parser_yml.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "PFileParser.h"
#include "vec_value_utils.h"
 
#include "parser_yml.h"

struct PYmlParserData{
        bool isRun;
        bool compactMode;
        size_t currentLine;
        std::vector<size_t> vecIndentation;
        PString currentText;
        VecValue * currentlyParsedKeyValue;
};


PYmlParserData default_PYmlParserData(){
        PYmlParserData data;
        data.isRun = true;
        data.compactMode = false;
        data.currentLine = 1lu;
        data.currentText = "";
        data.currentlyParsedKeyValue = NULL;
        return data;
}
 
bool parse_yml_all(VecValue & parent, PFileParser & parser, PYmlParserData & data);


void parse_yml_stopParsing(PYmlParserData & data){
        data.isRun = false;
}


bool parse_yml_isParse(const PYmlParserData & data){
        return data.isRun;
}


void parse_yml_updateIndentation(std::vector<size_t> & vecIndentation, size_t currentIndentation){
        if(currentIndentation == 0lu || vecIndentation.size() == 0lu){          //If there is no indentation
                vecIndentation.clear();
                vecIndentation.push_back(currentIndentation);
                return;
        }
        std::vector<size_t> vecOutIndentation;
        std::vector<size_t>::const_iterator it(vecIndentation.begin());
        bool isCurrentLower(true);
        while(isCurrentLower && it != vecIndentation.end()){            //Get previous indentation until the current one
                isCurrentLower = *it < currentIndentation;
                if(isCurrentLower){
                        vecOutIndentation.push_back(*it);
                }
                ++it;
        }
        vecOutIndentation.push_back(currentIndentation);        //Add the current indentation
        vecIndentation = vecOutIndentation;
}


void parse_yml_incrementCurrentChar(PFileParser & parser, PYmlParserData & data){
        //If nothing is known I need to save the current char in the MACRO TEXT
        char ch = parser.getCurrentCh();
        data.currentText += ch;
        parser.getNextChar();
}


void parse_yml_playCurrentText(PYmlParserData & data){
        PString value(data.currentText.eraseFirstLastChar(" \t\n"));
        
        if(data.currentlyParsedKeyValue != NULL && value != ""){
                data.currentlyParsedKeyValue->setValue(value);
        }
        data.currentText = "";
}


bool parse_yml_key(PString & key, size_t & keyIndentation, PFileParser & parser){
        parser.pushPosition();
        PString possibleKey(parser.getStrComposedOf("_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"));
        if(possibleKey != "" && parser.isMatch(":")){
                key = possibleKey;
                keyIndentation = parser.getColumn() - possibleKey.size() - 1lu;
                return true;
        }
        parser.popPosition();
        return false;
}


bool parse_yml_string(PString & str, PFileParser & parser){
        if(parser.isMatch("\"")){
                str = "\"" + parser.getUntilKey("\"");
        }else if(parser.isMatch("'")){
                str = "'" + parser.getUntilKey("'");
        }else{
                return false;
        }
        return true;
}


void parse_yml_dicoSetValue(VecValue * vecVal, const PString & value){
        if(vecVal == NULL){return;}
        vecVal->setValue(value);
        vecVal->setType(VecValueType::VALUE);
}


bool parse_yml_stringValue(PFileParser & parser, PYmlParserData & data){
        if(parser.isMatch("\'")){
                PString str("\'" + parser.getUntilKey("\'"));
                parse_yml_dicoSetValue(data.currentlyParsedKeyValue, str);
        }else if(parser.isMatch("\"")){
                PString str("\"" + parser.getUntilKey("\""));
                parse_yml_dicoSetValue(data.currentlyParsedKeyValue, str);
        }else{
//              PString strValue(parser.getStrComposedOf("_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789%$£?.*/+=-&~#(){}[]|!<>@°"));
//              parser.skipWhiteSpace();
//              PString strValue(parser.getStrComposedOf("_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789{}§"));
//              if(strValue != ""){
//                      parse_yml_dicoSetValue(data.currentlyParsedKeyValue, strValue);
//              }else{
                        return false;
//              }
        }
        return true;
}


bool parse_yml_compactDicoContent(VecValue & parent, PFileParser & parser, PYmlParserData & data){
        if(!parser.isMatch("{", "$§_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789/*+-.")){return false;}
        std::vector<size_t> saveVecIndentation = data.vecIndentation;
        parse_yml_playCurrentText(data);
        bool oldMode = data.compactMode;
        data.compactMode = true;
        
        VecValue & dico = *data.currentlyParsedKeyValue;
        data.vecIndentation.clear();
        data.vecIndentation.push_back(0lu);
        parser.getStrComposedOf(" \t\n");                               //Skip all blank characters
        while(parse_yml_isParse(data) && !parser.isMatch("}")){
                if(!parse_yml_all(dico, parser, data)){
                        std::cerr << "parse_yml_compactDicoContent : error at " << parser.getLocation() << std::endl;
                        std::cerr << "\tunexpected token '"<<parser.getNextToken()<<"'" << std::endl;
                        parse_yml_stopParsing(data);
                }
                parser.isMatch(",");                    //Skip comma if there is one
        }
        parse_yml_playCurrentText(data);
        data.vecIndentation = saveVecIndentation;
        data.compactMode = oldMode;
        return true;
}


