parser_json.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_json.h"

struct PJsonParserData{
        PFileParser parser;
        bool isRun{true};
};
 
bool parser_json_list(ConfigNode & node, PJsonParserData & data);
bool parser_json_map(ConfigNode & node, PJsonParserData & data);


bool parser_jsonErrorAt(PJsonParserData & data, const PString & errorMsg){
        data.isRun = false;
        std::cerr << "parser_jsonErrorAt : " << data.parser.getLocation() << std::endl;
        std::cerr << "\t" << errorMsg << std::endl;
        std::cerr << "Wrong token : '"<<data.parser.getNextToken()<<"'" << std::endl;
        return true;
}


bool parser_jsonString(PString & str, PJsonParserData & data){
        if(data.parser.isMatch("\"")){
                str = "\"" + data.parser.getUntilKey("\"");
                return true;
        }
        return false;
}
 


bool parser_json_value(PString & value, PJsonParserData & data){
        PFileParser & parser = data.parser;
        parser.pushPosition();
        if(!parser_jsonString(value, data)){
                value = parser.getStrComposedOf("abcdefghijklmnopqsrtuvwxyzABCDEFGHIJKLMNOPQSRTUVWXYZ0123456789._-+");
                if(value == ""){
                        parser.popPosition();
                        parser.clearPosition();
                        return false;
                }
        }
        if(parser.isMatchRewind(":")){
                parser.popPosition();
                return false;
        }
        parser.clearPosition();
        return true;
}


bool parser_json_value(ConfigNode & node, PJsonParserData & data){
        PString value;
        if(parser_json_value(value, data)){
                node.setValue(value);
                node.setLineCol(data.parser.getLocation());
                return true;
        }
        return false;
}


bool parser_json_key(ConfigNode & node, PJsonParserData & data){
        PString key;
        if(parser_jsonString(key, data)){
                ConfigNode * child = node.addChild(key);
                if(child == NULL){      //If the child is NULL, there is already a child named key
                        ConfigNode * prevChild = node.getChild(key.eraseFirstLastChar("\"'"));
                        std::stringstream location;
                        if(prevChild != NULL){
                                location << prevChild->getLocation();
                        }
                        return parser_jsonErrorAt(data, "key '"+key+"' already defined at " + location.str());
                }
                if(data.parser.isMatch(":")){
                        child->setLineCol(data.parser.getLocation());
                        //Let's parse the value of this child (map or list or value)
                        if(parser_json_map(*child, data)){}
                        else if(parser_json_list(*child, data)){}
                        else if(parser_json_value(*child, data)){}
                        else{
                                return parser_jsonErrorAt(data, "Cannot parse json value of key '"+key+"'");
                        }
                        return data.isRun;
                }else{
                        return parser_jsonErrorAt(data, "Expect ':' after key '"+key+"'");
                }
        }else{
                return parser_jsonErrorAt(data, "Expect \"key\"': ...");
        }
        return false;
}


bool parser_json_map(ConfigNode & node, PJsonParserData & data){
        PFileParser & parser = data.parser;
        if(!parser.isMatch("{")){return false;}
        node.setLineCol(parser.getLocation());
        while(!parser.isEndOfFile() && !parser.isMatch("}") && data.isRun){
                //key:Map or key:list or key:value
                if(!parser_json_key(node, data)){
                        return parser_jsonErrorAt(data, "Expect \"key\"");
                }
                if(parser.isMatch(",")){}
                else if(parser.isMatchRewind("}")){}
                else{
                        return parser_jsonErrorAt(data, "Expect ',' or '}' after key");
                }
        }
        return data.isRun;
}


bool parser_json_list(ConfigNode & node, PJsonParserData & data){
    PFileParser & parser = data.parser;
    if(!parser.isMatch("[")){return false;}
    node.setLineCol(parser.getLocation());
    while(!parser.isEndOfFile() && !parser.isMatch("]") && data.isRun){
        // On crée un enfant anonyme pour chaque élément du tableau
        ConfigNode * child = node.addChild("");
        if(parser_json_map(*child, data)){}
        else if(parser_json_list(*child, data)){}
        else{
            PString value;
            if(parser_json_value(value, data)){
                child->setValue(value);
                child->setLineCol(data.parser.getLocation());
            }
        }
        if(parser.isMatch(",")){}
        else if(parser.isMatchRewind("]")){}
        else{
            return parser_jsonErrorAt(data, "Expect ',' or ']' after value");
        }
    }
    return data.isRun;
}


