HeaderParser.cpp

Go to the documentation of this file.

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

HeaderParser::HeaderParser(){
        initialisationHeaderParser();
}


HeaderParser::HeaderParser(const HeaderParser & other){
        copyHeaderParser(other);
}

HeaderParser::~HeaderParser(){
        
}


HeaderParser & HeaderParser::operator = (const HeaderParser & other){
        copyHeaderParser(other);
        return *this;
}


const PVecSource & HeaderParser::getVecSource() const{
        return p_vecSource;
}


void HeaderParser::copyHeaderParser(const HeaderParser & other){
        p_vecSource = other.p_vecSource;
}


bool HeaderParser::parseFile(){
        if(!p_run) return false;
        p_lastDocString = "";
        p_otherCode = "";
        p_currentSource.setName(p_parser->getFileName().getFileName());
        p_parser->skipWhiteSpace();
        //To parse the file we need to read char by char until we get something we know
        while(!p_parser->isEndOfFile() && p_run){                       //If we are not at the end of the file
                PFunction function;
                if(parseDocString()){}
                else if(p_parser->isMatch("//")){p_parser->getUntilKeyWithoutPatern("\n");}     //Skip comment
                else if(p_parser->isMatch("/*")){p_parser->getUntilKeyWithoutPatern("*/");}     //Skip comment
                else if(parseMacro()){}
                else if(parseFunction(function)){
                        p_currentSource.getVecFunction().push_back(function);
                }else{
                        incrementCurrentChar();
                }
                p_parser->skipWhiteSpace();
        }
        p_vecSource.push_back(p_currentSource);
        return true;
}

void HeaderParser::preLoadFile(){
        //Save the current source
        p_parser->setWhiteSpace(" \t\n");
        p_parser->setSeparator(",;{}()");
}

void HeaderParser::postLoadFile(){
        
}

void HeaderParser::initialisationHeaderParser(){
        
}


void HeaderParser::incrementCurrentChar(){
        //If nothing is known I need to save the current char in the other code
        char ch = p_parser->getCurrentCh();
        if(ch == '~'){ch = ' ';}
        p_otherCode += ch;
        p_parser->getNextChar();
}

void HeaderParser::playOtherCode(){
        if(p_otherCode != ""){
                PFunction other;
                other.setOtherCode(p_otherCode);
                p_currentSource.getVecFunction().push_back(other);
                p_otherCode = "";
        }
}


bool HeaderParser::parseMacro(){
        if(!p_parser->isMatch("#")){return false;}
        PString macro("#" + p_parser->getUntilKeyWithoutPatern("\n") + "\n");
        PFunction func;
        func.setOtherCode(macro);
        p_currentSource.getVecFunction().push_back(func);
        return true;
}


bool HeaderParser::parseDocString(){
        if(!p_parser->isMatch("///")){return false;}
        p_lastDocString = p_parser->getUntilKeyWithoutPatern("\n");
        
        return true;
}


bool HeaderParser::parseFunction(PFunction & function){
        p_parser->pushPosition();
        PString templateDef(""), returnType("");
        parseTemplateDef(templateDef);
        parseType(returnType);
        std::cerr << "HeaderParser::parseFunction : returnType = '"<<returnType<<"'" << std::endl;
        PString functionName(p_parser->getNextToken());
        if(functionName == ""){return false;}   //This is not a function
        function.setDocString(p_lastDocString);
        p_lastDocString = "";
        //Let's get the arguments of the function
        if(!p_parser->isMatch("(")){return false;}      //This is not a function
        function.setName(functionName);
        function.setOutputType(returnType);
        while(!p_parser->isEndOfFile() && !p_parser->isMatch(")") && p_run){
                PArgument arg;
                if(parseDocString()){}
                else if(p_parser->isMatch("//")){p_parser->getUntilKeyWithoutPatern("\n");}     //Skip comment
                else if(p_parser->isMatch("/*")){p_parser->getUntilKeyWithoutPatern("*/");}     //Skip comment
                else if(parseArgument(arg)){
                        function.getVecArgument().push_back(arg);
                        if(!p_parser->isMatch(",") && !isMatchRewind(")")){
                                errorAt();
                                std::cerr << "HeaderParser::parseFunction : expect ',' or ')' after function definition '"<<functionName<<"'" << std::endl;
                                return true;
                        }
                }else{
                        errorAt();
                        std::cerr << "HeaderParser::parseFunction : cannot parse attribute" << std::endl;
                        return true;
                }
                p_parser->skipWhiteSpace();
                
        }
        if(!p_parser->isMatch(";")){
                errorAt();
                std::cerr << "HeaderParser::parseFunction : expect ';' after function definition '"<<functionName<<"'" << std::endl;
                return true;
        }
        playOtherCode();
        return true;
 
}


void HeaderParser::parseTemplateDef(PString & templateDef){
        if(!p_parser->isMatchToken("template")){return;}
        
        if(!p_parser->isMatch("<")){
                errorAt();
                std::cerr << "HeaderParser::parseTemplateDef : expect '<' after 'template' token" << std::endl;
                return;
        }
        templateDef += "template<";
        bool isTemplate(true);
        while(!p_parser->isEndOfFile() && isTemplate && p_run){
                templateDef += p_parser->getNextToken();                //Some typename
                templateDef += " ";
                templateDef += p_parser->getNextToken();                //Some T
                if(p_parser->isMatch(">")){isTemplate = false;}
                else if(!p_parser->isMatch(",")){
                        errorAt();
                        std::cerr << "HeaderParser::parseTemplateDef : expect '>' or ',' after template definition '"<<templateDef<<"'" << std::endl;
                        return;
                }
        }
        templateDef += ">";
}


bool isPtrRef(const PString & str){
        return str.find("&*") || str == "__restrict__";
}


bool HeaderParser::parseArgument(PArgument & arg){
        if(p_parser->isMatchRewind(")")){return true;}
        PString type("");
        parseType(type);
        
        PString varName(""), ptrRef(""), tmpPtrRef("");
        
        tmpPtrRef = p_parser->getNextToken();
        
        if(isPtrRef(tmpPtrRef)){
                do{
                        ptrRef += tmpPtrRef;
                        tmpPtrRef = p_parser->getNextToken();
//                      if(tmpPtrRef == "__restrict__"){ptrRef += " ";}
                        
                }while(isPtrRef(tmpPtrRef));
                
                varName = tmpPtrRef;
        }else{
                ptrRef = tmpPtrRef;
                varName = ptrRef;
                ptrRef = "";
        }
        std::cerr << "HeaderParser::parseArgument : type = '"<<type<<", ptrRef = '"<<ptrRef<<"', varName = '"<<varName<<"'" << std::endl;
        PString defaultValue("");
        if(p_parser->isMatch("=")){             //Some default value
                defaultValue = p_parser->getNextToken();
                //If double quote are not token, even default strings are single token
                p_parser->pushPosition();
                PString nexToken(p_parser->getNextToken());
                if(nexToken == "("){    //We call a function/constructor
                        defaultValue += p_parser->getUntilKeyWithoutPaternRecurse(")", "(");
                }else{
                        p_parser->popPosition();        //It was not a function/constructor call
                }
        }
        arg.setName(varName);
        arg.setPtrRef(ptrRef);
        arg.setType(type);
        arg.setDefaultValue(defaultValue);
        return true;
}


void HeaderParser::parseType(PString & type){
        type = "";
        PString token(p_parser->getNextToken());
        while(token == "const" || token == "unsigned" || token == "long"){
                type += token + " ";
                token = p_parser->getNextToken();
        }
        type += token;
}