parser_toml.cpp

Go to the documentation of this file.

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

struct PTomlParserData{
        PFileParser parser;
        bool isRun;
};


PTomlParserData default_PTomlParserData(){
        PTomlParserData data;
        data.isRun = true;
        return data;
}
 
bool parse_toml_var(DicoValue & dico, PTomlParserData & data);
bool parse_toml_all(DicoValue & parent, PTomlParserData & data);


void parse_toml_stopParsing(PTomlParserData & data){
        data.isRun = false;
}


bool parse_toml_isParse(const PTomlParserData & data){
        return data.isRun;
}


bool parse_toml_varName(PString & varName, PFileParser & parser){
        varName = parser.getStrComposedOf("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_");
        return varName != "";
}


bool parse_tomlCompactDico(DicoValue & parent, PTomlParserData & data){
        PFileParser & parser = data.parser;
        if(!parser.isMatch("{")){return false;}
        while(!parser.isEndOfFile() && parse_toml_isParse(data) && !parser.isMatch("}")){     //Let's parse the vatiables of the Dico
                if(parser.isMatch("#")){parser.getUntilKeyWithoutPatern("\n");}
                else if(parse_toml_var(parent, data)){
                        if(!parser.isMatch(",") && !parser.isMatchRewind("}")){ //We expect one element or a comma to add more
                                std::cerr << "parse_tomlCompactDico : expect ',' or '}' for unclosed dictionary of values at " << parser.getLocation() << std::endl;
                                parse_toml_stopParsing(data);
                                return false;
                        }
                }else{
                        if(!parser.isMatch("}")){
                                std::cerr << "parse_tomlCompactDico : missing '}' token to close empty dictionary of value at " << parser.getLocation() << std::endl;
                                parse_toml_stopParsing(data);
                                return false;
                        }
                }
        }
        return true;
}


bool parse_toml_varValue(DicoValue & var, PTomlParserData & data){
        PFileParser & parser = data.parser;
    if(parser.isMatch("[")){    //The value is a list
        while(!parser.isEndOfFile() && !parser.isMatch("]") && parse_toml_isParse(data)){     //Let's parse the values of the Variable
            DicoValue subValue;
            if(parse_tomlCompactDico(subValue, data)){
                var.getVecChild().push_back(subValue);
            }
            else if(parse_toml_varValue(subValue, data)){
                var.getVecChild().push_back(subValue);
            }
            else{
                if(!parser.isMatch("]")){
                    std::cerr << "parse_toml_varBase : missing ']' token to close empty list of value at " << parser.getLocation() << std::endl;
                    parse_toml_stopParsing(data);
                    return false;
                }
            }
            
            if(!parser.isMatch(",") && !parser.isMatchRewind("]")){     //We expect one element or a comma to add more
                std::cerr << "parse_toml_varValue : expect ',' or ']' forunclosed list of values at " << parser.getLocation() << std::endl;
                parse_toml_stopParsing(data);
                return false;
            }
        }
        }else{
                PString strValue("");
                if(parse_generic_string(strValue, parser)){
                        var.setValue(strValue);
                }else if(parser.isMatch("true")){
                        var.setValue("true");
                }else if(parser.isMatch("false")){
                        var.setValue("false");
                }else{
                        PString valueNumber(parser.getStrComposedOf("0123456789.-+e"));
                        if(valueNumber != ""){
                                var.setValue(valueNumber);
                        }else{
                                std::cerr << "parse_toml_varValue : missing value of variable '"<<var.getKey()<<"' at " << parser.getLocation() << std::endl;
                                parse_toml_stopParsing(data);
                                return false;
                        }
                }
        }
        return true;
}


bool parse_toml_varBase(DicoValue & var, PTomlParserData & data){
        PFileParser & parser = data.parser;
        PString varName("");
        if(!parse_toml_varName(varName, parser)){return false;}
        if(!parser.isMatch("=")){
                std::cerr << "parse_toml_varBase : missing '=' token to define value of variable '"<<varName<<"' at " << parser.getLocation() << std::endl;
                parse_toml_stopParsing(data);
                return false;
        }
        var.setKey(varName);
        bool b(true);
        if(parse_tomlCompactDico(var, data)){}
        else if(parse_toml_varValue(var, data)){}
        else{b = false;}
        return b;
}