bool parser_json_fileParser(ConfigNode & node, PJsonParserData & data){
        PFileParser & parser = data.parser;
        parser.getStrComposedOf(" \t\n");               //Skip all blank characters
        if(!parser.isMatch("{")){        //It has to start as JSON
                return !parser_jsonErrorAt(data, "JSON configuration has to start with a {");
        }
        node.setLineCol(data.parser.getLocation());
        //Call the Node Parsing
        //Map or list or value or set of keys
        if(parser_json_map(node, data)){}
        else if(parser_json_list(node, data)){}
        else if(parser_json_value(node, data)){}
        else{
                while(!parser.isEndOfFile() && !parser.isMatchRewind("}") && data.isRun){
                        //key:Map or key:list or key:value
                        if(!parser_json_key(node, data)){
                                return !parser_jsonErrorAt(data, "Expect \"key\"");
                        }
                        if(parser.isMatch(",")){}
                        else if(parser.isMatchRewind("}")){}
                        else{
                                return !parser_jsonErrorAt(data, "Expect ',' or '}' after key");
                        }
                }
        }
        
        if(!parser.isMatch("}")){        //It has to start as JSON
                return !parser_jsonErrorAt(data, "JSON configuration has to end with a }");
        }
        return data.isRun;
}


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


bool parser_jsonString(ConfigNode & main, const PString & fileContent){
        PJsonParserData data;
        PFileParser & parser = data.parser;
        parser.setWhiteSpace(" \n\t");
        parser.setSeparator(":-'\",{}[]>|");
        parser.setEscapeChar('\\');
        parser.setFileContent(fileContent);
        bool b(parser_json_fileParser(main, data));
        return b;
}
 


PString toJsonSaveRecurse(const ConfigNode & node, const PString & indentation, const PString & baseIndentation, const PString & baseNewLine, bool isInList){
        PString out(""), newIndentation(indentation);
        const PString & name = node.getName();
        if(name != "" || isInList){
                newIndentation = indentation + baseIndentation;
        }
        const VecConfigNode & vecChild = node.getVecChild();
        const MapConfigNode & mapChild = node.getMapChild();
        if(mapChild.size() != 0lu){
                if(name != ""){out += baseNewLine + indentation + name.addPrefixSuffix("\"","\"") + ": {";}
                else if(isInList){out += baseNewLine+indentation+"{";}
                PString comma("");
                for(VecConfigNode::const_iterator it(vecChild.begin()); it != vecChild.end(); ++it){
                        out += comma;
                        out += toJsonSaveRecurse(**it, newIndentation, baseIndentation, baseNewLine, false);
                        comma = ",";
                }
                if(name != ""){out += baseNewLine+indentation+"}";}
                else if(isInList){out += baseNewLine+indentation+"}";}
        }else if(vecChild.size() != 0lu){
                if(name != ""){out += baseNewLine + indentation + name.addPrefixSuffix("\"","\"") + ": [";}
                PString comma("");
                for(VecConfigNode::const_iterator it(vecChild.begin()); it != vecChild.end(); ++it){
                        out += comma;
                        out += toJsonSaveRecurse(**it, newIndentation, baseIndentation, baseNewLine, true);
                        comma = ", ";
                }
                if(name != ""){out += "]";}
        }else{
                if(name != ""){out += baseNewLine + indentation + name.addPrefixSuffix("\"","\"") + ": " + node.getValue().addPrefixSuffix("\"","\"");}
                else{out += node.getValue().addPrefixSuffix("\"","\"");}
        }
        return out;
}


PString toJsonString(const ConfigNode & main, const PString & baseIndentation, const PString & baseNewLine){
        PString out("{");
        out += toJsonSaveRecurse(main, baseIndentation, baseIndentation, baseNewLine, false);
        out += baseNewLine + "}";
        return out;
}