PMarkdownParser.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 "PMarkdownParser.h"
 
 
PMarkdownParser::PMarkdownParser(const PString & installPrefix)
        :PGenericParser(installPrefix)
{
        initialisationPMarkdownParser();
}
 
 
PMarkdownParser::PMarkdownParser(const PGenericParser & other)
        :PGenericParser(other)
{
        
}
 
 
PMarkdownParser::PMarkdownParser(const PMarkdownParser & other)
        :PGenericParser(other)
{
        copyPMarkdownParser(other);
}
 
PMarkdownParser::~PMarkdownParser(){
        
}
 
 
PMarkdownParser & PMarkdownParser::operator = (const PMarkdownParser & other){
        copyPMarkdownParser(other);
        return *this;
}
 
 
void PMarkdownParser::copyPMarkdownParser(const PMarkdownParser & other){
        
}
 
 
bool PMarkdownParser::parseFile(){
        if(!p_run) return false;
        p_currentSource.setType(PLatexType::FILE);
        p_currentSource.setLink("index.html");
        p_currentSource.setSourceFile(p_parser->getFileName());
        p_currentSource.setSourceLine(1lu);
        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 PMarkdownParser::preLoadFile(){
        //Save the current source
        clearLatexObj(p_currentSource);
        clearLatexObj(p_currentText);
        p_parser->setWhiteSpace("");
        p_parser->setSeparator("");
}
 
void PMarkdownParser::postLoadFile(){
        
}
 
void PMarkdownParser::initialisationPMarkdownParser(){
        
}
 
 
bool PMarkdownParser::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 PMarkdownParser::parseAllLatexObj(PLatexObj & parent, PLatexObj & textObj){
        if(parseSectionTitle(parent, textObj, "##### ", PLatexType::SUBSUBSECTION)){}
        else if(parseSectionTitle(parent, textObj, "#### ", PLatexType::SUBSECTION)){}
        else if(parseSectionTitle(parent, textObj, "### ", PLatexType::SECTION)){}
        else if(parseSectionTitle(parent, textObj, "## ", PLatexType::CHAPTER)){}
        else if(parseSectionTitle(parent, textObj, "# ", PLatexType::PART)){}
        
        else if(parseExtraEnvironement(parent, textObj)){}
        else if(parseExtraParser(parent, textObj)){}
        else if(parseWip(parent, textObj)){}
        else if(parseEnvDecoration(parent, textObj, "```", "terminal", PLatexType::ENVIRONEMENT, "pre")){}
        
        else if(parseGenericLatexObj(parent, textObj)){}
        else if(parseComplexMonoParam(parent, textObj, "\\footnote", PLatexType::FOOTNOTE)){}
        else if(parseComplexMonoParam(parent, textObj, "\\caption", PLatexType::CAPTION)){}
        
        else if(parseEnvLatexObj(parent, textObj)){}
        else{
                return false;
        }
        return true;
}
 
 
bool PMarkdownParser::parseEnvLatexObj(PLatexObj & parent, PLatexObj & textObj){
        if(parseItemize(parent, textObj)){}
        else if(parseEnumerate(parent, textObj)){}
        else if(parseNewLine(parent, textObj)){}
        else if(parseItemLatexObj(parent, textObj)){}
        else{
                return false;
        }
        
        return true;
}
 
 
bool PMarkdownParser::parseItemLatexObj(PLatexObj & parent, PLatexObj & textObj){
        if(parseComment(parent, textObj)){}
        else if(parseTextDecoration(parent, textObj, "***", "textbfit", PLatexType::FUNCTION, "span")){}
        else if(parseTextDecoration(parent, textObj, "**", "textbf", PLatexType::FUNCTION, "span")){}
        else if(parseTextDecoration(parent, textObj, "*", "textit", PLatexType::FUNCTION, "span")){}
        else if(parseTextDecoration(parent, textObj, "`", "code", PLatexType::FUNCTION, "span")){}
        
        else if(parseHref(parent, textObj)){}
        else if(parseIncludeGraphic(parent, textObj)){}
        else if(parseUrl(parent, textObj)){}
        else if(parsePercent(parent, textObj)){}
        else{
                return false;
        }
        return true;
}
 
 
bool PMarkdownParser::parseSectionTitle(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);
        tmp.setSourceFile(p_parser->getLocation().getFileName());
        tmp.setSourceLine(p_parser->getLocation().getLine());
        
        PLatexObj objTitle;
        parseVecLatexObj(objTitle, textObj, "", "\n");
        tmp.setComplexTitle(objTitle.getVecContent());
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PMarkdownParser::parseTextDecoration(PLatexObj & parent, PLatexObj & textObj, const PString & patern, const PString & cssStyle,
                                        PLatexType::PLatexType type, const PString & balise)
{
        if(p_parser->isMatch("```")){return false;}
        if(!p_parser->isMatch(patern)){return false;}
        playTextLatexObj(parent, textObj);
        PLatexObj tmp;
        tmp.setType(type);
        tmp.setName(cssStyle);
        tmp.setBalise(balise);
        
        parseVecLatexObj(tmp, textObj, "", patern);
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PMarkdownParser::parseEnvDecoration(PLatexObj & parent, PLatexObj & textObj, const PString & patern, const PString & cssStyle,
                                        PLatexType::PLatexType type, const PString & balise)
{
        if(!p_parser->isMatch(patern)){return false;}
        playTextLatexObj(parent, textObj);
        PLatexObj tmp;
        tmp.setType(type);
        tmp.setName(cssStyle);
        tmp.setBalise(balise);
        
        parseVecLatexObj(tmp, textObj, "", patern);
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PMarkdownParser::parseIncludeGraphic(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatch("![")){return false;}
        playTextLatexObj(parent, textObj);
        PString option(p_parser->getUntilKeyWithoutPatern("]"));
        if(!p_parser->isMatch("(")){
                errorAt();
                std::cerr << "PMarkdownParser::parseIncludeGraphic : expect '(' after '!["+option+"]' instead of '"<<p_parser->getNextChar()<<"'" << std::endl;
                stopParsing();
                return "";
        }
        PPath imageFile(p_parser->getUntilKeyWithoutPatern(")"));
        PLatexObj tmp;
        bool isVideo(imageFile.getExtension() == "mp4");
        if(isVideo){    //This is not an image
                tmp.setType(PLatexType::VIDEO);
        }else{
                tmp.setType(PLatexType::IMAGE);
        }
        PString outputDir(LATEX_IMAGE_OUTPUT_DIR);
        if(isVideo){
                outputDir = LATEX_VIDEO_OUTPUT_DIR;
        }
        PString buildFileName(copyFile(outputDir, imageFile));
        if(buildFileName == ""){return true;}
        tmp.setName(buildFileName);
        tmp.setText(option);
        
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PMarkdownParser::parseUrl(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatch("http")){return false;}
        playTextLatexObj(parent, textObj);
        PLatexObj tmp;
        tmp.setType(PLatexType::URL);
        
        PString link("http" + p_parser->getUntilKeyWithoutPatern(" "));
        tmp.setName(link);
        
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PMarkdownParser::parseHref(PLatexObj & parent, PLatexObj & textObj){
        p_parser->pushPosition();
        if(!p_parser->isMatch("[")){return false;}
        playTextLatexObj(parent, textObj);
        PLatexObj tmp;
        tmp.setType(PLatexType::HREF);
        
        parseVecLatexObj(tmp, textObj, "", "]");        //We alrday parse the begin patern at the begining of this method
        if(!p_parser->isMatch("(")){
                p_parser->popPosition();
                return false;
        }
        PString link(p_parser->getUntilKeyWithoutPaternRecurse(")", "("));
        tmp.setName(link);
        
        if(!tmp.getName().isSameBegining("http") && !tmp.getName().isSameBegining("https")){
                PString buildFileName(copyFile(PPath(LATEX_RESSOURCES_OUTPUT_DIR), link));
                if(buildFileName == ""){
                        if(PPath(tmp.getName()).getExtension() != "html"){
                                errorAt();
                                std::cerr << "PMarkdownParser::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 PMarkdownParser::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 PMarkdownParser::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 PMarkdownParser::parseComment(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatch("<!--")){return false;}
        playTextLatexObj(parent, textObj);
        PString comment(p_parser->getUntilKeyWithoutPatern("-->"));
        PLatexObj tmp;
        tmp.setType(PLatexType::COMMENT);
        tmp.setName(comment);
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PMarkdownParser::parseItem(std::vector<std::pair<size_t, PLatexObj> > & vecItemLevel){
        if(p_parser->isMatchRewind("\n\n")){return false;}
        if(!isItem()){
                return false;
        }
        size_t itemLevel(p_parser->getColumn());
        PLatexObj itemObj;
        itemObj.setType(PLatexType::ITEM);
        
        PLatexObj tmpText;
        tmpText.setType(PLatexType::TEXT);
        
        //Do some loop to fill the item
        while(!p_parser->isEndOfFile() && !p_parser->isMatchRewind("\n\n") && !isItem(true) && p_run){
                if(parseItemLatexObj(itemObj, tmpText)){}
                else{
                        incrementCurrentChar(tmpText);
                }
        }
        playTextLatexObj(itemObj, tmpText);
        vecItemLevel.push_back(std::pair<size_t, PLatexObj>(itemLevel, itemObj));
        return true;
}
 
 
bool PMarkdownParser::isItem(bool rewind){
        size_t currentCol(p_parser->getColumn());
        p_parser->pushPosition();
        if(!p_parser->isMatch("-")){
                p_parser->popPosition();
                return false;
        }
        PString space(" \t"), currentRow(p_parser->getCurrentRow());
        size_t i(0lu);
        while(i < currentCol){
                char ch = currentRow[i];
                if(!space.find(ch)){
                        p_parser->popPosition();
                        return false;
                }
                ++i;
        }
        if(rewind){
                p_parser->popPosition();
        }
        return true;
}
 
 
PLatexObj * PMarkdownParser::getProperParent(PLatexObj & parent, std::vector<size_t> & vecLevel, size_t itemLevel, PLatexType::PLatexType listItemType){
        PLatexObj * currentParent = &parent;
        if(vecLevel.back() >= itemLevel){               //The current parent level is too high
                while(vecLevel.back() > itemLevel && vecLevel.size() > 1lu){
                        vecLevel.pop_back();
                }
                if(vecLevel.size() <= 1lu){
                        return currentParent;
                }
                for(size_t i(1lu); i < vecLevel.size(); ++i){
                        PLatexObj * tmpParent = currentParent;
                        PLatexObj & lastItemize = tmpParent->getVecContent().back();
                        if(lastItemize.getType() == listItemType){
                                currentParent = &lastItemize;
                        }else{
                                errorAt();
                                std::cerr << "PMarkdownParser::getProperParent : unextected PLatexObj of type " << lastItemize.getType() << std::endl;
                                stopParsing();
                                return NULL;
                        }
                }
                return currentParent;
        }
        //Only if the level has to increase of one (vecLevel.back() < itemLevel)
        //Let's take the last parent we know
        for(size_t i(1lu); i < vecLevel.size(); ++i){
                PLatexObj * tmpParent = currentParent;
                PLatexObj & lastItemize = tmpParent->getVecContent().back();
                if(lastItemize.getType() == listItemType){
                        currentParent = &lastItemize;
                }else{
                        errorAt();
                        std::cerr << "PMarkdownParser::getProperParent : unextected PLatexObj of type " << lastItemize.getType() << std::endl;
                        stopParsing();
                        return NULL;
                }
        }
        PLatexObj newItemize;
        newItemize.setType(listItemType);
        
        PLatexObj * tmpParent = currentParent;
        addLatexObj(*tmpParent, newItemize);
        
        currentParent = &(tmpParent->getVecContent().back());
        vecLevel.push_back(itemLevel);
        return currentParent;
}
 
 
void PMarkdownParser::insertItemInItemize(PLatexObj & parent, const std::vector<std::pair<size_t, PLatexObj> > & vecItemLevel, PLatexType::PLatexType listItemType){
        std::vector<size_t> parentLevel;
        parentLevel.push_back(vecItemLevel.front().first);
        for(std::vector<std::pair<size_t, PLatexObj> >::const_iterator it(vecItemLevel.begin()); it != vecItemLevel.end(); ++it){
                //Get the proper parent
                PLatexObj * currentParent = getProperParent(parent, parentLevel, it->first, listItemType);
                if(currentParent == NULL){return;}
                //Add the current item to it
                addLatexObj(*currentParent, it->second);
        }
}
 
 
bool PMarkdownParser::parseItemize(PLatexObj & parent, PLatexObj & textObj){
        if(!isItem(true)){return false;}
        playTextLatexObj(parent, textObj);
        PLatexObj tmp;
        tmp.setType(PLatexType::ITEMIZE);
        std::vector<std::pair<size_t, PLatexObj> > vecItemLevel;
        while(!p_parser->isEndOfFile() && p_run && !p_parser->isMatch("\n\n")){
                //Let's parse the current item
                parseItem(vecItemLevel);
        }
        
        insertItemInItemize(tmp, vecItemLevel, PLatexType::ITEMIZE);
        
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PMarkdownParser::parseEnumerateItem(std::vector<std::pair<size_t, PLatexObj> > & vecItemLevel){
        if(p_parser->isMatchRewind("\n\n")){return false;}
        if(!isEnumerateItem()){
                return false;
        }
        size_t itemLevel(p_parser->getColumn());
        PLatexObj itemObj;
        itemObj.setType(PLatexType::ITEM);
        
        PLatexObj tmpText;
        tmpText.setType(PLatexType::TEXT);
        
        //Do some loop to fill the item
        while(!p_parser->isEndOfFile() && !p_parser->isMatchRewind("\n\n") && !isEnumerateItem(true) && p_run){
                if(parseItemLatexObj(itemObj, tmpText)){}
                else{
                        incrementCurrentChar(tmpText);
                }
        }
        playTextLatexObj(itemObj, tmpText);
        vecItemLevel.push_back(std::pair<size_t, PLatexObj>(itemLevel, itemObj));
        return true;
}
 
 
bool PMarkdownParser::isEnumerateItem(bool rewind){
        p_parser->pushPosition();
        size_t currentCol(p_parser->getColumn());
        PString listFigure(p_parser->getStrComposedOf("0123456789"));
        if(listFigure == ""){
                p_parser->popPosition();
                return false;
        }
        if(!p_parser->isMatch(". ")){
                p_parser->popPosition();
                return false;
        }
        PString space(" \t"), currentRow(p_parser->getCurrentRow());
        size_t i(0lu);
        while(i < currentCol){
                char ch = currentRow[i];
                if(!space.find(ch)){
                        p_parser->popPosition();
                        return false;
                }
                ++i;
        }
        if(rewind){
                p_parser->popPosition();
        }
        return true;
}
 
 
bool PMarkdownParser::parseEnumerate(PLatexObj & parent, PLatexObj & textObj){
        if(!isEnumerateItem(true)){return false;}
        playTextLatexObj(parent, textObj);
        PLatexObj tmp;
        tmp.setType(PLatexType::ENUMERATE);
        std::vector<std::pair<size_t, PLatexObj> > vecItemLevel;
        while(!p_parser->isEndOfFile() && p_run && !p_parser->isMatch("\n\n")){
                //Let's parse the current item
                parseEnumerateItem(vecItemLevel);
        }
        insertItemInItemize(tmp, vecItemLevel, PLatexType::ENUMERATE);
        
        addLatexObj(parent, tmp);
        return true;
}
 
 
void PMarkdownParser::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
                }
        }
        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 << "PMarkdownParser::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 PMarkdownParser::parseExtraEnvironement(PLatexObj & parent, PLatexObj & textObj){
        if(p_vecNameMarkdownExtraEnv.size() == 0lu){return false;}
        p_parser->pushPosition();
        PString matchFunc(p_parser->isMatch(p_vecNameMarkdownExtraEnv));
        if(matchFunc == ""){
                p_parser->popPosition();
                return false;
        }
        
        playTextLatexObj(parent, textObj);
        PLatexObj env;
        env.setType(PLatexType::ENVIRONEMENT);
        PString matchEnv(matchFunc.eraseChar('`'));
        env.setName(matchEnv);
        
        PEnvironement & configEnv = p_vecExtraEnv[matchEnv];
        env.setBalise(configEnv.getBalise());
        PLatexObj tmpText;
        tmpText.setType(PLatexType::TEXT);
        
        while(!p_parser->isEndOfFile() && !p_parser->isMatch("```") && p_run){
                if(parseEnvLatexObj(env, tmpText)){}
                else{
                        incrementCurrentChar(tmpText);
                }
        }
        playTextLatexObj(env, tmpText);
        
        addLatexObj(parent, env);
        return true;
}
 
 
 
bool PMarkdownParser::parseExtraParser(PLatexObj & parent, PLatexObj & textObj){
        if(p_vecNameMarkdownExtraParser.size() == 0lu){return false;}
        p_parser->pushPosition();
        PString matchFunc(p_parser->isMatch(p_vecNameMarkdownExtraParser));
        if(matchFunc == ""){
                p_parser->popPosition();
                return false;
        }
        
        playTextLatexObj(parent, textObj);
        PLatexObj tmp;
        tmp.setType(PLatexType::PARSER);
        PString matchEnv(matchFunc.eraseChar('`'));
        tmp.setName(matchEnv);
        
        PParserEnv parser(getParserEnv(p_vecExtraParser, matchEnv));
        
        PString inputFileContent(p_parser->getUntilKeyWithoutPatern("```").eraseFirstLastChar(" \n") + "\n");
        
        tmp.setNbline(inputFileContent.count('\n'));
        
        PString envContent(parser_makeHighlighting(inputFileContent, parser));
        tmp.setText(envContent);
        tmp.setSubTitle(inputFileContent);
        addLatexObj(parent, tmp);
        return true;
}
 
 
bool PMarkdownParser::parseWip(PLatexObj & parent, PLatexObj & textObj){
        if(!p_parser->isMatch("```wip")){return false;}
        
        playTextLatexObj(parent, textObj);
        PLatexObj env;
        env.setType(PLatexType::WORK_IN_PROGRESS);
        
        PLatexObj tmpText;
        tmpText.setType(PLatexType::TEXT);
        
        while(!p_parser->isEndOfFile() && !p_parser->isMatch("```") && p_run){
                if(parseEnvLatexObj(env, tmpText)){}
                else{
                        incrementCurrentChar(tmpText);
                }
        }
        playTextLatexObj(env, tmpText);
        
        addLatexObj(parent, env);
        return true;
}