bool parse_toml_var(DicoValue & dico, PTomlParserData & data){
        DicoValue var;
        if(!parse_toml_varBase(var, data)){return false;}
        dico.getMapChild()[var.getKey()] = var;
        return true;
}


bool parse_toml_varTable(DicoValue & dico, PTomlParserData & data){
        DicoValue var;
        if(!parse_toml_varBase(var, data)){return false;}
        dico.getVecChild().push_back(var);
        return true;
}


DicoValue * parse_get_parent_dico(DicoValue & parent, const PVecString & vecDicoName){
        DicoValue * output = &parent;
        for(PVecString::const_iterator it(vecDicoName.begin()); it != vecDicoName.end(); ++it){
                output = &(output->getMapChild()[*it]);
                output->setKey(*it);
        }
        return output;
}


bool parse_toml_dico_def(DicoValue & parent, PTomlParserData & data){
        PFileParser & parser = data.parser;
        if(!parser.isMatch("[")){return false;}
        PString dicoName(parser.getUntilKeyWithoutPatern("]"));
        PVecString vecDicoName = dicoName.split('.');
        DicoValue * dicoDef = parse_get_parent_dico(parent, vecDicoName);
        
//      dicoDef.setKey(dicoName);
        while(!parser.isEndOfFile() && parse_toml_isParse(data) && !parser.isMatchRewind("[")){       //Let's parse the vatiables of the Dico
                if(parser.isMatch("#")){parser.getUntilKeyWithoutPatern("\n");}
                else if(parse_toml_var(*dicoDef, data)){
//                      parent.getMapChild()[dicoName] = *dicoDef;
                }
//              else{
//                      std::cerr << "parse_toml_dico_def : error at " << parser.getLocation() << std::endl;
//                      std::cerr << "\tcannot parse [definition]" << std::endl;
//                      parse_toml_stopParsing(data);
//                      return true;
//              }
        }
        return true;
}


bool parse_toml_table_def(DicoValue & parent, PTomlParserData & data){
        PFileParser & parser = data.parser;
        if(!parser.isMatch("[[")){return false;}
        PString dicoName(parser.getUntilKeyWithoutPatern("]]"));
        PVecString vecDicoName = dicoName.split('.');
        DicoValue * dicoDef = parse_get_parent_dico(parent, vecDicoName);
//      DicoValue dicoDef;
//      dicoDef.setKey(dicoName);
        DicoValue table;
        while(!parser.isEndOfFile() && parse_toml_isParse(data) && !parser.isMatchRewind("[")){       //Let's parse the vatiables of the Dico
                if(parser.isMatch("#")){parser.getUntilKeyWithoutPatern("\n");}
                else if(parse_toml_var(table, data)){
//                      parent.getMapChild()[dicoName] = *dicoDef;
                }
//              else{
//                      std::cerr << "parse_toml_table_def : error at " << parser.getLocation() << std::endl;
//                      std::cerr << "\tcannot parse [[table_definition]]" << std::endl;
//                      parse_toml_stopParsing(data);
//                      return true;
//              }
        }
        dicoDef->getVecChild().push_back(table);
        return true;
}


bool parser_toml_fileParser(DicoValue & dico, PTomlParserData & data){
        PFileParser & parser = data.parser;
        parser.getStrComposedOf(" \t\n");               //Skip all blank characters
        while(!parser.isEndOfFile() && parse_toml_isParse(data)){
                if(parser.isMatch("#")){parser.getUntilKeyWithoutPatern("\n");}
                else if(parse_toml_table_def(dico, data)){}
                else if(parse_toml_dico_def(dico, data)){}
                else{
                        PString nextToken(parser.getNextToken());
                        if(nextToken.size() != 0lu){    //If the token is empty, we are at the end of the file
                                std::cerr << "parser_toml_fileParser : error at " << parser.getLocation() << std::endl;
                                std::cerr << "\tunexpected token '"<<nextToken<<"'" << std::endl;
                                parse_toml_stopParsing(data);
                        }
                }
        }
        return data.isRun;
}