bool parse_yml_dicoContent(VecValue & parent, PFileParser & parser, PYmlParserData & data){
        parser.pushPosition();
        PString keyName("");
        size_t keyIndentation(0lu);
        if(!parse_yml_key(keyName, keyIndentation, parser)){       //Check if there is a key
                parser.popPosition();   //This is not a key
                return false;
        }
        parse_yml_playCurrentText(data);
        VecValue dico;
        dico.setKey(keyName);
        dico.setType(VecValueType::KEY);
        if(data.compactMode){
                keyIndentation = -1lu;
        }
        dico.setIndentation(keyIndentation);
        //Add the dico into its parent and get back the pointer of the current dico we want to fill
        VecValue * ptrDico = addChildToParentVecValue(parent, data.vecIndentation, data.compactMode, dico, keyIndentation);
        
        //Update indentation to be used to fill the VecValue in the current dico
        parse_yml_updateIndentation(data.vecIndentation, keyIndentation);
        
        data.currentlyParsedKeyValue = ptrDico;
        
        //We do not need to parse the dico content, because its content will depend on what comes next (key, value, list)
        
        //OK, on pourrait dire que les dicos se regroupent par leur indentation donc ça fonctionne
        //Et que les valeurs associée (string, listes) sont ajoutées en utilisant data.currentlyParsedKeyValue
        
        return true;
}


bool parse_yml_compactListContent(VecValue & parent, PFileParser & parser, PYmlParserData & data){
        if(!parser.isMatch("[")){return false;}
        parse_yml_playCurrentText(data);
        VecVecValue & listValue = data.currentlyParsedKeyValue->getVecChild();
        
        while(parse_yml_isParse(data) && !parser.isMatch("]")){
                PString tmpStr("");
                if(parse_yml_string(tmpStr, parser)){
                        VecValue vecTmp;
                        vecTmp.setValue(tmpStr);
                        listValue.push_back(vecTmp);
                }else{
                        while(parse_yml_isParse(data) && !parser.isMatchRewind("]") && !parser.isMatchRewind(",")){
                                parse_yml_incrementCurrentChar(parser, data);
                        }
                        VecValue vecTmp;
                        vecTmp.setValue(data.currentText.eraseFirstChar(" \t\n"));
                        listValue.push_back(vecTmp);
                        data.currentText = "";
                }
                if(!parser.isMatch(",") && !parser.isMatchRewind("]")){
                        parse_yml_stopParsing(data);
                        std::cerr << "parser_yml_fileParser : error at " << parser.getLocation() << std::endl;
                        std::cerr << "\tunexpected token '"<<parser.getNextToken()<<"'" << std::endl;
                        std::cerr << "\texpect token ',' or ']'" << std::endl;
                        return true;
                }
        }
        return true;
}


bool parse_yml_listContent(VecValue & parent, PFileParser & parser, PYmlParserData & data){
        if(!parser.isMatch("- ")){return false;}                //There is no extra space, this is exactly the syntax
        size_t currentIndentation(parser.getColumn() - 1lu);
        parse_yml_playCurrentText(data);
        VecValue dashList;
        dashList.setKey("");
        dashList.setType(VecValueType::LIST_ITEM);
        dashList.setIndentation(currentIndentation);
//      std::cerr << "parse_yml_listContent : Add LIST_ITEM at " << parser.getLocation() << std::endl;
        //Add the dico into its parent and get back the pointer of the current dico we want to fill
        VecValue * ptrDashList = addChildToParentVecValueAddListItem(parent, data.vecIndentation, data.compactMode, dashList, currentIndentation);
        
        //Update indentation to be used to fill the VecValue in the current dico
        parse_yml_updateIndentation(data.vecIndentation, currentIndentation);
        
        data.currentlyParsedKeyValue = ptrDashList;
        return true;
}


bool parse_yml_all(VecValue & parent, PFileParser & parser, PYmlParserData & data){
        if(parser.isMatch("#")){parser.getUntilKeyWithoutPatern("\n");}         //Skip the comment
        else if(parse_yml_compactListContent(parent, parser, data)){}
        else if(parse_yml_compactDicoContent(parent, parser, data)){}
        else if(parse_yml_listContent(parent, parser, data)){}
        else if(parse_yml_dicoContent(parent, parser, data)){}
        else if(parse_yml_stringValue(parser, data)){}
        else{
                parse_yml_incrementCurrentChar(parser, data);
        }
        return true;
}


bool parser_yml_fileParser(VecValue & dico, PFileParser & parser){
        PYmlParserData data(default_PYmlParserData());
        data.currentlyParsedKeyValue = &dico;
        parser.getStrComposedOf(" \t\n");               //Skip all blank characters
        while(!parser.isEndOfFile() && parse_yml_isParse(data)){
                if(!parse_yml_all(dico, parser, data)){
                        std::cerr << "parser_yml_fileParser : error at " << parser.getLocation() << std::endl;
                        std::cerr << "\tunexpected token '"<<parser.getNextToken()<<"'" << std::endl;
                        parse_yml_stopParsing(data);
                }
        }
        parse_yml_playCurrentText(data);
        return data.isRun;
}
 


bool parser_yml(DicoValue & dico, const PPath & fileName){
        PFileParser parser;
        parser.setWhiteSpace("");
        parser.setSeparator(":-'\",{}[]>|#");
        parser.setEscapeChar('\\');
        if(!parser.open(fileName)){
                std::cerr << "parser_yml : cannot open file '"<<fileName<<"'" << std::endl;
                return false;
        }
        VecValue vecValue;
        vecValue.setType(VecValueType::MAIN);
        vecValue.setIndentation(parser.getLocation().getColumn());
        bool b(parser_yml_fileParser(vecValue, parser));
        vecValueToDicoValue(dico, vecValue);
        return b;
}