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{
        bool isRun;
};
 
 
PTomlParserData default_PTomlParserData(){
        PTomlParserData data;
        data.isRun = true;
        return data;
}
 
bool parse_toml_var(DicoValue & dico, PFileParser & parser, PTomlParserData & data);
bool parse_toml_all(DicoValue & parent, PFileParser & parser, 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_toml_varValue(DicoValue & var, PFileParser & parser, PTomlParserData & data){
        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_toml_varValue(subValue, parser, data)){
                                var.getVecChild().push_back(subValue);
                                
                                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{
                                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;
                                }
                        }
                }
        }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_tomlCompactDico(DicoValue & parent, PFileParser & parser, PTomlParserData & data){
        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, parser, 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_varBase(DicoValue & var, PFileParser & parser, PTomlParserData & data){
        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, parser, data)){}
        else if(parse_toml_varValue(var, parser, data)){}
        else{b = false;}
        return b;
}
 
 
bool parse_toml_var(DicoValue & dico, PFileParser & parser, PTomlParserData & data){
        DicoValue var;
        if(!parse_toml_varBase(var, parser, data)){return false;}
        dico.getMapChild()[var.getKey()] = var;
        return true;
}
 
 
bool parse_toml_varTable(DicoValue & dico, PFileParser & parser, PTomlParserData & data){
        DicoValue var;
        if(!parse_toml_varBase(var, parser, 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, PFileParser & parser, PTomlParserData & data){
        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, parser, 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, PFileParser & parser, PTomlParserData & data){
        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, parser, 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, PFileParser & parser){
        PTomlParserData data(default_PTomlParserData());
        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, parser, data)){}
                else if(parse_toml_dico_def(dico, parser, 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){
        PFileParser 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, parser));
        return b;
}