PFileParser.cpp

Go to the documentation of this file.

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

PFileParser::PFileParser(){
        initialisationPFileParser();
}

PFileParser::~PFileParser(){
        
}


bool PFileParser::open(const PPath & fileName){
        p_fileName = fileName;
        p_fileContent = fileName.loadFileContent();
        p_nbTotalChar = p_fileContent.size();
        return (p_fileContent != "");
}


void PFileParser::setWhiteSpace(const PString & whiteSpace){
        p_listWhiteSpace = whiteSpace;
}


void PFileParser::setSeparator(const PString & separator){
        p_listSeparator = separator;
}


void PFileParser::setFileContent(const PString & fileContent){
        p_fileContent = fileContent;
        p_nbTotalChar = p_fileContent.size();
}


void PFileParser::setEscapeChar(char escapeChar){
        p_echapChar = escapeChar;
}


void PFileParser::setLocation(const PLocation & location){
        setLine(location.getLine());
        setColumn(location.getColumn());
        p_fileName = location.getFileName();
}


void PFileParser::setCurrentCharIdx(size_t index){
        p_currentChar = index;
}


void PFileParser::setLine(size_t currentLine){
        p_currentLine = currentLine;
}


void PFileParser::setColumn(size_t currentCol){
        p_currentLineFirstColumn = currentCol;
}


bool PFileParser::isEndOfFile() const{
        return (p_currentChar >= p_nbTotalChar);
}

void PFileParser::pushPosition(){
        p_vecPosition.push_back(p_currentChar);
        p_vecLine.push_back(p_currentLine);
}

void PFileParser::popPosition(){
        if(p_vecPosition.size() == 0lu){
                return;
        }
        p_currentChar = p_vecPosition.back();
        p_currentLine = p_vecLine.back();
        p_vecPosition.pop_back();
        p_vecLine.pop_back();
}

void PFileParser::clearPosition(){
        p_vecPosition.clear();
        p_vecLine.clear();
}


bool PFileParser::isChSpace() const{
        if(isEndOfFile()) return false;
        return p_listWhiteSpace.find(p_fileContent[p_currentChar]);
}


bool PFileParser::isChSeparator() const{
        if(isEndOfFile()) return false;
        return p_listSeparator.find(p_fileContent[p_currentChar]);
}


char PFileParser::getEscapeChar() const{
        return p_echapChar;
}


PPath PFileParser::getFileName() const{
        return p_fileName;
}


PString PFileParser::getNextToken(){
        PString dummySkipedStr("");
        return getNextToken(dummySkipedStr);
}


PString PFileParser::getNextToken(PString & skippedStr){
        if(isEndOfFile()) return "";
        char ch = p_fileContent[p_currentChar];
        while(!isEndOfFile() && p_listWhiteSpace.find(ch)){
                skippedStr += ch;
                incrementCurrentChar();
                if(isEndOfFile()) return "";
                ch = p_fileContent[p_currentChar];
        }
        //We are sur ethe current char is not a white character
        if(p_listSeparator.find(ch) && !isEndOfFile()){       //If is it a separator, we stop
                incrementCurrentChar();
                PString s("");
                s += ch;
                return s;
        }
        //If not we get all characters until the next white character or separator character
        PString buf("");
        while(!isEndOfFile() && !p_listWhiteSpace.find(ch) && !p_listSeparator.find(ch)){
                buf += ch;
                incrementCurrentChar();
                if(isEndOfFile()){return buf;}
                ch = p_fileContent[p_currentChar];
        }
        return buf;
}


char PFileParser::getNextChar(){
        incrementCurrentChar();
        if(p_currentChar < p_nbTotalChar){
                char ch = p_fileContent[p_currentChar];
                return ch;
        }else{
                p_currentChar = p_nbTotalChar;
                return '\0';
        }
}


PString PFileParser::getUntilKey(const PString & patern){
        if(patern == "" || p_nbTotalChar == 0lu || isEndOfFile()) return "";
        return getUntilKeyWithoutPatern(patern) + patern;
}