bool parser_toml(DicoValue & dico, const PPath & fileName){
        PTomlParserData data(default_PTomlParserData());
        PFileParser & parser = data.parser;
        parser.setWhiteSpace(" \n\t");
        parser.setSeparator(":-'\",{}[]>|");
        parser.setEscapeChar('\\');
        if(!parser.open(fileName)){
                std::cerr << "parser_toml : cannot open file '"<<fileName<<"'" << std::endl;
                return false;
        }
        bool b(parser_toml_fileParser(dico, data));
        return b;
}
 
bool parse_toml_var(ConfigNode & parent, PTomlParserData & data);


bool parse_tomlCompactDico(ConfigNode & parent, PTomlParserData & data){
        PFileParser & parser = data.parser;
        if(!parser.isMatch("{")){return false;}
        while(!parser.isEndOfFile() && parse_toml_isParse(data) && !parser.isMatch("}")){     //Let's parse the vatiables of the Dico
                if(parser.isMatch("#")){parser.getUntilKeyWithoutPatern("\n");}
                else if(parse_toml_var(parent, data)){
                        if(!parser.isMatch(",") && !parser.isMatchRewind("}")){ //We expect one element or a comma to add more
                                std::cerr << "parse_tomlCompactDico : expect ',' or '}' for unclosed dictionary of values at " << parser.getLocation() << std::endl;
                                parse_toml_stopParsing(data);
                                return false;
                        }
                }else{
                        if(!parser.isMatch("}")){
                                std::cerr << "parse_tomlCompactDico : missing '}' token to close empty dictionary of value at " << parser.getLocation() << std::endl;
                                parse_toml_stopParsing(data);
                                return false;
                        }
                }
        }
        return true;
}


bool parse_toml_varValue(ConfigNode & var, PTomlParserData & data){
        PFileParser & parser = data.parser;
        if(parser.isMatch("[")){        //The value is a list
                while(!parser.isEndOfFile() && !parser.isMatch("]") && parse_toml_isParse(data)){     //Let's parse the values of the Variable
                        if(parser.isMatch("#")){parser.getUntilKeyWithoutPatern("\n");}
                        else{
                                ConfigNode * subValue = var.addChild();
                                if(parse_tomlCompactDico(*subValue, data)){
                                        if(!parser.isMatch(",") && !parser.isMatchRewind("]")){ //We expect one element or a comma to add more
                                                std::cerr << "parse_toml_varValue : expect ',' or ']' for unclosed list of values at " << parser.getLocation() << std::endl;
                                                parse_toml_stopParsing(data);
                                                return false;
                                        }
                                }else if(parse_toml_varValue(*subValue, data)){
                                        if(!parser.isMatch(",") && !parser.isMatchRewind("]")){ //We expect one element or a comma to add more
                                                std::cerr << "parse_toml_varValue : expect ',' or ']' for unclosed list of values at " << parser.getLocation() << std::endl;
                                                parse_toml_stopParsing(data);
                                                return false;
                                        }
                                }else{
                                        if(!parser.isMatch("]")){
                                                std::cerr << "parse_toml_varValue : missing ']' token to close empty list of value at " << parser.getLocation() << std::endl;
                                                parse_toml_stopParsing(data);
                                                return false;
                                        }
                                }
                        }
                }
        }else{
                PString strValue("");
                if(parse_generic_string(strValue, parser)){
                        var.setValue(strValue);
                }else if(parser.isMatch("true")){
                        var.setValue("true");
                }else if(parser.isMatch("false")){
                        var.setValue("false");
                }else{
                        PString valueNumber(parser.getStrComposedOf("0123456789.-+e"));
                        if(valueNumber != ""){
                                var.setValue(valueNumber);
                        }else{
                                std::cerr << "parse_toml_varValue : missing value of variable '"<<var.getName()<<"' at " << parser.getLocation() << std::endl;
                                parse_toml_stopParsing(data);
                                return false;
                        }
                }
        }
        return true;
}


bool parse_toml_var(ConfigNode & parent, PTomlParserData & data){
        PFileParser & parser = data.parser;
        PString varName("");
        if(!parse_toml_varName(varName, parser)){return false;}
        if(!parser.isMatch("=")){
                std::cerr << "parse_toml_var : missing '=' token to define value of variable '"<<varName<<"' at " << parser.getLocation() << std::endl;
                parse_toml_stopParsing(data);
                return false;
        }
        ConfigNode * var = parent.addChild(varName);
        var->setLineCol(parser.getLocation());
        bool b(true);
        if(parse_tomlCompactDico(*var, data)){}
        else if(parse_toml_varValue(*var, data)){}
        else{b = false;}
        return b;
}


