PGenericParser.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "data_all.h"
#include "pxml_utils.h"
#include "PConfigParser.h"
#include "PLatexObj/platexobj_text.h"
 
#include "PGenericParser.h"
 
 
bool wgetFile(const PString& url){
        PString command("wget \""+url+"\"");
        return system(command.c_str()) != 0;
}
 
 
PVecString getBeginSeqEnv(const PString & envName){
        PVecString vecEndPatern;
        vecEndPatern.push_back("\\begin");
        vecEndPatern.push_back("{");
        vecEndPatern.push_back(envName);
        vecEndPatern.push_back("}");
        return vecEndPatern;
}
 
 
PVecString getEndSeqEnv(const PString & envName){
        PVecString vecEndPatern;
        vecEndPatern.push_back("\\end");
        vecEndPatern.push_back("{");
        vecEndPatern.push_back(envName);
        vecEndPatern.push_back("}");
        return vecEndPatern;
}
 
 
PGenericParser::PGenericParser(const PString & installPrefix){
        initialisationPGenericParser(installPrefix);
}
 
 
PGenericParser::PGenericParser(const PGenericParser & other){
        copyPGenericParser(other);
}
 
PGenericParser::~PGenericParser(){
        
}
 
 
PGenericParser & PGenericParser::operator = (const PGenericParser & other){
        copyPGenericParser(other);
        return *this;
}
 
 
void PGenericParser::setDebugMode(bool isDebugMode){
        p_isDebugMode = isDebugMode;
}
 
 
const PLatexObj & PGenericParser::getSource() const{
        return p_currentSource;
}
 
 
PLatexObj & PGenericParser::getSource(){
        return p_currentSource;
}
 
 
const PVecString & PGenericParser::getVecIncludeDir() const{
        return p_vecIncludeDir;
}
 
 
PVecString & PGenericParser::getVecIncludeDir(){
        return p_vecIncludeDir;
}
 
 
const PMapBiblioEntry & PGenericParser::getMapBiblioEntry() const{return p_mapBiblioEntry;}
 
 
PMapBiblioEntry & PGenericParser::getMapBiblioEntry(){return p_mapBiblioEntry;}
 
 
const PString & PGenericParser::getBookSideBarWidth() const{
        return p_bookSideBarWidth;
}
 
 
const PString & PGenericParser::getBookGitlabUrl() const{
        return p_bookGitlabUrl;
}
 
 
bool PGenericParser::getBookEnableFeedback() const{
        return p_isEnableBookFeedback;
}
 
 
const PString & PGenericParser::getBookMail() const{
        return p_bookMail;
}
 
 
const PString & PGenericParser::getBookMasterProjectUrl() const{
        return p_bookMasterProjectUrl;
}
 
 
const PLatexObj & PGenericParser::getBookMainPageLink() const{
        return p_bookMainPageLink;
}
 
 
bool PGenericParser::saveCss(){
        PVecString vecTheme;
        for(std::map<PString, PString>::iterator itStyle(p_cssContent.begin()); itStyle != p_cssContent.end(); ++itStyle){
                vecTheme.push_back(itStyle->first);
        }
        
        for(std::map<PString, PString>::iterator itStyle(p_cssContent.begin()); itStyle != p_cssContent.end(); ++itStyle){
                PString cssStyle(itStyle->second), cssThemeName(itStyle->first);
                if(p_vecExtraEnv.size() != 0lu){
                        for(PMapExtraEnv::iterator it(p_vecExtraEnv.begin()); it != p_vecExtraEnv.end(); ++it){
                                cssStyle += "." + it->second.getName() + "Style{\n";
                                cssStyle += select_css_theme(vecTheme, cssThemeName, it->second.getCss());
                                cssStyle += "}\n\n";
                        }
                }
                if(p_vecExtraFunction.size() != 0lu){
                        for(PMapExtraEnv::iterator it(p_vecExtraFunction.begin()); it != p_vecExtraFunction.end(); ++it){
                                cssStyle += "." + it->second.getName() + "Style{\n";
                                cssStyle += select_css_theme(vecTheme, cssThemeName, it->second.getCss());
                                cssStyle += "}\n\n";
                        }
                }
                PPath fileName(cssThemeName + "_style.css");
                if(!fileName.saveFileContent(cssStyle)){
                        std::cerr << "PGenericParser::saveCss : can't save the file '"<<fileName<<"'" << std::endl;
                        return false;
                }
        }
        return true;
}
 
 
void PGenericParser::copyPGenericParser(const PGenericParser & other){
        p_isDebugMode = other.p_isDebugMode;
        
        p_vecEnv = other.p_vecEnv;
        p_vecFunc = other.p_vecFunc;
        
        p_vecIncludeDir = other.p_vecIncludeDir;
        
        p_vecNameExtraEnv = other.p_vecNameExtraEnv;
        p_vecNameFunctionExtraEnv = other.p_vecNameFunctionExtraEnv;
        p_vecNameMarkdownExtraEnv = other.p_vecNameMarkdownExtraEnv;
        p_vecExtraEnv = other.p_vecExtraEnv;
        
        p_vecNameExtraFunction = other.p_vecNameExtraFunction;
        p_vecExtraFunction = other.p_vecExtraFunction;
        
        p_vecNameExtraParser = other.p_vecNameExtraParser;
        p_vecNameFunctionExtraParser = other.p_vecNameFunctionExtraParser;
        p_vecNameMarkdownExtraParser = other.p_vecNameMarkdownExtraParser;
        p_vecRemoveLatexKeyword = other.p_vecRemoveLatexKeyword;
        p_vecExtraParser = other.p_vecExtraParser;
        
        p_cssContent = other.p_cssContent;
        p_mapBiblioEntry = other.p_mapBiblioEntry;
        p_mapCopiedFile = other.p_mapCopiedFile;
        
        p_bookSideBarWidth = other.p_bookSideBarWidth;
        p_bookMasterProjectUrl = other.p_bookMasterProjectUrl;
        p_bookMainPageLink = other.p_bookMainPageLink;
        p_bookMail = other.p_bookMail;
        p_bookGitlabUrl = other.p_bookGitlabUrl;
        p_isEnableBookFeedback = other.p_isEnableBookFeedback;
}
 
 
void PGenericParser::clearLatexObj(PLatexObj & obj){
        obj.getVecContent().clear();
        obj.setLabelName("");
        obj.setText("");
        obj.setName("");
        obj.setType(PLatexType::TEXT);
}
 
 
void PGenericParser::incrementCurrentChar(PLatexObj & textObj){
        //If nothing is known I need to save the current char in the MACRO TEXT
        char ch = p_parser->getCurrentCh();
        textObj.getText() += ch;
        p_parser->getNextChar();
}
 
 
bool PGenericParser::playTextLatexObj(PLatexObj & parent, PLatexObj & textObj, bool isRemoveFirstLastSpace){
        if(isRemoveFirstLastSpace){
                textObj.setText(textObj.getText().eraseFirstLastChar(" \t\n"));
        }
        if(textObj.getText() != ""){
                parent.getVecContent().push_back(textObj);
                clearLatexObj(textObj);
                return true;
        }
        return false;
}
 
 
 