PString PFileParser::getUntilKeyWithoutPatern(const PString & patern){
        if(patern == "" || p_nbTotalChar == 0lu || isEndOfFile()) return "";
        size_t sizePatern(patern.size());
        std::string out(""); //on évite les petits désagréments
        size_t sizeSrc(p_nbTotalChar - p_currentChar);
        size_t beginTest(0lu), beginLine(0lu), beginI(0lu), nbMatch(0lu);
        for(size_t i(0lu); i < sizeSrc; ++i){
                if(p_fileContent[p_currentChar] == patern[nbMatch] && !p_currentCharEchaped){ //si le caractère i est le même que le caractère nbMatch
                        if(nbMatch == 0lu){ //c'est le premier qu'on teste
                                beginTest = p_currentChar; //il faut donc se rappeler où on a commencer à faire le test
                                beginLine = p_currentLine;
                                beginI = i;
                        }
                        ++nbMatch;          //la prochaîne fois on testera le caractère suivant
                        if(nbMatch == sizePatern){ //dans ce cas, on a tout testé et tout les caractères correspondent, donc on sauvegarde
                                incrementCurrentChar();
                                return out;
                        }
                }else{                      //si le caractère i n'est pas le même caractère que nbMatch
                        if(nbMatch == 0lu){        //si on n'en avait pas trouver de bon avant
                                out += p_fileContent[p_currentChar];       //on ne change rien à ce caractère
                        }else{                  //si on avais déjà tester des caractères avant
                                out += p_fileContent[beginTest];
                                p_currentChar = beginTest;
                                p_currentLine = beginLine;
                                i = beginI;
                        }
                        beginTest = 0lu;  //on remet le début des tests à 0 (pour évité les dépassements, on ne sait jamais)
                        nbMatch = 0lu;    //on remet ne nombre des tests à 0, comme on n'a pas trouver de nouveau le motif
                }
                incrementCurrentChar();
        }
        return out;
}


PString PFileParser::getUntilKeyWithoutPaternExclude(const PString & patern, const PString & strNotBeforeEndPatern){
        if(patern == "" || p_nbTotalChar == 0lu || isEndOfFile()) return "";
        std::string out(""); //on évite les petits désagréments
        bool prevSkipSpace(p_dontSkipSpace);
        p_dontSkipSpace = true;
        bool skiptNextEnd(false);
        while(!isEndOfFile()){
                 if(isMatch(strNotBeforeEndPatern)){
                        out += strNotBeforeEndPatern;
                        skiptNextEnd = true;
                }else if(skiptNextEnd){
                        skiptNextEnd = false;
                        out += p_fileContent[p_currentChar];
                        incrementCurrentChar();
                }else if(isMatch(patern)){
                        p_dontSkipSpace = prevSkipSpace;
                        return out;
                }else{
                        out += p_fileContent[p_currentChar];
                        incrementCurrentChar();
                }
        }
        p_dontSkipSpace = prevSkipSpace;
        return out;
}


PString PFileParser::getUntilKeyWithoutPaternRecurse(const PString & patern, const PString & beginPatern,
                                                         const PString & allowedCharAfterBegin)
{
        if(patern == "" || beginPatern == "" || p_nbTotalChar == 0lu || isEndOfFile()) return "";
        bool prevSkipSpace(p_dontSkipSpace);
        p_dontSkipSpace = true;
        std::string out("");
        long int nbEmbeded(1lu);
        while(!isEndOfFile()){
                if(isMatch(patern)){
                        --nbEmbeded;
                        if(nbEmbeded <= 0l){
                                p_dontSkipSpace = prevSkipSpace;
                                return out;
                        }else{
                                out += patern;
                        }
                }else if(isMatch(beginPatern)){
                        if(allowedCharAfterBegin.find(p_fileContent[p_currentChar])){
                                out += beginPatern;
                                ++nbEmbeded;
                        }
                }else{
                        out += p_fileContent[p_currentChar];
                        incrementCurrentChar();
                }
        }
        p_dontSkipSpace = prevSkipSpace;
        return out;
}