ConfigNode * parse_get_parent_dico(ConfigNode & parent, const PVecString & vecDicoName){
        ConfigNode * output = &parent;
        for(PVecString::const_iterator it(vecDicoName.begin()); it != vecDicoName.end(); ++it){
                ConfigNode * next = output->getChild(it->eraseFirstLastChar("\"'"));
                if(next == NULL){
                        next = output->addChild(*it);
                }
                output = next;
                output->setName(*it);
        }
        return output;
}


bool parse_toml_dico_def(ConfigNode & parent, PTomlParserData & data){
        PFileParser & parser = data.parser;
        if(!parser.isMatch("[")){return false;}
        PString dicoName(parser.getUntilKeyWithoutPatern("]"));
        PVecString vecDicoName = dicoName.split('.');
        ConfigNode * dicoDef = parse_get_parent_dico(parent, vecDicoName);
        dicoDef->setLineCol(parser.getLocation());
        while(!parser.isEndOfFile() && parse_toml_isParse(data) && !parser.isMatchRewind("[")){       //Let's parse the vatiables of the Dico
                if(parser.isMatch("#")){parser.getUntilKeyWithoutPatern("\n");}
                else if(parse_toml_var(*dicoDef, data)){}
        }
        return true;
}


bool parse_toml_table_def(ConfigNode & parent, PTomlParserData & data){
        PFileParser & parser = data.parser;
        if(!parser.isMatch("[[")){return false;}
        PString dicoName(parser.getUntilKeyWithoutPatern("]]"));
        PVecString vecDicoName = dicoName.split('.');
        ConfigNode * dicoDef = parse_get_parent_dico(parent, vecDicoName);
        dicoDef->setLineCol(parser.getLocation());
        ConfigNode * table = dicoDef->addChild();
        table->setLineCol(parser.getLocation());
        while(!parser.isEndOfFile() && parse_toml_isParse(data) && !parser.isMatchRewind("[")){       //Let's parse the vatiables of the Dico
                if(parser.isMatch("#")){parser.getUntilKeyWithoutPatern("\n");}
                else if(parse_toml_var(*table, data)){}
        }
        return true;
}


bool parser_toml_fileParser(ConfigNode & node, PTomlParserData & data){
        PFileParser & parser = data.parser;
        parser.getStrComposedOf(" \t\n");               //Skip all blank characters
        while(!parser.isEndOfFile() && parse_toml_isParse(data)){
                if(parser.isMatch("#")){parser.getUntilKeyWithoutPatern("\n");}
                else if(parse_toml_table_def(node, data)){}
                else if(parse_toml_dico_def(node, data)){}
                else if(parse_toml_var(node, data)){}
                else{
                        PString nextToken(parser.getNextToken());
                        if(nextToken.size() != 0lu){    //If the token is empty, we are at the end of the file
                                std::cerr << "parser_toml_fileParser : error at " << parser.getLocation() << std::endl;
                                std::cerr << "\tunexpected token '"<<nextToken<<"'" << std::endl;
                                parse_toml_stopParsing(data);
                        }
                }
        }
        return data.isRun;
}


bool parser_toml(ConfigNode & node, const PPath & fileName){
        PTomlParserData data(default_PTomlParserData());
        PFileParser & parser = data.parser;
        parser.setWhiteSpace(" \n\t");
        parser.setSeparator(":-'\",{}[]>|");
        parser.setEscapeChar('\\');
        if(!parser.open(fileName)){
                std::cerr << "parser_toml : cannot open file '"<<fileName<<"'" << std::endl;
                return false;
        }
        node.setFileName(fileName);
        bool b(parser_toml_fileParser(node, data));
        return b;
}


bool parser_tomlString(ConfigNode & node, const PString & fileContent){
        PTomlParserData data(default_PTomlParserData());
        PFileParser & parser = data.parser;
        parser.setWhiteSpace(" \n\t");
        parser.setSeparator(":-'\",{}[]>|");
        parser.setEscapeChar('\\');
        parser.setFileContent(fileContent);
        bool b(parser_toml_fileParser(node, data));
        return b;
}