PConfigParser.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
#include <sys/stat.h> 
#include <sys/types.h>
 
#include "data_all.h"
#include "pxml_utils.h"
 
#include "PMarkdownParser.h"
 
#include "PConfigParser.h"
 
 
PConfigParser::PConfigParser(const PString & installPrefix)
        :PGenericParser(installPrefix)
{
        initialisationPConfigParser(installPrefix);
}
 
 
PConfigParser::PConfigParser(const PConfigParser & other)
        :PGenericParser(other)
{
        copyPConfigParser(other);
}
 
PConfigParser::~PConfigParser(){
        saveMapFile();
}
 
 
PConfigParser & PConfigParser::operator = (const PConfigParser & other){
        copyPConfigParser(other);
        return *this;
}
 
 
void PConfigParser::copyPConfigParser(const PConfigParser & other){
        p_isAllowComment = other.p_isAllowComment;
        p_isAllowMath = other.p_isAllowMath;
}
 
 
bool PConfigParser::parseFile(){
        if(!p_run) return false;
        p_currentSource.setType(PLatexType::FILE);
        p_currentSource.setSourceFile(p_parser->getLocation().getFileName());
        p_currentSource.setSourceLine(1lu);
        p_currentSource.setLink("index.html");
        p_currentSource.setName(p_parser->getFileName().getFileName().eraseExtension());
        
        //To parse the file we need to read char by char until we get something we know
        while(!p_parser->isEndOfFile() && p_run){                       //If we are not at the end of the file
                if(parseAllLatexObj(p_currentSource, p_currentText)){}
                else{
                        incrementCurrentChar(p_currentText);
                }
        }
        playTextLatexObj(p_currentSource, p_currentText);
        
        return true;
}
 
void PConfigParser::preLoadFile(){
        //Save the current source
        clearLatexObj(p_currentSource);
        clearLatexObj(p_currentText);
        p_parser->setWhiteSpace("");
        p_parser->setSeparator("");
}
 
