PMultiFileParser.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "PMultiFileParser.h"
 
 
 
PMultiFileParser::PMultiFileParser(const PPath & inputDirectory, const PPath & outputDirectory){
        initialisationPMultiFileParser(inputDirectory, outputDirectory);
}
 
PMultiFileParser::~PMultiFileParser(){
        
}
 
 
bool PMultiFileParser::load(const PPath & configFile){
        if(configFile == "") return false;
        PFileParser parser;
        p_listFileParser.push_back(parser);
        p_listFileParser.back().setSeparator(MULTI_PARSER_SEPARATORS_STRING);
        p_parser = &p_listFileParser.back();
        if(!p_parser->open(configFile)){
                std::cerr << "PMultiFileParser::load : can't open file '" << configFile << "'" << std::endl;
                return false;
        }
        return fullParsing();
}
 
 
void PMultiFileParser::setFileContent(const PString & fileContent){
        if(p_parser == NULL){
                PFileParser parser;
                p_listFileParser.push_back(parser);
                p_listFileParser.back().setSeparator(MULTI_PARSER_SEPARATORS_STRING);
                p_parser = &p_listFileParser.back();
        }
        p_parser = &p_listFileParser.back();
        p_parser->setFileContent(fileContent);
}
 
 
bool PMultiFileParser::fullParsing(){
        if(p_parser == NULL){
                std::cerr << "PMultiFileParser::fullParsing : the parser is not initialised, please call PMultiFileParser::load or PMultiFileParser::setFileContent before this function" << std::endl;
                return false;
        }
        preLoadFile();
        bool isParseGood(true);
        while(!p_parser->isEndOfFile() && isParseGood && p_run){
                long unsigned int currentPos = p_parser->getCurrentCharIdx();
                isParseGood = parseFile();
                if(currentPos == p_parser->getCurrentCharIdx() && !p_parser->isEndOfFile()){
                        std::cerr << "PMultiFileParser::fullParsing : the parser is stucked at the position :" << std::endl << "\t" << p_parser->getLocation() << std::endl;
                        unexpectedToken();
                        pointAtRow();
                        p_run = false;
                }
        }
        if(p_run) postLoadFile();
        p_listFileParser.pop_back();
        if(p_listFileParser.size() > 0lu) p_parser =  &p_listFileParser.back();
        else p_parser = NULL;
        return p_run;
}
 
 
void PMultiFileParser::addCommentConfig(const PMultiCommentConfig & commentConfig){
        p_listCommentConfig.push_back(commentConfig);
}
 
 
void PMultiFileParser::addCommentConfig(const PString & beginStringComment, const PString & endStringComment){
        p_listCommentConfig.push_back(PMultiCommentConfig(beginStringComment, endStringComment));
}
 
 
const PString & PMultiFileParser::getLastComment() const{
        return p_lastComment;
}
 
 
PString & PMultiFileParser::getLastComment(){
        return p_lastComment;
}
 
void PMultiFileParser::preLoadFile(){
        
}
 
void PMultiFileParser::postLoadFile(){
        
}
 
void PMultiFileParser::stopParsing(){
        p_run = false;
}
 
void PMultiFileParser::errorAt(){
        std::cerr << "\033[31mError at " << p_parser->getLocation() << " :\033[0m" << std::endl;
}
 
void PMultiFileParser::unexpectedToken(){
        errorAt();
        std::cerr << "PMultiFileParser::parseFile : unexpected token '"<<p_parser->getNextToken()<<"'" << std::endl;
        stopParsing();
}
 
