parser_utils.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "PFileParser.h"
#include "parser_utils.h"
 
 
PString convertStrToHtml(const PString & str){
        PString buffer(str.replace("&", "&"));
        buffer = buffer.replace("<", "&lt;");
        buffer = buffer.replace(">", "&gt;");
        buffer = buffer.replace("\\\"\\\\\\\"", "&bsol;&quot;&bsol;&bsol;&bsol;&quot;");
        buffer = buffer.replace("\\\\\\\"\\\"", "&bsol;&bsol;&bsol;&quot;&bsol;&quot;");
        buffer = buffer.replace("\"", "&quot;");
        buffer = buffer.replace("\\dots{}", "...");
        buffer = buffer.replace("\\'e", "é");
        buffer = buffer.replace("\\'", "");
        buffer = buffer.replace("~", "&#126;");
        buffer = buffer.replace("\\and", "&amp;");
//      buffer = buffer.replace("\\\\", "<br />");
        buffer = buffer.replace("\\,", "");
        buffer = buffer.replace("\\", "&bsol;");
        return buffer;
}
 
 
PString convertCharToHtml(char ch){
        switch(ch){
                case '\\':
                        return "&bsol;";
                case '&':
                        return "&amp;";
                case '<':
                        return "&lt;";
                case '>':
                        return "&gt;";
                case '~':
                        return "&#126;";
                default:
                        break;
        }
        PString tmp("");
        tmp += ch;
        return tmp;
}
 
 
PParserEnv getParserEnv(const PVecParserEnv & vecParser, const PString & nameParser){
        const std::vector<PParserEnv> & vecPars = vecParser.getVecEnv();
        for(std::vector<PParserEnv>::const_iterator it(vecPars.begin()); it != vecPars.end(); ++it){
                if(it->getName() == nameParser){
                        return *it;
                }
        }
        PParserEnv out;
        return out;
}
 
 
void incrementCurrentChar(PFileParser & fileParser, PString & textObj){
        //If nothing is known I need to save the current char in the MACRO TEXT
        char ch = fileParser.getCurrentCh();
        textObj += convertCharToHtml(ch);
        fileParser.getNextChar();
}
 
 
void playTextLatexObj(PString & parent, PString & textObj){
        if(textObj != ""){
                parent += textObj;
                textObj = "";
        }
}
 
 
 
bool parser_parseKeyword(PString & out, PString & textObj, PFileParser & fileParser, const PContext & context){
        PString strBegin(context.getBegin()), strEnd(context.getEnd());
        PString strNotAfterBegin(context.getNotAfterBegin());
        PString strNotBeforeBegin(context.getNotBeforeBegin());
        PString strNotBeforeEnd(context.getNotBeforeEnd());
        
        bool parseUntilEnd(false), isFind(false);
        if(strBegin != ""){
                fileParser.pushPosition();
                if(strNotBeforeBegin == "" || (strNotBeforeBegin != "" && !fileParser.isMatch(strNotBeforeBegin))){
                        if(fileParser.isMatch(strBegin)){
                                if(strNotAfterBegin != ""){
                                        parseUntilEnd = !fileParser.isMatch(strNotAfterBegin);
                                }else{
                                        parseUntilEnd = true;
                                }
                        }
                }
                if(parseUntilEnd){
                        if(strEnd != ""){
                                playTextLatexObj(out, textObj);
                                PString content("");
                                if(strNotBeforeEnd != ""){
//                                      content = fileParser.getUntilKeyWithoutPaternRecurseExclude(strEnd, strBegin, strNotBeforeEnd);
                                        content = fileParser.getUntilKeyWithoutPaternExclude(strEnd, strNotBeforeEnd);
                                }else{
//                                      content = fileParser.getUntilKeyWithoutPaternRecurse(strEnd, strBegin);
                                        content = fileParser.getUntilKeyWithoutPatern(strEnd);
                                }
                                out += "<span class=\""+context.getName()+"\">" + convertStrToHtml(strBegin + content + strEnd) + "</span>";
                                isFind = true;
                        }else{
                                fileParser.popPosition();
                        }
                }else{
                        fileParser.popPosition();
                }
        }
        const PVecString & vecKeyword = context.getVecKeyword();
        if(vecKeyword.size() != 0lu){
                PString matchString(fileParser.isMatchToken(vecKeyword));
                if(matchString != ""){
                        playTextLatexObj(out, textObj);
                        out += "<span class=\""+context.getName()+"\">" + convertStrToHtml(matchString) + "</span>";
                        isFind = true;
                }
        }
        const PVecString & vecDelimiter= context.getVecDelimiter();
        if(vecDelimiter.size() != 0lu){
                PString matchString(fileParser.isMatch(vecDelimiter));
                if(matchString != ""){
                        playTextLatexObj(out, textObj);
                        out += "<span class=\""+context.getName()+"\">" + convertStrToHtml(matchString) + "</span>";
                        isFind = true;
                }
        }
        const PVecParseStep & vecStep = context.getSeq().getVecStep();
        if(vecStep.size() != 0lu){
                PString res(fileParser.isMatch(context.getSeq()));
                if(res != ""){
                        playTextLatexObj(out, textObj);
                        out += "<span class=\""+context.getName()+"\">" + convertStrToHtml(res) + "</span>";
                        isFind = true;
                }
        }
        
        return isFind;
}
 
 
 
bool parser_parseKeyword(PString & out, PString & textObj, PFileParser & fileParser, const PParserEnv & parser){
        const PVecContext & vecContext = parser.getVecContext();
        PVecContext::const_iterator it(vecContext.begin());
        bool isSearch(true);
        while(it != vecContext.end() && isSearch){
                isSearch = !parser_parseKeyword(out, textObj, fileParser, *it);
                ++it;
        }
        return !isSearch;
}
 
 
PString parser_makeHighlighting(const PString & strContent, const PParserEnv & parser){
        PString out(""), tmpText("");
        PFileParser fileParser;
        fileParser.setEscapeChar('\0');
        fileParser.setWhiteSpace("");
        fileParser.setFileContent(strContent);
        
        while(!fileParser.isEndOfFile()){
                if(parser_parseKeyword(out, tmpText, fileParser, parser)){}
                else{
                        PString plainText(fileParser.getStrComposedOf(parser.getPlainText()));
                        if(plainText == ""){
                                incrementCurrentChar(fileParser, tmpText);
                        }else{
                                tmpText += plainText;
                        }
                }
        }
        playTextLatexObj(out, tmpText);
        return out;
}
 
 
PLatexObj* getLastPLatexObj(PLatexObj & obj){
        PLatexType::PLatexType type = obj.getType();
        PVecLatexObj & vecObj = obj.getVecContent();
        if(vecObj.size() != 0lu){
                if(type == PLatexType::CAPTION){return &obj;}
                PLatexObj* outPtr = NULL;
                PVecLatexObj::reverse_iterator it(vecObj.rbegin());
                while(outPtr == NULL && it != vecObj.rend()){
                        outPtr = getLastPLatexObj(*it);
                        ++it;
                }
                return outPtr;
        }else{  //No other content
                if(type == PLatexType::TEXT){return NULL;}      //Pure text cannot recieved label
                else{return &obj;}
        }
}