void PGenericParser::addLatexObj(PLatexObj & parent, const PLatexObj & obj){
        parent.getVecContent().push_back(obj);
}
 
 
PString PGenericParser::executeLatexCommand(const PString & inputStr){
        PConfigParser parser;
        parser.setFileContent(inputStr + "\n");
        PString out("");
        if(parser.fullParsing()){
                out = platexobj_text(parser.getSource());
        }else{
                out = inputStr;
        }
        return out;
}
 
 
PString PGenericParser::getStringBetweenBraces(const PString & previousToken){
        if(!isMatch("{")){
                errorAt();
                std::cerr << "PGenericParser::getStringBetweenBraces : expect '{' after '"<<previousToken<<"' instead of '"<<p_parser->getNextChar()<<"'" << std::endl;
                stopParsing();
                return "";
        }
//      PString link(p_parser->getUntilKeyWithoutPatern("}"));
        PString link(p_parser->getUntilKeyWithoutPaternRecurse("}", "{"));
        return link;
}
 
 
PString PGenericParser::getOptionStringBetweenBraces(){
        if(!isMatch("{")){      //No hook => empty string
                return "";
        }
        PString link(p_parser->getUntilKeyWithoutPaternRecurse("}", "{"));
        return link;
}
 
 
PString PGenericParser::getOptionStringBetweenHook(){
        PARSER_SKIP_SPACE
        char ch = p_parser->getCurrentCh();
        if(ch != '['){  //No hook => empty string
                return "";
        }
        p_parser->getNextChar();
        PString link(p_parser->getUntilKeyWithoutPatern("]"));
        return link;
}
 
 
bool PGenericParser::parseMonoParam(PLatexObj & parent, PLatexObj & textObj, const PString & functionName, PLatexType::PLatexType type){
        if(!p_parser->isMatch(functionName)){return false;}
        playTextLatexObj(parent, textObj);
        PLatexObj tmp;
        tmp.setType(type);
        
        PString textOption(getOptionStringBetweenHook());
        tmp.setText(textOption);
        
        PString title(getStringBetweenBraces(functionName));
        tmp.setName(title);
        
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PGenericParser::parseGenericLatexObj(PLatexObj & parent, PLatexObj & textObj){
        if(parseMonoParam(parent, textObj, "\\updateStyle", PLatexType::UPDATESTYLE)){}
        else if(parseMonoParam(parent, textObj, "\\ref", PLatexType::REF)){}
        else if(parseMonoParam(parent, textObj, "\\cite", PLatexType::CITATION)){}
        else if(parseLabel(parent, textObj)){}
        else if(parserGetEnv(parent, textObj)){}
        else if(parseMainTitle(parent, textObj)){}
        else if(parseMainSubTitle(parent, textObj)){}
        else if(parseMainAuthor(parent, textObj)){}
        else if(parseMainDate(parent, textObj)){}
        else if(parseBookSizeBarWidth(parent, textObj)){}
        else if(parseBookGitlabUrl(parent, textObj)){}
        else if(parseBookEnableFeedback(parent, textObj)){}
        else if(parseBookMail(parent, textObj)){}
        else if(parseBookMasterProject(parent, textObj)){}
        else{return false;}
        return true;
}
 
 
bool PGenericParser::parseLabel(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\label")){return false;}
        playTextLatexObj(parent, textObj);
        PString link(getStringBetweenBraces("\\label"));
        
        PLatexObj* ptrLatex = getLastPLatexObj(parent);
        if(ptrLatex != NULL){
                ptrLatex->setLabelName(link);
        }
        return true;
}
 
 
bool PGenericParser::parserGetEnv(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\getenv")){return false;}
        playTextLatexObj(parent, textObj);
        PString title(getStringBetweenBraces("\\getenv"));
        PLatexObj tmp;
        tmp.setType(PLatexType::GETENV);
        tmp.setName(title);
        addLatexObj(parent, tmp);
        
        return true;
}
 
 
bool PGenericParser::parseMainTitle(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\title")){return false;}
        playTextLatexObj(parent, textObj);
        PString title(getStringBetweenBraces("\\title"));
        parent.setName(executeLatexCommand(title));
        return true;
}
 
 
bool PGenericParser::parseMainSubTitle(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\subtitle")){return false;}
        playTextLatexObj(parent, textObj);
        PString title(getStringBetweenBraces("\\subtitle"));
        parent.setSubTitle(executeLatexCommand(title));
        return true;
}
 
 
bool PGenericParser::parseMainAuthor(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\author")){return false;}
        playTextLatexObj(parent, textObj);
        PString title(getStringBetweenBraces("\\author"));
        parent.setAuthor(executeLatexCommand(title));
        return true;
}
 
 
bool PGenericParser::parseMainDate(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\date")){return false;}
        playTextLatexObj(parent, textObj);
        PString title(getStringBetweenBraces("\\date"));
        parent.setDate(executeLatexCommand(title));
        return true;
}
 
 
bool PGenericParser::parseBookSizeBarWidth(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\bookSizebarWidth")){return false;}
        playTextLatexObj(parent, textObj);
        PString title(getStringBetweenBraces("\\bookSizebarWidth"));
        p_bookSideBarWidth = executeLatexCommand(title);
        return true;
}
 
 
bool PGenericParser::parseBookGitlabUrl(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\bookGitlabUrl")){return false;}
        playTextLatexObj(parent, textObj);
        PString title(getStringBetweenBraces("\\bookGitlabUrl"));
        p_bookGitlabUrl = executeLatexCommand(title).eraseLastChar("/");
        return true;
}
 
 
bool PGenericParser::parseBookEnableFeedback(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\bookEnableFeedback")){return false;}
        playTextLatexObj(parent, textObj);
        PString title(getStringBetweenBraces("\\bookEnableFeedback").toLower());
        title = executeLatexCommand(title);
        p_isEnableBookFeedback = (title == "true" || title == "yes" || title == "1");
        return true;
}
 
 
bool PGenericParser::parseBookMail(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\bookMail")){return false;}
        playTextLatexObj(parent, textObj);
        PString title(getStringBetweenBraces("\\bookMail"));
        p_bookMail = executeLatexCommand(title);
        return true;
}
 
 
bool PGenericParser::parseBookMasterProject(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatchToken("\\bookMasterProject")){return false;}
        playTextLatexObj(parent, textObj);
        PString title(getStringBetweenBraces("\\bookMasterProject"));
        p_bookMasterProjectUrl = executeLatexCommand(title).eraseLastChar("/");
        return true;
}
 
 
void setBoolFromAttr(bool & isAllowComment, const PXml & xml, const PString & name){
        PXmlAttr attr;
        if(pxml_getAttrIfExist(attr, xml, name)){
                PString value = attr.getValue().toLower();
                isAllowComment = value == "yes" || value == "1" || value == "y";
        }
}
 
 
void PGenericParser::loadDirExtraEnvironementFile(const PPath & inputFile){
        PXml root;
        if(!pxml_parserFile(root, inputFile)){
                std::cerr << "PGenericParser::loadDirExtraEnvironementFile : can't read file '"<<inputFile<<"'" << std::endl;
                return;
        }
        PXml & childXml = root.getVecChild().front();
        if(!pxml_getChildIfExist(childXml, root, "environement")){
                std::cerr << "PGenericParser::loadDirExtraEnvironementFile : can't find <environement> </environement> balise in file '"<<inputFile<<"'" << std::endl;
                return;
        }
        PVecXml listEnv;
        if(pxml_getVecChildIfExist(listEnv, childXml, "env")){
                for(PVecXml::iterator it(listEnv.begin()); it != listEnv.end(); ++it){
                        PXmlAttr attrName;
                        if(!pxml_getAttrIfExist(attrName, *it, "name")){continue;}
                        PString name(attrName.getValue());
                        if(name == ""){
                                std::cerr << "PGenericParser::loadDirExtraEnvironementFile : expect name in balise" << std::endl;
                                continue;
                        }
                        PString balise("div");
                        PXmlAttr attr;
                        if(pxml_getAttrIfExist(attr, *it, "balise")){
                                balise = attr.getValue();
                        }
                        bool isAllowComment(true), isAllowMath(true);
                        setBoolFromAttr(isAllowComment, *it, "comment");
                        setBoolFromAttr(isAllowMath, *it, "math");
                        
                        PString contentStr(pxml_getFullContent(*it));
                        
                        PEnvironement tmp;
                        tmp.setName(name);
                        tmp.setBalise(balise);
                        tmp.setCss(contentStr);
                        tmp.setIsAllowComment(isAllowComment);
                        tmp.setIsAlloxMath(isAllowMath);
                        
                        p_vecExtraEnv[name] = tmp;
                        p_vecNameExtraEnv.push_back(name);
                        p_vecNameFunctionExtraEnv.push_back("\\" + name);
                        p_vecNameMarkdownExtraEnv.push_back("```" + name);
                }
        }
}
 
 
void PGenericParser::loadDirExtraEnvironement(const PPath & inputDir){
        PListFile listInputFile = inputDir.getAllElementInDir();
        if(listInputFile.size() == 0lu){
                std::cerr << "PGenericParser::loadDirExtraEnvironement : can't read directory '"<<inputDir<<"'" << std::endl;
                return;
        }
        for(PListFile::iterator it(listInputFile.begin()); it != listInputFile.end(); ++it){
                loadDirExtraEnvironementFile(inputDir / (*it));
        }
}
 
 
void PGenericParser::loadDirExtraFunctionFile(const PPath & inputFile){
        PXml root;
        if(!pxml_parserFile(root, inputFile)){
                std::cerr << "PGenericParser::loadDirExtraFunctionFile : can't read file '"<<inputFile<<"'" << std::endl;
                return;
        }
        PXml & childXml = root.getVecChild().front();
        if(!pxml_getChildIfExist(childXml, root, "function")){
                std::cerr << "PGenericParser::loadDirExtraFunctionFile : can't find <function> </function> balise in file '"<<inputFile<<"'" << std::endl;
                return;
        }
        PVecXml listEnv;
        if(pxml_getVecChildIfExist(listEnv, childXml, "fct")){
                for(PVecXml::iterator it(listEnv.begin()); it != listEnv.end(); ++it){
                        PXmlAttr attrName;
                        if(!pxml_getAttrIfExist(attrName, *it, "name")){continue;}
                        PString name(attrName.getValue());
                        if(name == ""){
                                std::cerr << "PGenericParser::loadDirExtraFunctionFile : expect name in balise" << std::endl;
                                continue;
                        }
                        PString balise("span");
                        PXmlAttr attr;
                        if(pxml_getAttrIfExist(attr, *it, "balise")){
                                balise = attr.getValue();
                        }
                        PString contentStr(pxml_getFullContent(*it));
                        PEnvironement tmp;
                        tmp.setName(name);
                        tmp.setBalise(balise);
                        tmp.setCss(contentStr);
                        
                        p_vecExtraFunction[name] = tmp;
                        p_vecNameExtraFunction.push_back("\\" + name);
                }
        }
}
 
 
void PGenericParser::loadDirExtraFunction(const PPath & inputDir){
        PListFile listInputFile = inputDir.getAllElementInDir();
        if(listInputFile.size() == 0lu){
                std::cerr << "PGenericParser::loadDirExtraFunction : can't read directory '"<<inputDir<<"'" << std::endl;
                return;
        }
        for(PListFile::iterator it(listInputFile.begin()); it != listInputFile.end(); ++it){
                loadDirExtraFunctionFile(inputDir / (*it));
        }
}
 
 
void PGenericParser::loadDirExtraParserFile(const PPath & inputFile){
        PXml root;
        if(!pxml_parserFile(root, inputFile)){
                std::cerr << "PGenericParser::loadDirExtraParserFile : can't read file '"<<inputFile<<"'" << std::endl;
                return;
        }
        PXml & childXml = root.getVecChild().front();
        if(!pxml_getChildIfExist(childXml, root, "highlighting")){
                std::cerr << "PGenericParser::loadDirExtraParserFile : can't find <highlighting> </highlighting> balise in file '"<<inputFile<<"'" << std::endl;
                return;
        }
        PString environementName(inputFile.getFileName().eraseExtension());
        p_vecNameExtraParser.push_back(environementName);
        p_vecNameFunctionExtraParser.push_back("\\" + environementName);
        p_vecNameMarkdownExtraParser.push_back("```" + environementName);
        
        PParserEnv parserEnv;
        parserEnv.setName(environementName);
        
        PXml matchPlainText;
        if(pxml_getChildIfExist(matchPlainText, childXml, "plainText")){
                parserEnv.setPlainText(convertBackSlahedStr(pxml_getFullContent(matchPlainText)));
        }
        PVecXml listEnv;
        if(pxml_getVecChildIfExist(listEnv, childXml, "context")){
                for(PVecXml::iterator itBalise(listEnv.begin()); itBalise != listEnv.end(); ++itBalise){
                        PXmlAttr attrClass;
                        if(!pxml_getAttrIfExist(attrClass, *itBalise, "class")){continue;}
                        PString nameClass(attrClass.getValue());
                        if(nameClass == ""){
                                std::cerr << "PGenericParser::loadDirExtraEnvironementFile : expect 'class' in balise" << std::endl;
                                continue;
                        }
                        PContext tmp;
                        tmp.setName(nameClass);
                        
                        PXml matchBegin;
                        if(pxml_getChildIfExist(matchBegin, *itBalise, "begin")){
                                tmp.setBegin(convertBackSlahedStr(pxml_getFullContent(matchBegin)));
                        }
                        PXml matchEnd;
                        if(pxml_getChildIfExist(matchEnd, *itBalise, "end")){
                                tmp.setEnd(convertBackSlahedStr(pxml_getFullContent(matchEnd)));
                        }
                        PXml matchNotBeforeBegin;
                        if(pxml_getChildIfExist(matchNotBeforeBegin, *itBalise, "notBeforeBegin")){
                                tmp.setNotBeforeBegin(convertBackSlahedStr(pxml_getFullContent(matchNotBeforeBegin)));
                        }
                        PXml matchNotAfterBegin;
                        if(pxml_getChildIfExist(matchNotAfterBegin, *itBalise, "notAfterBegin")){
                                tmp.setNotAfterBegin(convertBackSlahedStr(pxml_getFullContent(matchNotAfterBegin)));
                        }
                        PXml matchNotBeforEnd;
                        if(pxml_getChildIfExist(matchNotBeforEnd, *itBalise, "notBeforeEnd")){
                                tmp.setNotBeforeEnd(convertBackSlahedStr(pxml_getFullContent(matchNotBeforEnd)));
                        }
                        PVecXml listKw;
                        if(pxml_getVecChildIfExist(listKw, *itBalise, "keyword")){
                                for(PVecXml::iterator it(listKw.begin()); it != listKw.end(); ++it){
                                        tmp.getVecKeyword().push_back(convertBackSlahedStr(pxml_getFullContent(*it)));
                                }
                        }
                        
                        PXml matchSequence;
                        if(pxml_getChildIfExist(matchSequence, *itBalise, "sequence")){
                                PParseSeq seq;
                                if(loadParserSeq(seq, matchSequence)){
                                        tmp.setSeq(seq);
                                }else{
                                        std::cerr << "PGenericParser::loadDirExtraParserFile : can't initialise sequence with balise in file '"<<inputFile<<"'" << std::endl;
                                }
                        }
                        parserEnv.getVecContext().push_back(tmp);
                }
                p_vecExtraParser.getVecEnv().push_back(parserEnv);
        }
}
 
 
void PGenericParser::loadDirExtraParser(const PPath & inputDir){
        PListFile listInputFile = inputDir.getAllElementInDir();
        if(listInputFile.size() == 0lu){
                std::cerr << "PGenericParser::loadDirExtraParser : can't read directory '"<<inputDir<<"'" << std::endl;
                return;
        }
        for(PListFile::iterator it(listInputFile.begin()); it != listInputFile.end(); ++it){
                loadDirExtraParserFile(inputDir / (*it));
        }
}
 
 
void PGenericParser::loadCss(const PPath & inputDir){
        PListFile listInputFile = inputDir.getAllElementInDir();
        if(listInputFile.size() == 0lu){
                std::cerr << "PGenericParser::loadCss : can't read directory '"<<inputDir<<"'" << std::endl;
                return;
        }
        for(PListFile::iterator it(listInputFile.begin()); it != listInputFile.end(); ++it){
                PString styleName(it->getFileName().eraseExtension());
                PPath tmpFile(inputDir / (*it));
                p_cssContent[styleName] = tmpFile.loadFileContent();
        }
}
 