PString PFileParser::getUntilKeyWithoutPaternRecurseExclude(const PString & patern, const PString & beginPatern,
                                                                                const PString & echapExpr)
{
        if(patern == "" || beginPatern == "" || p_nbTotalChar == 0lu || isEndOfFile()) return "";
        bool prevSkipSpace(p_dontSkipSpace);
        p_dontSkipSpace = true;
        std::string out("");
        long int nbEmbeded(1lu);
        bool skiptNextEnd(false);
        while(!isEndOfFile()){
                 if(isMatch(echapExpr)){
                        out += echapExpr;
                        skiptNextEnd = true;
                }else if(skiptNextEnd){
                        skiptNextEnd = false;
                        out += p_fileContent[p_currentChar];
                        incrementCurrentChar();
                }else if(isMatch(patern)){
                        --nbEmbeded;
                        if(nbEmbeded <= 0l){
                                p_dontSkipSpace = prevSkipSpace;
                                return out;
                        }else{
                                out += patern;
                        }
                }else if(isMatch(beginPatern)){
                        out += beginPatern;
                        ++nbEmbeded;
                }else{
                        out += p_fileContent[p_currentChar];
                        incrementCurrentChar();
                }
        }
        p_dontSkipSpace = prevSkipSpace;
        return out;
}


PString PFileParser::getUntilKeyWithoutPaternRecurse(const PString & patern, const PString & beginPatern)
{
        if(patern == "" || beginPatern == "" || p_nbTotalChar == 0lu || isEndOfFile()) return "";
        bool prevSkipSpace(p_dontSkipSpace);
        p_dontSkipSpace = true;
        std::string out("");
        long int nbEmbeded(1l);
        while(!isEndOfFile()){
                if(isMatch(patern)){
                        --nbEmbeded;
                        if(nbEmbeded <= 0l){
                                p_dontSkipSpace = prevSkipSpace;
                                return out;
                        }else{
                                out += patern;
                        }
                }else if(isMatch(beginPatern)){
                        out += beginPatern;
                        ++nbEmbeded;
                }else{
                        out += p_fileContent[p_currentChar];
                        incrementCurrentChar();
                }
        }
        p_dontSkipSpace = prevSkipSpace;
        return out;
}


PString PFileParser::getStrComposedOf(const PString & charset){
        PString tmpWhiteSpace(p_listWhiteSpace.eraseChar(charset));
        if(tmpWhiteSpace != ""){
                skipChars(tmpWhiteSpace);
        }
        std::string out("");
        bool isInCharSet(true);
        while(!isEndOfFile() && isInCharSet){
                char ch = p_fileContent[p_currentChar];
                isInCharSet = charset.find(ch);
                if(isInCharSet){
                        out += ch;
                        incrementCurrentChar();
                }
        }
        return out;
}


PString PFileParser::getCurrentRow() const{
        if(p_fileContent.empty()) return "";
        size_t currentCharIndex(p_currentChar);
        char ch = p_fileContent[currentCharIndex];
        size_t indexBeginRow(currentCharIndex);
        size_t indexEndRow(currentCharIndex);
        if(ch != '\n'){
                while(p_fileContent[indexEndRow] != '\n' && !isEndOfFile()){
                        ++indexEndRow;
                }
        }
        if(ch == '\n' && indexBeginRow != 0lu){
                --indexBeginRow;
        }
        while(p_fileContent[indexBeginRow] != '\n' && indexBeginRow != 0lu){
                --indexBeginRow;
        }
        if(p_fileContent[indexBeginRow] == '\n'){indexBeginRow++;}
        return p_fileContent.substr(indexBeginRow, indexEndRow - indexBeginRow);
}


