parserClassConfig.cpp

Go to the documentation of this file.

 
/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include <iostream>
#include "class_attribute_utils.h"
#include "parserClassConfig.h"


void errorUnexpectedToken(const PFileParser & parser, const PString & token){
        std::cerr << "errorUnexpectedToken : '" << parser.getFileName() << "' line " << parser.getLine() << std::endl;
        std::cerr << "unexpected token '" << token << "'" << std::endl;
}


PString getClassName(PFileParser & parser){
        PString name = parser.getStrComposedOf("_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
        while(parser.isMatch("::")){
                name += "::" + parser.getStrComposedOf("_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
        }
        return name;
}


bool updateCurrentComment(PFileParser & parser, PString & currentComment){
        if(parser.isMatch("//")){
                if(currentComment != ""){currentComment += "\n";}
                currentComment += "//" + parser.getUntilKeyWithoutPatern("\n");
        }else if(parser.isMatch("/*")){
                if(currentComment != ""){currentComment += "\n";}
                currentComment += "/*" + parser.getUntilKey("*/");
        }else{
                return false;
        }
        return true;
}


bool updateCurrentTemplate(PFileParser & parser, PVecString & currentTemplate){
        if(!parser.isMatch("template")){return false;}
        if(!parser.isMatch("<")){return false;}
        
        currentTemplate = parser.getUntilKeyWithoutPaternRecurse(">", "<").split(',');
        
        return true;
}


bool parseClassConfigAttribut(PClassConfig & config,  PFileParser & parser, PString & currentComment){
        parser.skipWhiteSpace();
        PString attribut(parser.getUntilKeyWithoutPatern(";").eraseChar("\n"));
        PVecString listToken(attribut.split(" \n\t"));
        PString attributName(listToken.back());
        listToken.pop_back();
        PString attributType("");
        for(PVecString::iterator it(listToken.begin()); it != listToken.end(); ++it){
                attributType += *it + " ";
        }
        attributType = attributType.eraseFirstLastChar(" \n\t");
        config.addAttribute(createClassAttribute(attributType, attributName, currentComment));
        currentComment = "";
        return true;
}


bool parseParentOfClassConfig(PClassConfig & config, PFileParser & parser){
        if(!parser.isMatch("(")) return true;
        
        while(!parser.isEndOfFile() && parser.isMatch(")")){
                PString parentDef(getClassName(parser));
                if(parentDef == ""){
                        break;
                }
                config.addParentClass(parentDef);
                if(parser.isMatch(")")){break;}
                
                if(!parser.isMatch(",")){
                        errorUnexpectedToken(parser, parser.getNextToken());
                        return false;
                }
        }
        return true;
}


bool parseEnumValue(PClassConfig & config,  PFileParser & parser, PString & currentComment){
        PString enumValue(getClassName(parser)), value("");
        if(!parser.isMatch("=")){
                value = parser.getStrComposedOf("0123456789xu");
        }
        PClassAttribute attr(createClassAttribute("int /* just to remember*/", enumValue, currentComment));
        attr.setDefaultValue(value);
        config.addAttribute(attr);
        currentComment = "";
        parser.isMatch(",");    //We consume the comma if there is one
        return true;
}


bool parseEnumConfig(std::vector<PClassConfig> & listClassConfig, PFileParser & parser, PString & currentComment){
        if(!parser.isMatchToken("enum")){return false;}
        PClassConfig config;
        config.setIsEnum(true);
        PString enumName(getClassName(parser));     //Get the name of the enum
        std::cout << "parseEnumConfig : find enum : '"<<enumName<<"'" << std::endl;
        config.setName(enumName);
        config.setClassDocumentation(currentComment);
        currentComment = "";
        parser.skipWhiteSpace();
        if(!parser.isMatch("{")){
                errorUnexpectedToken(parser, parser.getNextToken());
                std::cerr << "\tExpect '{' after enum name '"<<enumName<<"'" << std::endl;
                return false;
        }
        bool searchingData(true);
        while(!parser.isEndOfFile() && searchingData && !parser.isMatch("}")){
                if(updateCurrentComment(parser, currentComment)){}
                else{           //Si ce n'est pas un séparateur, c'est que l'on a trouvé un nom, de PDataGroup ou de PDataVar ou PDataTable
                        if(!parseEnumValue(config, parser, currentComment)){
                                errorUnexpectedToken(parser, parser.getNextToken());
                                return false;
                        }
                }
        }
        listClassConfig.push_back(config);
        return true;
}


bool parsePClassConfig(std::vector<PClassConfig> & listClassConfig, PFileParser & parser, PString & currentComment, PVecString & listTemplate){
        PClassConfig config;
        PString fullName(getClassName(parser));
        size_t separator = fullName.rfind("::");
        PString className, namespaceName;
        if(separator != PString::npos){
                className = fullName.substr(separator + 2);
                namespaceName = fullName.substr(0, separator);
                std::cout << "parsePClassConfig : find namespaceName : '"<<namespaceName<<"'" << std::endl;
        }else{
                className = fullName;
        }
        std::cout << "parsePClassConfig : find className : '"<<className<<"'" << std::endl;
        config.setName(className);
        config.setNamespace(namespaceName);
        config.setClassDocumentation(currentComment);
        config.setListTemplate(listTemplate);
        currentComment = "";
        listTemplate.clear();
        parser.skipWhiteSpace();
        
        if(!parseParentOfClassConfig(config, parser)){
                std::cerr << "parsePClassConfig : file '" << parser.getFileName() << "' line " << parser.getLine() << std::endl;
                std::cerr << "\tmissing ')' : can't parse parents of the class '"<<config.getName()<<"'" << std::endl;
        }
        if(parser.isEndOfFile()){
                std::cerr << "parsePClassConfig : file '" << parser.getFileName() << "' line " << parser.getLine() << std::endl;
                std::cerr << "\tmissing '}'" << std::endl;
                return false;
        }
        if(!parser.isMatch("{")){
                errorUnexpectedToken(parser, parser.getNextToken());
                std::cerr << "\tExpect '{' after class name '"<<className<<"'" << std::endl;
                return false;
        }
        
        bool searchingData(true);
        while(!parser.isEndOfFile() && searchingData && !parser.isMatch("}")){
                if(updateCurrentComment(parser, currentComment)){}
                else{           //Si ce n'est pas un séparateur, c'est que l'on a trouvé un nom, de PDataGroup ou de PDataVar ou PDataTable
                        if(!parseClassConfigAttribut(config, parser, currentComment)){
                                errorUnexpectedToken(parser, parser.getNextToken());
                                return false;
                        }
                }
        }
        listClassConfig.push_back(config);
        return true;
}


bool parserClassConfig(std::vector<PClassConfig> & listClassConfig, PVecPath & listInclude, const PPath & fileName){
        if(fileName == "") return false;
        PFileParser  parser;
        parser.setWhiteSpace(" \t\n");
        parser.setSeparator("{};/*");
        if(!parser.open(fileName)) return false;
        PString currentComment("");
        PVecString listTemplate;
        while(!parser.isEndOfFile()){
                if(parser.isMatch("#")){
                        if(parser.isMatch("include")){
                                listInclude.push_back(parser.getUntilKeyWithoutPatern("\n").eraseChar(" \t\n"));
                        }
                }else if(updateCurrentComment(parser, currentComment)){}
                else if(updateCurrentTemplate(parser, listTemplate)){}
                else if(parseEnumConfig(listClassConfig, parser, currentComment)){}
                else{           //Si ce n'est pas un séparateur, c'est que l'on a trouvé un nom, de PClassConfig
                        if(!parsePClassConfig(listClassConfig, parser, currentComment, listTemplate)){
                                errorUnexpectedToken(parser, parser.getNextToken());
                                return false;
                        }
                }
                parser.skipWhiteSpace();
        }
        return true;
}