void PConfigParser::postLoadFile(){
        
}
 
 
void PConfigParser::initialisationPConfigParser(const PString & baseInstallPrefix){
        p_isAllowMath = true;
        p_isAllowComment = true;
}
 
 
bool PConfigParser::loadInclude(PLatexObj & parent, PLatexObj & textObj, const PPath & fileName){
        if(fileName == "") return false;
        PPath fileToBeUsed(fileName);
        bool removeTmpFilename(false);
        if(fileName.isSameBegining("http")){
                if(!wgetFile(fileName)){
                        errorAt();
                        std::cerr << "PConfigParser::loadInclude : cannot get file with url = '"<<fileName<<"'" << std::endl;
                        return true;
                }
                fileToBeUsed = fileName.getFileName();
                removeTmpFilename = true;
        }
        
        PString fileExtension(fileToBeUsed.getExtension());
        if(fileExtension == "md"){
                PMarkdownParser mdParser(*this);
                
                bool b = mdParser.load(fileToBeUsed);
                if(!b){return b;}
                PLatexObj & mainLatexObj = mdParser.getSource();
                std::vector<PLatexObj> & vecObj = mainLatexObj.getVecContent();
                for(std::vector<PLatexObj>::iterator it(vecObj.begin()); it != vecObj.end(); ++it){
                        addLatexObj(parent, *it);
                }
                copyPGenericParser(mdParser);
                return b;
        }
        
        PFileParser parser;
        p_listFileParser.push_back(parser);
        p_listFileParser.back().setSeparator(MULTI_PARSER_SEPARATORS_STRING);
        p_parser = &p_listFileParser.back();
        if(!p_parser->open(fileToBeUsed)){
                std::cerr << "PMultiFileParser::load : can't open file '" << fileToBeUsed << "'" << std::endl;
                return false;
        }
        p_parser->setWhiteSpace("");
        p_parser->setSeparator("");
        while(!p_parser->isEndOfFile() && p_run){
                long unsigned int currentPos = p_parser->getCurrentCharIdx();
                if(parseAllLatexObj(parent, textObj)){}
                else{
                        incrementCurrentChar(textObj);
                }
                
                if(currentPos == p_parser->getCurrentCharIdx() && !p_parser->isEndOfFile()){
                        std::cerr << "PMultiFileParser::load : the parser is stucked at the position :" << std::endl << "\t" << p_parser->getLocation() << std::endl;
                        p_run = false;
                }
        }
        if(p_run) playTextLatexObj(parent, textObj);
        p_listFileParser.pop_back();
        if(p_listFileParser.size() > 0lu) p_parser =  &p_listFileParser.back();
        else p_parser = NULL;
        if(removeTmpFilename){
                remove(fileToBeUsed.c_str());
        }
        return p_run;
}
 
 
bool PConfigParser::parseComplexMonoParam(PLatexObj & parent, PLatexObj & textObj, const PString & functionName, PLatexType::PLatexType type){
        if(!p_parser->isMatchToken(functionName)){return false;}
        playTextLatexObj(parent, textObj);
        PLatexObj tmp;
        tmp.setType(type);
        
        PString textOption(getOptionStringBetweenHook());
        tmp.setText(textOption);
        
        parseVecLatexObj(tmp, textObj, "{", "}");
        
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PConfigParser::parseAllLatexObj(PLatexObj & parent, PLatexObj & textObj){
        if(p_parser->isMatch("{")){}
        else if(p_parser->isMatch("}")){}
        else if(skipMonoParam("\\minitoc")){}
        else if(skipMonoParam("\\newpage")){}
        else if(skipMonoParam("\\centering")){}
        else if(skipMonoParam("\\def\\sgn")){}
        else if(skipMonoParam("\\,")){}
        else if(parsePercent(parent, textObj)){}
        else if(p_parser->isMatch(p_vecRemoveLatexKeyword) != ""){}
        else if(parseSpaceParagraphe(parent, textObj)){}
        else if(parseNewLine(parent, textObj)){}
        else if(parseRealNewLine(parent, textObj)){}
        else if(parseDots(parent, textObj)){}
        
        else if(parseMonoParam(parent, textObj, "\\url", PLatexType::URL)){}
        else if(parseGenericLatexObj(parent, textObj)){}
        else if(parseComplexMonoParam(parent, textObj, "\\footnote", PLatexType::FOOTNOTE)){}
        else if(parseComplexMonoParam(parent, textObj, "\\caption", PLatexType::CAPTION)){}
        
        else if(parseComplexMonoParam(parent, textObj, "\\wip", PLatexType::WORK_IN_PROGRESS)){}
        else if(parseComplexMonoParam(parent, textObj, "\\workinprogress", PLatexType::WORK_IN_PROGRESS)){}
        else if(parserDetails(parent, textObj)){}
        else if(parserQuote(parent, textObj)){}
        else if(parseComment(parent, textObj)){}
        else if(parseDebug(parent, textObj)){}
        else if(parseHref(parent, textObj)){}
        else if(parseIncludeGraphic(parent, textObj)){}
        else if(parseAddSpeaker(parent, textObj)){}
        else if(parseSaveSpeaker(parent, textObj)){}
        else if(parseTimeTable(parent, textObj)){}
        
        else if(parseSectionTitle(parent, textObj, "\\part*", PLatexType::PARTSTAR)){}
        else if(parseSectionTitle(parent, textObj, "\\chapter*", PLatexType::CHAPTERSTAR)){}
        else if(parseSectionTitle(parent, textObj, "\\section*", PLatexType::SECTIONSTAR)){}
        else if(parseSectionTitle(parent, textObj, "\\subsection*", PLatexType::SUBSECTIONSTAR)){}
        else if(parseSectionTitle(parent, textObj, "\\subsubsection*", PLatexType::SUBSUBSECTIONSTAR)){}
        
        else if(parseSectionTitle(parent, textObj, "\\part", PLatexType::PART)){}
        else if(parseSectionTitle(parent, textObj, "\\chapter", PLatexType::CHAPTER)){}
        else if(parseSectionTitle(parent, textObj, "\\section", PLatexType::SECTION)){}
        else if(parseSectionTitle(parent, textObj, "\\subsection", PLatexType::SUBSECTION)){}
        else if(parseSectionTitle(parent, textObj, "\\subsubsection", PLatexType::SUBSUBSECTION)){}
        
        else if(parseSectionTitle(parent, textObj, "\\bookpartseparator", PLatexType::BOOKPARTSEPARATOR)){}
        
        else if(parseEnvStringOnly(parent, textObj, "displaymath", PLatexType::DISPLAYMATH)){}
        else if(parseEnvStringOnly(parent, textObj, "equation", PLatexType::DISPLAYMATH)){}
        else if(parseEnvStringOnly(parent, textObj, "equation*", PLatexType::DISPLAYMATH)){}
        else if(parseEnvStringOnly(parent, textObj, "eqnarray", PLatexType::EQNARRAY)){}
        else if(parseEnvStringOnly(parent, textObj, "align*", PLatexType::EQNARRAY)){}
        else if(parseDoubleInlineMath(parent, textObj)){}
        else if(parseInlineMath(parent, textObj)){}
        
        else if(parseEnvironement(parent, textObj, "paragraph", PLatexType::PARAGRAPHE)){}
        else if(parseEnvironement(parent, textObj, "center", PLatexType::CENTER)){}
        else if(parseEnvironement(parent, textObj, "columns", PLatexType::COLUMNS)){}
        else if(parseEnvironement(parent, textObj, "column", PLatexType::COLUMN)){}
        
        else if(parseEnvironement(parent, textObj, "figure", PLatexType::FIGURE)){}
        else if(parseEnvironement(parent, textObj, "wrapfigure", PLatexType::FIGURE)){}
        else if(parseEnvironement(parent, textObj, "table", PLatexType::TABLE)){}
        else if(parseTabular(parent, textObj)){}
        else if(parseEnvironement(parent, textObj, "itemize", PLatexType::ITEMIZE)){}
        else if(parseEnvironement(parent, textObj, "enumerate", PLatexType::ENUMERATE)){}
        else if(parseItem(parent, textObj)){}
        
        else if(parserCallDot(parent, textObj)){}
        else if(parserSvgToPng(parent, textObj)){}
        
        else if(parseExtraEnvironement(parent, textObj)){}
        else if(parseExtraEnvironementFunction(parent, textObj)){}
        else if(parseExtraFunction(parent, textObj)){}
        else if(parseParserLanguage(parent, textObj)){}
        else if(parseParserLanguageFunction(parent, textObj)){}
        
        else if(parseIncludeFile(parent, textObj)){}
        else if(parseInputFile(parent, textObj)){}      //An other non sens of latex
        else if(parseVideo(parent, textObj)){}
        else if(parseBookMainPageLink(parent, textObj)){}
        else{
                return false;
        }
        return true;
}
 
 
bool PConfigParser::parseBookMainPageLink(PLatexObj & parent, PLatexObj & textObj){
        PLatexObj tmpParent;
        if(parseComplexMonoParam(tmpParent, textObj, "\\bookMainPageLink", PLatexType::BOOKMAINPAGELINK)){
                if(tmpParent.getVecContent().size() != 0lu){
                        p_bookMainPageLink = tmpParent.getVecContent().back();
                        std::cout << "PConfigParser::parseBookMainPageLink : Update main page link (nb element = "<<tmpParent.getVecContent().size()<<")" << std::endl;
                }
                return true;
        }else{
                return false;
        }
}
 
 
 
bool PConfigParser::parseSpaceParagraphe(PLatexObj & parent, PLatexObj & textObj){
        if(!isMatch("\\spaceparagraphe")){return false;}
        playTextLatexObj(parent, textObj);
        getOptionStringBetweenBraces();
        PLatexObj tmp;
        tmp.setType(PLatexType::SPACEPARAGRAPH);
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PConfigParser::parseNewLine(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatch("\n\n")){return false;}
        playTextLatexObj(parent, textObj);
        PLatexObj tmp;
        tmp.setType(PLatexType::AUTOSPACEPARAGRAPH);
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PConfigParser::parseRealNewLine(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatch("\\\\")){return false;}
        playTextLatexObj(parent, textObj);
        PLatexObj tmp;
        tmp.setType(PLatexType::NEWLINE);
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PConfigParser::parseDots(PLatexObj & parent, PLatexObj & textObj){
        if(!isMatch("\\dots")){return false;}
        playTextLatexObj(parent, textObj);
        getOptionStringBetweenBraces();
        PLatexObj tmp;
        tmp.setType(PLatexType::TEXT);
        tmp.setText("... ");
        addLatexObj(parent, tmp);
        return true;
}
 
bool PConfigParser::parseIncludeFile(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\include")){return false;}
        playTextLatexObj(parent, textObj);
        PString fileName(getStringBetweenBraces("\\include"));
        
        PPath fileToBeLoaded(fileName);
        if(fileToBeLoaded.size() != 0lu){
                if(fileToBeLoaded[0] != '/'){
                        fileToBeLoaded = p_parser->getFileName().getParentDirectory() / fileToBeLoaded;
                }
        }
        return loadInclude(parent, textObj, fileToBeLoaded);
}
 
 
bool PConfigParser::parseInputFile(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\input")){return false;}
        playTextLatexObj(parent, textObj);
        PString fileName(getStringBetweenBraces("\\input"));
        
        PPath fileToBeLoaded(fileName);
        if(fileToBeLoaded.size() != 0lu){
                if(fileToBeLoaded[0] != '/'){
                        fileToBeLoaded = p_parser->getFileName().getParentDirectory() / fileToBeLoaded;
                }
        }
        return loadInclude(parent, textObj, fileToBeLoaded);
}
 
 
bool PConfigParser::parseVideo(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\video")){return false;}
        playTextLatexObj(parent, textObj);
        PARSER_SKIP_SPACE
        char ch = p_parser->getCurrentCh();
        PString prevToken(""), option("400");
        prevToken += ch;
        if(ch == '['){                                  //We skip the options for now
                p_parser->getNextChar();
                option = p_parser->getUntilKeyWithoutPatern("]");
                prevToken += option;
                ch = p_parser->getCurrentCh();
        }
        PARSER_SKIP_SPACE
        if(ch != '{'){
                errorAt();
                std::cerr << "PConfigParser::parseVideo : expect '{' after '"+prevToken+"' instead of '"<<ch<<"'" << std::endl;
                stopParsing();
                return true;
        }
        p_parser->getNextChar();
        PPath fileName(p_parser->getUntilKeyWithoutPatern("}"));
        
        if(fileName.getExtension() != "mp4"){
                errorAt();
                std::cerr << "PConfigParser::parseVideo : use video '"<<fileName<<"' because the extension has to be '.mp4'" << std::endl;
                stopParsing();
                return true;
        }
        
        PLatexObj tmp;
        tmp.setText(option);
        tmp.setType(PLatexType::VIDEO);
        
        PString buildFileName("");
        if(!fileName.isSameBegining("http")){
                PPath fileToBeUsed(getAbsoluteFileName(fileName));
                if(fileToBeUsed.checkFileBegning("http")){              //If the file contains an url, we replace it by the url
                        buildFileName = fileToBeUsed.loadFileContent();
                }else{          //Otherwise, we just copy the file
                        buildFileName = copyFile(PPath(LATEX_VIDEO_OUTPUT_DIR), fileName);
                }
        }else{
                buildFileName = fileName;
        }
        if(buildFileName == ""){return true;}
        tmp.setName(buildFileName);
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PConfigParser::parserDetails(PLatexObj & parent, PLatexObj & textObj){
        std::vector<PString> vecBeginPatern(getBeginSeqEnv("detail"));
        if(!p_parser->isMatchSeq(vecBeginPatern)){return false;}
        playTextLatexObj(parent, textObj);
        //Parse the summary
        PLatexObj summaryObj;
        summaryObj.setType(PLatexType::SUMMARY);
        parseVecLatexObj(summaryObj, textObj, "{", "}");
        
        PLatexObj env;
        env.setType(PLatexType::DETAILS);
        env.setName("details");
        env.setBalise("details");
        
        addLatexObj(env, summaryObj);
        //Parse the environement
        PLatexObj tmpText;
        tmpText.setType(PLatexType::TEXT);
        std::vector<PString> vecPatern(getEndSeqEnv("detail"));
        
        while(!p_parser->isEndOfFile() && !p_parser->isMatchSeq(vecPatern) && p_run){
                if(parseAllLatexObj(env, tmpText)){}
                else{
                        incrementCurrentChar(tmpText);
                }
        }
        playTextLatexObj(env, tmpText);
        addLatexObj(parent, env);
        return true;
}
 
 
bool PConfigParser::parserQuote(PLatexObj & parent, PLatexObj & textObj){
        std::vector<PString> vecBeginPatern(getBeginSeqEnv("quote"));
        if(!p_parser->isMatchSeq(vecBeginPatern)){return false;}
        playTextLatexObj(parent, textObj);
        
        PLatexObj env;
        env.setType(PLatexType::QUOTE);
        
        PLatexObj authorQuote;
        authorQuote.setType(PLatexType::FUNCTION);
        authorQuote.setName("rightline");
        authorQuote.setBalise("div");
        parseVecLatexObj(authorQuote, textObj, "{", "}");
        
        PLatexObj contentQuote;
        contentQuote.setType(PLatexType::CENTER);
        
        //Parse the environement
        PLatexObj tmpText;
        tmpText.setType(PLatexType::TEXT);
        std::vector<PString> vecPatern(getEndSeqEnv("quote"));
        
        while(!p_parser->isEndOfFile() && !p_parser->isMatchSeq(vecPatern) && p_run){
                if(parseAllLatexObj(contentQuote, tmpText)){}
                else{
                        incrementCurrentChar(tmpText);
                }
        }
        playTextLatexObj(contentQuote, tmpText);
        
        addLatexObj(env, contentQuote);
        addLatexObj(env, authorQuote);
        
        addLatexObj(parent, env);
        return true;
}
 
 
bool PConfigParser::parserCallDot(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\calldot")){return false;}
        playTextLatexObj(parent, textObj);
        p_parser->getNextChar();
        PLatexObj tmp;
        tmp.setType(PLatexType::CALLDOT);
        PString baseContent(p_parser->getUntilKeyWithoutPaternRecurse("}", "{"));
        PString fileName(baseContent);
        tmp.setName(fileName);
        tmp.setText(p_parser->getFileName());
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PConfigParser::parserSvgToPng(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\svgtopng")){return false;}
        playTextLatexObj(parent, textObj);
        p_parser->getNextChar();
        PLatexObj tmp;
        tmp.setType(PLatexType::SVGTOPNG);
        PString fileName(p_parser->getUntilKeyWithoutPatern("}"));
        tmp.setName(fileName);
        tmp.setText(p_parser->getFileName());
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PConfigParser::parseComment(PLatexObj & parent, PLatexObj & textObj){
        if(!p_isAllowComment){return false;}
        if(!p_parser->isMatch("%")){return false;}
        playTextLatexObj(parent, textObj);
        PString comment(p_parser->getUntilKeyWithoutPatern("\n"));
        PLatexObj tmp;
        tmp.setType(PLatexType::COMMENT);
        tmp.setName(comment);
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PConfigParser::parseDebug(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\debug")){return false;}
        if(p_isDebugMode){
                playTextLatexObj(parent, textObj);
                PLatexObj tmp;
                tmp.setType(PLatexType::DEBUG);
                PString text(getStringBetweenBraces("\\debug"));
                tmp.setName(text);
                addLatexObj(parent, tmp);
        }
        return true;
}
 
 
bool PConfigParser::parseHref(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\href")){return false;}
        playTextLatexObj(parent, textObj);
        PLatexObj tmp;
        tmp.setType(PLatexType::HREF);
        PString link(getStringBetweenBraces("\\href"));
        tmp.setName(link);
 
        parseVecLatexObj(tmp, textObj, "{", "}");
        if(!tmp.getName().isSameBegining("http") && !tmp.getName().isSameBegining("https")){
                PPath buildFileName(copyFile(PPath(LATEX_RESSOURCES_OUTPUT_DIR), link));
                if(buildFileName == ""){
                        if(PPath(tmp.getName()).getExtension() != "html"){
                                errorAt();
                                std::cerr << "PConfigParser::parseHref : cannot copy file '"<<link<<"' in '" LATEX_RESSOURCES_OUTPUT_DIR "'" << std::endl;
                                return true;
                        }
                        buildFileName = link;
                }
                tmp.setName(buildFileName);
        }
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PConfigParser::parsePercent(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatch("\\%")){return false;}
        playTextLatexObj(parent, textObj);
        PLatexObj tmp;
        tmp.setType(PLatexType::PERCENT);
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PConfigParser::parseSectionTitle(PLatexObj & parent, PLatexObj & textObj, const PString & functionName, PLatexType::PLatexType type){
        if(!p_parser->isMatchToken(functionName)){return false;}
        playTextLatexObj(parent, textObj);
        PLatexObj tmp;
        tmp.setType(type);
        tmp.setSourceFile(p_parser->getLocation().getFileName());
        tmp.setSourceLine(p_parser->getLocation().getLine());
        
        PString textOption(getOptionStringBetweenHook());
        tmp.setText(textOption);
        PLatexObj objTitle;
        parseVecLatexObj(objTitle, textObj, "{", "}");
        tmp.setComplexTitle(objTitle.getVecContent());
        addLatexObj(parent, tmp);
        return true;
}
 
 
void PConfigParser::parseVecLatexObj(PLatexObj & parent, PLatexObj & textObj, const PString & beginPatern, const PString & endPatern){
        if(beginPatern != ""){                                  //If we check the begin patern
                if(!p_parser->isMatch(beginPatern)){    //And it does not match
                        return;                                 //We stop
                }
        }
        PARSER_SKIP_SPACE
        while(!p_parser->isEndOfFile() && p_run && !p_parser->isMatch(endPatern)){
                long unsigned int currentPos = p_parser->getCurrentCharIdx();
                
                if(parseAllLatexObj(parent, textObj)){}
                else{
                        incrementCurrentChar(textObj);
                }
                if(currentPos == p_parser->getCurrentCharIdx() && !p_parser->isEndOfFile()){
                        std::cerr << "PConfigParser::parseVecLatexObj : the parser is stucked at the position :" << std::endl << "\t" << p_parser->getLocation() << std::endl;
                        p_run = false;
                }
        }
        if(p_run) playTextLatexObj(parent, textObj);
}
 
 
bool PConfigParser::parseIncludeGraphic(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\includegraphics")){return false;}
        playTextLatexObj(parent, textObj);
        PARSER_SKIP_SPACE
        char ch = p_parser->getCurrentCh();
        PString prevToken(""),option("");
        prevToken += ch;
        if(ch == '['){                                  //We skip the options for now
                p_parser->getNextChar();
                option = p_parser->getUntilKeyWithoutPatern("]");
                prevToken += option;
                ch = p_parser->getCurrentCh();
        }
        PARSER_SKIP_SPACE
        if(ch != '{'){
                errorAt();
                std::cerr << "PConfigParser::parseIncludeGraphic : expect '{' after '"+prevToken+"' instead of '"<<ch<<"'" << std::endl;
                stopParsing();
                return "";
        }
        p_parser->getNextChar();
        PString imageFile(p_parser->getUntilKeyWithoutPatern("}"));
        PLatexObj tmp;
        tmp.setType(PLatexType::IMAGE);
        
        PString buildFileName("");
        if(!imageFile.isSameBegining("http")){
                buildFileName = copyFile(PPath(LATEX_IMAGE_OUTPUT_DIR), imageFile);
        }else{
                buildFileName = imageFile;
        }
        if(buildFileName == ""){return true;}
        tmp.setName(buildFileName);
        tmp.setText(option);
        
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PConfigParser::parseAddSpeaker(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\addspeakers")){return false;}
        playTextLatexObj(parent, textObj);
        PPath speakerConfig = getOptionStringBetweenBraces();
        PPath speakerFile = p_parser->getFileName().getParentDirectory() / speakerConfig;
        
        if(!ptimetable_loadSpeaker(p_vecSpeaker, speakerFile)){
                errorAt();
                std::cerr << "PConfigParser::parseTimeTable : cannot parse speakers configuration '"+speakerFile+"'" << std::endl;
                stopParsing();
                return true;
        }
        
        return true;
}
 
 
bool PConfigParser::parseSaveSpeaker(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\savespeakers")){return false;}
        playTextLatexObj(parent, textObj);
        getOptionStringBetweenBraces();
        
        pspeaker_tex(parent.getVecContent(), p_vecSpeaker, "sec_full_speakers");
        return true;
}
 
 
bool PConfigParser::parseTimeTable(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\timetable")){return false;}
        playTextLatexObj(parent, textObj);
        PPath timetableConfig = getOptionStringBetweenBraces();
        PPath timeTableFile = p_parser->getFileName().getParentDirectory() / timetableConfig;
        //We have to try to load speakers in some are defined in the timetable configuration
        //But we need also to add \addspeakers function to update a map of speakers in the PGenericParser
        
        //Load the timetable toml config
        PTimeTable timetable;
        bool isAlreadyDefinedSpeaker = p_vecSpeaker.size() != 0lu;
        if(isAlreadyDefinedSpeaker){
                timetable.setVecSpeaker(p_vecSpeaker);
        }
        if(!ptimetable_load(timetable, timeTableFile)){
                errorAt();
                std::cerr << "PConfigParser::parseTimeTable : cannot parse timetable configuration '"+timeTableFile+"'" << std::endl;
                stopParsing();
                return true;
        }
        //Update begin and end time of blocks
        ptimetable_updateEndTime(timetable);
        //Create the HTML PLatexObj
        if(!ptimetable_tex(parent.getVecContent(), timetable, PPath(LATEX_INVITATION_OUTPUT_DIR), !isAlreadyDefinedSpeaker)){
                errorAt();
                std::cerr << "PConfigParser::parseTimeTable : cannot save timetable '"+timeTableFile+"'" << std::endl;
                stopParsing();
        }
        return true;
}
 
 
bool PConfigParser::parseEnvironement(PLatexObj & parent, PLatexObj & textObj, const PString & environementName, PLatexType::PLatexType type){
        std::vector<PString> vecPatern(getBeginSeqEnv(environementName));
        if(!p_parser->isMatchSeq(vecPatern)){return false;}
        return parseEnvironementContent(parent, textObj, environementName, type, true, true, "div");
}
 
 
bool PConfigParser::parseEnvironementContent(PLatexObj & parent, PLatexObj & textObj, const PString & environementName,
                                        PLatexType::PLatexType type, bool isAllowComment, bool isAllowMath, const PString & envBalise)
{
        playTextLatexObj(parent, textObj);
        PLatexObj env;
        env.setType(type);
        env.setName(environementName);
        env.setBalise(envBalise);
        PLatexObj tmpText;
        tmpText.setType(PLatexType::TEXT);
        std::vector<PString> vecPatern(getEndSeqEnv(environementName));
        
        bool saveIsAllowComment(p_isAllowComment), saveIsAllowMath(p_isAllowMath);
        p_isAllowComment = isAllowComment;
        p_isAllowMath = isAllowMath;
        while(!p_parser->isEndOfFile() && !p_parser->isMatchSeq(vecPatern) && p_run){
                if(parseAllLatexObj(env, tmpText)){}
                else{
                        incrementCurrentChar(tmpText);
                }
        }
        p_isAllowComment = saveIsAllowComment;
        p_isAllowMath = saveIsAllowMath;
        
        playTextLatexObj(env, tmpText);
        addLatexObj(parent, env);
        return true;
}
 
 
bool PConfigParser::parseTabular(PLatexObj & parent, PLatexObj & textObj){
        std::vector<PString> vecBeginPatern(getBeginSeqEnv("tabular"));
        if(!p_parser->isMatchSeq(vecBeginPatern)){return false;}
        playTextLatexObj(parent, textObj);
        getOptionStringBetweenBraces(); //Remove tabular option
        PLatexObj envTabular;
        envTabular.setType(PLatexType::TABULAR);
        envTabular.setName("tabular");
        
        std::vector<PString> vecEndPatern(getEndSeqEnv("tabular"));
        
        while(!p_parser->isEndOfFile() && !p_parser->isMatchSeq(vecEndPatern) && p_run){        //Parse all rows
                PLatexObj rowObj;
                rowObj.setType(PLatexType::TABROW);
                while(!p_parser->isEndOfFile() && !p_parser->isMatchSeq(vecEndPatern, true) &&
                                                        !p_parser->isMatch("\\\\") && p_run)    //Parse one row
                {
                        PLatexObj cellObj;
                        cellObj.setType(PLatexType::TABCELL);
                        
                        PLatexObj tmpText;
                        tmpText.setType(PLatexType::TEXT);
                        //Parse all cells
                        while(!p_parser->isEndOfFile() && !p_parser->isMatchSeq(vecEndPatern, true) &&
                                                        !p_parser->isMatchRewind("\\\\") &&
                                                        !p_parser->isMatch("&") && p_run)       //Parse one cell
                        {
                                if(parseAllLatexObj(cellObj, tmpText)){}
                                else{
                                        incrementCurrentChar(tmpText);
                                }
                        }
                        playTextLatexObj(cellObj, tmpText, true);
                        if(cellObj.getVecContent().size() != 0lu){
                                rowObj.getVecContent().push_back(cellObj);      //Add cell in row
                        }
                }
                if(rowObj.getVecContent().size() != 0lu){
                        envTabular.getVecContent().push_back(rowObj);   //Add row in tabular
                }
        }
        
        addLatexObj(parent, envTabular);
        return true;
}
 
 
bool PConfigParser::parseEnvStringOnly(PLatexObj & parent, PLatexObj & textObj, const PString & environementName, PLatexType::PLatexType type){
        p_parser->pushPosition();
        if(!p_parser->isMatchToken("\\begin")){return false;}
        PString envName(getStringBetweenBraces("\\begin").eraseFirstLastChar(" \t\n"));
        if(environementName != envName){
                p_parser->popPosition();
                return false;
        }
        playTextLatexObj(parent, textObj);
        PString envContent(p_parser->getUntilKeyWithoutPatern("\\end{"+environementName+"}"));
        
        PLatexObj tmp;
        tmp.setType(type);
        tmp.setText(envContent);
        
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PConfigParser::parseInlineMath(PLatexObj & parent, PLatexObj & textObj){
        if(!p_isAllowMath){return false;}
        if(!p_parser->isMatch("$", "\\")){return false;}
        playTextLatexObj(parent, textObj);
        PString mathText(p_parser->getUntilKeyWithoutPatern("$"));
        PLatexObj inlineMath;
        inlineMath.setType(PLatexType::INLINEMATH);
        inlineMath.setText(mathText);
        
        addLatexObj(parent, inlineMath);
        return true;
}
 
 
bool PConfigParser::parseDoubleInlineMath(PLatexObj & parent, PLatexObj & textObj){
        if(!p_isAllowMath){return false;}
        if(!p_parser->isMatch("$$", "\\")){return false;}
        playTextLatexObj(parent, textObj);
        PString mathText(p_parser->getUntilKeyWithoutPatern("$$"));
        PLatexObj inlineMath;
        inlineMath.setType(PLatexType::DISPLAYMATH);
        inlineMath.setText(mathText);
        
        addLatexObj(parent, inlineMath);
        return true;
}
 
 
bool PConfigParser::parseStringAndGoBack(const PString & str){
        p_parser->pushPosition();
        bool b = p_parser->isMatch(str);
        p_parser->popPosition();
        return b;
}
 
 
bool PConfigParser::parseItem(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatch("\\item")){return false;}
        playTextLatexObj(parent, textObj);
        
        PLatexObj env;
        env.setType(PLatexType::ITEM);
        
        PLatexObj tmpText;
        tmpText.setType(PLatexType::TEXT);
        
        std::vector<PString> vecPaternItemize;
        vecPaternItemize.push_back("\\end");
        vecPaternItemize.push_back("{");
        vecPaternItemize.push_back("itemize");
        vecPaternItemize.push_back("}");
        
        std::vector<PString> vecPaternEnumerate;
        vecPaternEnumerate.push_back("\\end");
        vecPaternEnumerate.push_back("{");
        vecPaternEnumerate.push_back("enumerate");
        vecPaternEnumerate.push_back("}");
        
        while(!p_parser->isEndOfFile() && !p_parser->isMatchSeq(vecPaternItemize, true) &&
                                !p_parser->isMatchSeq(vecPaternEnumerate, true) &&
                                !parseStringAndGoBack("\\item") && p_run)
        {
                if(parseAllLatexObj(env, tmpText)){}
                else{
                        incrementCurrentChar(tmpText);
                }
        }
        playTextLatexObj(env, tmpText);
        
        addLatexObj(parent, env);
        
        
        return true;
}
 
 
bool PConfigParser::parseParserLanguage(PLatexObj & parent, PLatexObj & textObj){
        if(p_vecNameExtraParser.size() == 0lu){return false;}
        p_parser->pushPosition();
        if(!p_parser->isMatchToken("\\begin")){return false;}
        PARSER_SKIP_SPACE
        char ch = p_parser->getCurrentCh();
        if(ch != '{'){
                p_parser->popPosition();        //This is not the expected environement
                return false;
        }
        p_parser->getNextChar();
        PString matchEnv(p_parser->isMatch(p_vecNameExtraParser));
        if(matchEnv == ""){
                p_parser->popPosition();
                return false;
        }
        PARSER_SKIP_SPACE
        ch = p_parser->getCurrentCh();
        if(ch != '}'){
                p_parser->popPosition();        //This is not the expected environement
                return false;
        }
        p_parser->getNextChar();
        playTextLatexObj(parent, textObj);
        PLatexObj tmp;
        tmp.setType(PLatexType::PARSER);
        tmp.setName(matchEnv);
        
        PParserEnv parser(getParserEnv(p_vecExtraParser, matchEnv));
        char saveEscapeChar = p_parser->getEscapeChar();
        p_parser->setEscapeChar('\0');
        PString inputFileContent(p_parser->getUntilKeyWithoutPatern("\\end{"+matchEnv+"}").eraseFirstLastChar(" \n") + "\n");
        p_parser->setEscapeChar(saveEscapeChar);
        tmp.setNbline(inputFileContent.count('\n'));
        
        PString envContent(parser_makeHighlighting(inputFileContent, parser));
        tmp.setText(envContent);
        
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PConfigParser::parseParserLanguageFunction(PLatexObj & parent, PLatexObj & textObj){
        if(p_vecNameFunctionExtraParser.size() == 0lu){return false;}
        p_parser->pushPosition();
        PString matchFunc(p_parser->isMatch(p_vecNameFunctionExtraParser));
        if(matchFunc == ""){
                p_parser->popPosition();
                return false;
        }
        PARSER_SKIP_SPACE
        char ch = p_parser->getCurrentCh();
        if(ch != '{'){
                p_parser->popPosition();        //This is not the expected environement
                return false;
        }
        playTextLatexObj(parent, textObj);
        PLatexObj tmp;
        tmp.setType(PLatexType::PARSER);
        PString matchEnv(matchFunc.eraseChar('\\'));
        tmp.setName(matchEnv);
        
        p_parser->getNextChar();
        PString baseContent(p_parser->getUntilKeyWithoutPaternRecurse("}", "{"));
        PPath fileName(baseContent);
        if(fileName != ""){
                if(fileName[0] != '/'){
                        fileName = p_parser->getFileName().getParentDirectory() / fileName;
                }
                PParserEnv parser(getParserEnv(p_vecExtraParser, matchEnv));
                PString inputFileContent("");
                if(fileName.isFileExist()){
                        inputFileContent = fileName.loadFileContent().eraseFirstLastChar(" \n") + "\n";
                }else{
                        inputFileContent = baseContent + " ";
                }
                tmp.setNbline(inputFileContent.count('\n'));    //The first line has no \n, if there is a \n there are two lines
                
                PString envContent(parser_makeHighlighting(inputFileContent, parser));
                tmp.setText(envContent);
                
                addLatexObj(parent, tmp);
        }
        
        return true;
}
 
 
bool PConfigParser::parseExtraEnvironement(PLatexObj & parent, PLatexObj & textObj){
        if(p_vecNameExtraEnv.size() == 0lu){return false;}
        p_parser->pushPosition();
        if(!p_parser->isMatch("\\begin")){return false;}
        PARSER_SKIP_SPACE
        char ch = p_parser->getCurrentCh();
        if(ch != '{'){
                errorAt();
                std::cerr << "PConfigParser::parseExtraEnvironement : expect '{' after '\\begin' instead of '"<<ch<<"'" << std::endl;
                stopParsing();
                return true;
        }
        p_parser->getNextChar();
        PString matchEnv(p_parser->isMatch(p_vecNameExtraEnv));
        if(matchEnv == ""){
                p_parser->popPosition();
                return false;
        }
        PARSER_SKIP_SPACE
        ch = p_parser->getCurrentCh();
        if(ch != '}'){
                errorAt();
                std::cerr << "PConfigParser::parseExtraEnvironement : expect '}' after '\\begin{matchEnv' instead of '"<<ch<<"'" << std::endl;
                stopParsing();
                return true;
        }
        p_parser->getNextChar();
        return parseExtraEnvironementContent(parent, textObj, matchEnv, PLatexType::ENVIRONEMENT);
}
 
 
bool PConfigParser::parseExtraEnvironementContent(PLatexObj & parent, PLatexObj & textObj, const PString & environementName, PLatexType::PLatexType type){
        PEnvironement & configEnv = p_vecExtraEnv[environementName];
        return parseEnvironementContent(parent, textObj, environementName,
                                type, configEnv.getIsAllowComment(), configEnv.getIsAlloxMath(), configEnv.getBalise());
}
 
 
 
bool PConfigParser::parseExtraEnvironementFunction(PLatexObj & parent, PLatexObj & textObj){
        if(p_vecNameFunctionExtraEnv.size() == 0lu){return false;}
        p_parser->pushPosition();
        PString matchFunc(p_parser->isMatch(p_vecNameFunctionExtraEnv));
        if(matchFunc == ""){
                p_parser->popPosition();
                return false;
        }
        PARSER_SKIP_SPACE
        char ch = p_parser->getCurrentCh();
        if(ch != '{'){
                p_parser->popPosition();        //This is not the expected environement
                return false;
        }
        playTextLatexObj(parent, textObj);
        PLatexObj tmp;
        tmp.setType(PLatexType::ENVIRONEMENT);
        
        PString matchEnv(matchFunc.eraseChar('\\'));
        tmp.setName(matchEnv);
        
        PEnvironement & configEnv = p_vecExtraEnv[matchEnv];
        tmp.setBalise(configEnv.getBalise());
        
        p_parser->getNextChar();
        PPath fileName(p_parser->getUntilKeyWithoutPatern("}"));
        if(fileName != ""){
                if(fileName[0] != '/'){
                        fileName = p_parser->getFileName().getParentDirectory() / fileName;
                }
                PString envContent(fileName.loadFileContent().eraseFirstLastChar(" \t\n"));
                PLatexObj content;
                content.setType(PLatexType::TEXT);
                content.setText(envContent);
                tmp.getVecContent().push_back(content);
                addLatexObj(parent, tmp);
        }
        return true;
}
 
 
bool PConfigParser::parseExtraFunction(PLatexObj & parent, PLatexObj & textObj){
        if(p_vecNameExtraFunction.size() == 0lu){return false;}
        p_parser->pushPosition();
        PString matchFunc(p_parser->isMatch(p_vecNameExtraFunction));
        if(matchFunc == ""){
                p_parser->popPosition();
                return false;
        }
        if(!isMatchRewind("{")){
                p_parser->popPosition();        //This is not the expected environement
                return false;
        }
        playTextLatexObj(parent, textObj);
        PLatexObj tmp;
        tmp.setType(PLatexType::FUNCTION);
        PString matchEnv(matchFunc.eraseChar('\\'));
        tmp.setName(matchEnv);
        
        PEnvironement & configEnv = p_vecExtraFunction[matchEnv];
        tmp.setBalise(configEnv.getBalise());
        
        parseVecLatexObj(tmp, textObj, "{", "}");
        
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PConfigParser::skipMonoParam(const PString & functionName){
        if(!p_parser->isMatchToken(functionName)){return false;}
        //Skip hook option
        getOptionStringBetweenHook();
        //Skip brace content
        getOptionStringBetweenBraces();
        return true;
}