bool PFileParser::isMatch(const PString & patern){
        if(patern == "" || isEndOfFile() || p_currentCharEchaped) return false;
        skipWhiteSpace();
        size_t nbCharPatern(patern.size());
        if(p_currentChar + nbCharPatern > p_nbTotalChar){return false;}
        bool match = true;
        size_t i(0lu);
        while(match && i < nbCharPatern){
                match = (patern[i] == p_fileContent[p_currentChar + i]);
                ++i;
        }
        if(match){
                incrementCurrentChar(nbCharPatern);
        }
        return match;
}


bool PFileParser::isMatchRewind(const PString & patern){
        pushPosition();
        bool b = isMatch(patern);
        popPosition();
        return b;
}


bool PFileParser::isMatchSeq(const PVecString & patern, bool alwaysPopBack){
        pushPosition();
        PVecString::const_iterator it(patern.begin());
        bool matchPatern(true);
        while(it != patern.end() && matchPatern){
                matchPatern = isMatch(*it);
                ++it;
        }
        if(!matchPatern || alwaysPopBack){
                popPosition();
        }
        return matchPatern;
}


bool PFileParser::isMatch(const PString & patern, const PString & forbiddenCharBefore){
        if(p_currentChar > 0lu){
                //If we find a forbidden character before the current char, the patern is canceled
                if(forbiddenCharBefore.find(p_fileContent[p_currentChar - 1lu])){
                        return false;
                }
        }
        return isMatch(patern);
}