void PMultiFileParser::pointAtRow(){
        std::cerr << "\tAt row :\n" << p_parser->getCurrentRow() << std::endl;
        for(size_t i(0lu); i < p_parser->getColumn(); ++i){
                std::cerr << " ";
        }
        std::cerr << "^" << std::endl;
}
 
 
bool PMultiFileParser::checkExpectedToken(const PString & tokenExpected, const PString & tokenBefore){
        if(tokenExpected == p_currentToken) return true;
        errorAt();
        std::cerr << "Unexpected token '"<<p_currentToken<<"'" << std::endl;
        std::cerr << "Expected token '"<<tokenExpected<<"'" << std::endl;
        if(tokenBefore != "") std::cerr << " after " << tokenBefore << std::endl;
        stopParsing();
        return false;
}
 
 
bool PMultiFileParser::checkExpectedMatch(const PString & tokenExpected, const PString & tokenBefore){
        if(p_parser->isMatch(tokenExpected)) return true;
        errorAt();
        std::cerr << "Unexpected token '"<<p_parser->getNextToken()<<"'" << std::endl;
        std::cerr << "Expected token '"<<tokenExpected<<"'" << std::endl;
        if(tokenBefore != "") std::cerr << " after " << tokenBefore << std::endl;
        stopParsing();
        return false;
}
 
void PMultiFileParser::skipComment(){
        bool isCommentFound(false);
        do{
                isCommentFound = false;
                PListMultiCommentConfig::iterator it(p_listCommentConfig.begin());
                while(it != p_listCommentConfig.end() && !isCommentFound && p_run && !p_parser->isEndOfFile()){
                        if(p_parser->isMatch(it->first)){
                                p_lastComment += it->first + p_parser->getUntilKey(it->second);
                                isCommentFound = true;
                        }
                        ++it;
                }
        }while(isCommentFound && p_run && !p_parser->isEndOfFile());
}
 
void PMultiFileParser::clearComment(){
        p_lastComment = "";
}
 
 
bool PMultiFileParser::isMatch(const PString & token){
        //Remove comments
        skipComment();
        //Check if the token matches
        return p_parser->isMatch(token);
}
 
 
bool PMultiFileParser::isMatchRewind(const PString & token){
        //Remove comments
        skipComment();
        //Check if the token matches
        return p_parser->isMatchRewind(token);
}
 
 
bool PMultiFileParser::isMatchSeq(const PVecString & patern, bool alwaysPopBack){
        //Remove comments
        skipComment();
        //Check if the token matches
        return p_parser->isMatchSeq(patern, alwaysPopBack);
}
 
 
bool PMultiFileParser::isMatch(const PString & patern, const PString & forbiddenCharBefore){
        //Remove comments
        skipComment();
        //Check if the token matches
        return p_parser->isMatch(patern, forbiddenCharBefore);
}
 
 
PString PMultiFileParser::isMatch(const PVecString & vecToken){
        //Remove comments
        skipComment();
        //Check if the token matches
        return p_parser->isMatch(vecToken);
}
 
 
PString PMultiFileParser::isMatchToken(const PVecString & vecToken){
        //Remove comments
        skipComment();
        //Check if the token matches
        return p_parser->isMatchToken(vecToken);
}
 
 
PString PMultiFileParser::getStrComposedOf(const PString & charset){
        //Remove comments
        skipComment();
        //Check if the token matches
        return p_parser->getStrComposedOf(charset);
}
 
void PMultiFileParser::getCurrentTokenWithoutComment(){
        if(!p_run) return;
        p_lastComment = "";
        if(p_listCommentConfig.size() != 0lu){
                bool currentTokenIsComment(true);
                while(currentTokenIsComment && p_run && !p_parser->isEndOfFile()){
                        PListMultiCommentConfig::iterator it(p_listCommentConfig.begin());
                        currentTokenIsComment = false;
                        while(it != p_listCommentConfig.end() && !currentTokenIsComment){
                                if(p_parser->isMatch(it->first)){
                                        p_lastComment = p_parser->getUntilKey(it->second);
                                        currentTokenIsComment = true;
                                }
                                ++it;
                        }
                }
        }
        p_currentToken = p_parser->getNextToken();
}
 
 
PFileParser * PMultiFileParser::getCurrentParser(){
        return p_parser;
}
 
 
void PMultiFileParser::initialisationPMultiFileParser(const PPath & inputDirectory, const PPath & outputDirectory){
        p_run = true;
        p_inputDirectory = inputDirectory;
        p_outputDirectory = outputDirectory;
        p_currentToken = "";
        clearComment();
        p_parser = NULL;
}