void PGenericParser::loadMapFile(){
        PString fileName(COPIED_RECOVER_FILE);
        if(!data_load(fileName, p_mapCopiedFile)){return;}
}
 
void PGenericParser::saveMapFile(){
        PString fileName(COPIED_RECOVER_FILE);
        if(!data_save(fileName, p_mapCopiedFile)){return;}
}
 
 
PPath PGenericParser::getAbsoluteFileName(const PPath & fileName){
        PPath fileToBeCopied(fileName);
        if(!fileToBeCopied.isFileExist()){      //If the fileName does not exists, it is relative to the current parsed file
                fileToBeCopied = p_parser->getFileName().getParentDirectory() / fileName;
                if(!fileToBeCopied.isFileExist()){      //Il the fileName still does not exists, we have to complain
                        std::cerr << "PGenericParser::getAbsoluteFileName : file '"<<fileName<<"' does not exists, even relative to the current parsed file that gives '"<<fileToBeCopied<<"'" << std::endl;
                        return PPath("");
                }
        }
        return fileToBeCopied;
}
 
 
PPath PGenericParser::copyFile(const PPath & outputDir, const PPath & fileName){
        if(fileName == ""){
                std::cerr << "PGenericParser::copyFile : fileName is empty" << std::endl;
                return PPath("");
        }
        PPath fileToBeCopied(getAbsoluteFileName(fileName));
        if(fileToBeCopied == ""){       //If the fileName does not exists, it is relative to the current parsed file
                std::cerr << "PGenericParser::copyFile : file '"<<fileName<<"' does not exists, even relative to the current parsed file that gives '"<<fileToBeCopied<<"'" << std::endl;
                return PPath("");
        }
        
        PString baseFileName(fileToBeCopied.getFileName());
        PString linkDir(fileName.getParentDirectory().replace("../", ""));
        PPath buildFileName(outputDir + PPath("/") + linkDir + PPath("/") + baseFileName);
        
        //Do we know the input file (did we already copy it)
        PMapFile::iterator it(p_mapCopiedFile.find(fileName));
        if(it != p_mapCopiedFile.end()){
                //Let's check if the copied file still exists
                if(buildFileName.isFileExist()){
                        //Ok, now let's get it's last modification time to be sure
                        time_t currentModifTime = fileToBeCopied.getFileModificationTime();
                        //Now let's check if it is the same one
                        if(currentModifTime == it->second && currentModifTime > 0){     //negative value is an error
                                //Ok, no need to copy, we already did it and the file if up to date
                                std::cout << "PGenericParser::copyFile : no need to copy file '"<<fileName<<"' already updated at time " << currentModifTime << std::endl;
                                return buildFileName;
                        }
                }
        }
        
        if(linkDir != ""){              //If there is other directories
                if(!PPath(outputDir + "/" + linkDir).createDirectory()){
                        std::cerr << "PGenericParser::copyFile : cannot create directory '"<<(outputDir + "/" + linkDir)<<"'" << std::endl;
                        return PPath("");
                }
        }else{
                if(!outputDir.createDirectory()){
                        std::cerr << "PGenericParser::copyFile : cannot create directory '"<<outputDir<<"'" << std::endl;
                        return PPath("");
                }
        }
        
        //Set the modification time
        time_t lastModifTime = fileToBeCopied.getFileModificationTime();
        
        PString command("cp "+fileToBeCopied+" " + buildFileName);
        if(system(command.c_str()) != 0){
                errorAt();
                std::cerr << "PGenericParser::copyFile : can't copy file '"<<fileToBeCopied<<"' into '"<<buildFileName<<"' directory" << std::endl;
                stopParsing();
                return PPath("");
        }
//      std::cout << "PGenericParser::copyFile : copy file '"<<fileToBeCopied<<"' at time " << lastModifTime << std::endl;
        p_mapCopiedFile[fileToBeCopied] = lastModifTime;
        return buildFileName;
}
 
 
void PGenericParser::initialisationPGenericParser(const PString & baseInstallPrefix){
        p_isDebugMode = false;
        p_currentText.setType(PLatexType::TEXT);
        p_currentSource.setType(PLatexType::FILE);
        
        PString installPrefix(CMAKE_INSTALL_PREFIX);
        if(baseInstallPrefix != ""){
                installPrefix = baseInstallPrefix;
        }
        
        PPath dirExtraEnv(installPrefix+"/share/PhoenixTex2Html/ENVIRONEMENT");
        loadDirExtraEnvironement(dirExtraEnv);
        
        PPath dirExtraFunction(installPrefix+"/share/PhoenixTex2Html/FUNCTION");
        loadDirExtraFunction(dirExtraFunction);
        
        PPath dirExtraParser(installPrefix+"/share/PhoenixTex2Html/PARSER");
        loadDirExtraParser(dirExtraParser);
        
        PPath dirCss(installPrefix+"/share/PhoenixTex2Html/STYLE");
        loadCss(dirCss);
        
        p_vecRemoveLatexKeyword.push_back("\\toprule");
        p_vecRemoveLatexKeyword.push_back("\\midrule");
        p_vecRemoveLatexKeyword.push_back("\\bottomrule");
        p_vecRemoveLatexKeyword.push_back("\\hline");
        loadMapFile();
        
        p_bookSideBarWidth = "300px";
        p_isEnableBookFeedback = false;
        
        p_bookMainPageLink.setType(PLatexType::NONE);   //None by default, type will be updated on update
}