bool PFileParser::isMatchToken(const PString & patern){
        pushPosition();
        if(!isMatch(patern)){
                popPosition();
                return false;
        }
        PString letterNumberUnderscore("_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
        if(p_currentChar > patern.size()){
                if(letterNumberUnderscore.find(p_fileContent[p_currentChar - patern.size() - 1lu])){
                        popPosition();
                        return false;
                }
        }
        if(p_nbTotalChar > p_currentChar){
                if(letterNumberUnderscore.find(p_fileContent[p_currentChar])){
                        popPosition();
                        return false;
                }
        }
        return true;
}


PString PFileParser::isMatch(const PVecString & patern){
        if(patern.size() == 0lu) return "";
        PVecString::const_iterator it(patern.begin());
        while(it != patern.end()){
                if(isMatch(*it)) return *it;
                ++it;
        }
        return "";
}


PString PFileParser::isMatchToken(const PVecString & patern){
        if(patern.size() == 0lu) return "";
        PVecString::const_iterator it(patern.begin());
        while(it != patern.end()){
                if(isMatchToken(*it)) return *it;
                ++it;
        }
        return "";
}


PString PFileParser::isMatch(const std::vector<PVecString > & patern){
        if(patern.size() == 0lu) return "";
        std::vector<PVecString >::const_iterator itList(patern.begin());
        while(itList != patern.end()){
                PVecString::const_iterator it(itList->begin());
                while(it != itList->end()){
                        if(isMatch(*it)) return *it;
                        ++it;
                }
                ++itList;
        }
        return "";
}


PString PFileParser::isMatch(const PParseSeq & seq){
        pushPosition();
        PString body("");
        const PVecParseStep & vecStep = seq.getVecStep();
        PVecParseStep::const_iterator itStep(vecStep.begin());
        bool isParseNextStep(true);
        while(itStep != vecStep.end() && isParseNextStep){
                isParseNextStep = itStep->getIsOptional();
                const PVecParseCmd & vecCmd = itStep->getVecCmd();
                bool isMatchedCmd(false);
                PVecParseCmd::const_iterator itCmd(vecCmd.begin());
                while(itCmd != vecCmd.end() && !isMatchedCmd){
                        PString str(itCmd->getStr());
                        if(itCmd->getIsMatch()){
                                isMatchedCmd = isMatch(str);
                                body += str;
                        }else{
                                PString res(getStrComposedOf(str));
                                if(res != ""){
                                        body += res;
                                        isMatchedCmd = true;
                                }
                        }
                        ++itCmd;
                }
                isParseNextStep |= isMatchedCmd;
                ++itStep;
        }
        if(!isParseNextStep){
                popPosition();
                body = "";
        }
        return body;
}


bool PFileParser::isWhiteSpace(){
        if(isEndOfFile()) return false;
        if(p_listWhiteSpace.find(p_fileContent[p_currentChar])){
                do{
                        incrementCurrentChar();
                }while(p_listWhiteSpace.find(p_fileContent[p_currentChar]) && !isEndOfFile());
                return true;
        }else return false;
}

void PFileParser::skipWhiteSpace(){
        if(p_dontSkipSpace){return;}
        if(p_listWhiteSpace.find(p_fileContent[p_currentChar])){
                do{
                        incrementCurrentChar();
                }while(p_listWhiteSpace.find(p_fileContent[p_currentChar]) && !isEndOfFile());
        }
}


void PFileParser::skipChars(const PString & chToSkip){
        if(chToSkip.find(p_fileContent[p_currentChar])){
                do{
                        incrementCurrentChar();
                }while(chToSkip.find(p_fileContent[p_currentChar]) && !isEndOfFile());
        }
}


PString PFileParser::getWhiteSpace() const{
        return p_listWhiteSpace;
}


PString PFileParser::getSeparator() const{
        return p_listSeparator;
}


char PFileParser::getCurrentCh() const{
        if(isEndOfFile()) return '\0';
        return p_fileContent[p_currentChar];
}


char PFileParser::getPrevCh() const{
        if(isEndOfFile() && p_currentChar > 0lu) return '\0';
        return p_fileContent[p_currentChar - 1lu];
}


char PFileParser::getChar(size_t index) const{
        if(index >= p_nbTotalChar) return '\0';
        return p_fileContent[index];
}


size_t PFileParser::getLine() const{
        return p_currentLine;
}


size_t PFileParser::getColumn() const{
        if(p_currentChar > p_currentLineFirstColumn){
                return p_currentChar - p_currentLineFirstColumn;
        }else{return 0lu;}
}


size_t PFileParser::getNbTotalChar() const{
        return p_nbTotalChar;
}


size_t PFileParser::getCurrentCharIdx() const{
        return p_currentChar;
}


size_t PFileParser::getLineIndentation(){
        //First, let's get the current column
        size_t indentation(0lu), currentCharIdx(p_currentLineFirstColumn);
        while(currentCharIdx < p_nbTotalChar && PString(" \t").find(p_fileContent[currentCharIdx])){
                ++indentation;
                ++currentCharIdx;
        }
        if(currentCharIdx > p_currentChar){
                p_currentChar = currentCharIdx;            //Anyway, it was just white character
        }
        
        return indentation;
}


PLocation PFileParser::getLocation() const{
        return PLocation(p_fileName, p_currentLine, getColumn());
}


std::ostream & operator << (std::ostream & out, const PFileParser & other){
        out << "file '" << other.getFileName() << "' line " << other.getLine() << ":" << other.getColumn();
        return out;
}

void PFileParser::initialisationPFileParser(){
        p_currentChar = 0lu;
        p_currentLine = 1lu;
        p_currentLineFirstColumn = 0lu;
        p_fileContent = "";
        p_listWhiteSpace = " \t\n";
        p_listSeparator = "()[]{}+=.;,:/*%<>#";
        p_echapChar = '\0';
        p_dontSkipSpace = false;
        p_currentCharEchaped = false;
}

void PFileParser::incrementCurrentLine(){
        ++p_currentLine;
        p_currentLineFirstColumn = p_currentChar + 1lu;
}


void PFileParser::incrementCurrentChar(size_t nbChar){
        for(size_t i(0lu); i < nbChar; ++i){
                if(p_fileContent[p_currentChar] == '\n'){
                        incrementCurrentLine();
                }
                p_currentCharEchaped = !p_currentCharEchaped && p_fileContent[p_currentChar] == p_echapChar && p_echapChar != '\0';
                if(p_currentChar < p_nbTotalChar){
                        ++p_currentChar;
                }
        }
}