Head

GCC Code Coverage Report
Directory:	./		Exec	Total	Coverage
File:	tmp_project/FileParser/src/PFileParser.cpp	Lines:	402	427	94.1 %
Date:	2024-09-10 03:06:26	Branches:	393	488	80.5 %


/***************************************
	Auteur : Pierre Aubert
	Mail : pierre.aubert@lapp.in2p3.fr
	Licence : CeCILL-C
****************************************/

#include "PFileParser.h"

using namespace std;

///Constructeur de PFileParser
PFileParser::PFileParser(){
	initialisationPFileParser();
}

///Destructeur de PFileParser
PFileParser::~PFileParser(){

}

///Initialise la liste des caractères blancs
/**	@param whiteSpace : liste des caractères blancs
 * 	Se sont les caractères que l'on ne prend jamais en compte
*/
void PFileParser::setWhiteSpace(const std::string & whiteSpace){
	p_listWhiteSpace = whiteSpace;
}

///Initialise la liste des caractères séparateurs
/**	@param separator : liste des caractères séparateurs
 * 	Se sont les caractères que l'on ne prend en compte un par un
*/
void PFileParser::setSeparator(const std::string & separator){
	p_listSeparator = separator;
}

///Set the file content
/**	@param fileContent : file content
*/
void PFileParser::setFileContent(const std::string & fileContent){
	p_fileContent = fileContent;
	p_nbTotalChar = p_fileContent.size();
}

///Sets the escape character of the PFileParser
/**	@param escapeChar : escape character of the PFileParser
*/
void PFileParser::setEscapeChar(char escapeChar){
	p_echapChar = escapeChar;
}

///Set the current location of the PFileParser
/**	@param location : current location of the PFileParser
*/
void PFileParser::setLocation(const PLocation & location){
	setLine(location.getLine());
	setColumn(location.getColumn());
	p_fileName = location.getFileName();
}

///Set the current line of the PFileParser
/**	@param currentLine : current line of the PFileParser
*/
void PFileParser::setLine(size_t currentLine){
	p_currentLine = currentLine;
}

///Set the current column of the PFileParser
/**	@param currentCol : current column of the PFileParser
*/
void PFileParser::setColumn(size_t currentCol){
	p_currentLineFirstColumn = currentCol;
}

///Fonction qui ouvre le fichier que l'on va parser
/**	@param fileName : nom du fichier à ouvrir
 * 	@return true si la fonction à réussie, false sinon
*/
bool PFileParser::open(const std::string & fileName){
	p_fileName = fileName;
	p_fileContent = getFileContent(fileName);
	p_nbTotalChar = p_fileContent.size();
	return (p_fileContent != "");
}

///Dit si on est à la fin du fichier
/**	@return true si on est à la fin du fichier, false sinon
*/
bool PFileParser::isEndOfFile() const{
	return (p_currentChar >= p_nbTotalChar);
}

///Remember the current position of the PFileParser in the current file
void PFileParser::pushPosition(){
	p_vecPosition.push_back(p_currentChar);
	p_vecLine.push_back(p_currentLine);
}

///Get to the last saved position of the PFileParser in the current file
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();
}

///Clear the save position of the parser in ther current file
void PFileParser::clear(){
	p_vecPosition.clear();
	p_vecLine.clear();
}

///Dis si le caractère courant est un caractère blanc
/**	@return true si caractère courant est un caractère blanc
*/
bool PFileParser::isChSpace() const{
	if(isEndOfFile()) return false;
	return findInString(p_listWhiteSpace, p_fileContent[p_currentChar]);
}

///Dis si le caractère courant est un séparateur
/**	@return true si caractère courant est un séparateur
*/
bool PFileParser::isChSeparator() const{
	if(isEndOfFile()) return false;
	return findInString(p_listSeparator, p_fileContent[p_currentChar]);
}

///Gets the escape character of the PFileParser
/**	@return escape character of the PFileParser
*/
char PFileParser::getEscapeChar() const{
	return p_echapChar;
}

///Fonction qui renvoie le nom du fichier que l'on a ouvert
/**	@return nom du fichier que l'on a ouvert
*/
std::string PFileParser::getFileName() const{
	return p_fileName;
}

///Get the next token
/**	@return next token
*/
std::string PFileParser::getNextToken(){
	std::string dummySkipedStr("");
	return getNextToken(dummySkipedStr);
}

///Get the next token and return also the skipped characters until the next token
/**	@param[out] skippedStr : string of skipped characters
 * 	@return next token
*/
std::string PFileParser::getNextToken(std::string & skippedStr){
	if(isEndOfFile()) return "";
	char ch = p_fileContent[p_currentChar];
	while(!isEndOfFile() && findInString(p_listWhiteSpace, ch)){
		skippedStr += ch;
		incrementCurrentChar();
		if(isEndOfFile()) return "";
		ch = p_fileContent[p_currentChar];
	}
	//We are sur ethe current char is not a white character
	if(findInString(p_listSeparator, ch) && !isEndOfFile()){	//If is it a separator, we stop
		incrementCurrentChar();
		std::string s("");
		s += ch;
		return s;
	}
	//If not we get all characters until the next white character or separator character
	std::string buf("");
	while(!isEndOfFile() && !findInString(p_listWhiteSpace, ch) && !findInString(p_listSeparator, ch)){
		buf += ch;
		incrementCurrentChar();
		if(isEndOfFile()){return buf;}
		ch = p_fileContent[p_currentChar];
	}
	return buf;
}

///Fonction qui renvoie le prochain caractère du fichier courant
/**	@return prochain caractère du fichier courant ou le caractère NULL si on est à la fin
*/
char PFileParser::getNextChar(){
	incrementCurrentChar();
	if(p_currentChar < p_nbTotalChar - 1lu){
		char ch = p_fileContent[p_currentChar];
		return ch;
	}else{
		p_currentChar = p_nbTotalChar;
		return '\0';
	}
}

///Renvoie la chaine de caractère du caractère courant jusqu'à patern comprise
/**	@param patern : séquence d'arrêt
 * 	@return chaine de caractère du caractère courant jusqu'à patern comprise
*/
std::string PFileParser::getUntilKey(const std::string & patern){
	if(patern == "" || p_nbTotalChar == 0lu || isEndOfFile()) return "";
	return getUntilKeyWithoutPatern(patern) + patern;
}

///Renvoie la chaine de caractère du caractère courant jusqu'à patern exclu
/**	@param patern : séquence d'arrêt
 * 	@return chaine de caractère du caractère courant jusqu'à patern exclu
*/
std::string PFileParser::getUntilKeyWithoutPatern(const std::string & patern){
	if(patern == "" || p_nbTotalChar == 0lu || isEndOfFile()) return "";
	size_t sizePatern(patern.size());
	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]){ //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;
}

///Parse a string until the patern is found, only if it has not strNotBeforeEndPatern before it
/**	@param patern : patern to be found
 * 	@param strNotBeforeEndPatern : string which cannot be found before the patern, otherwise the patern is not considered as the end
 * 	@return string unit patern, without it
*/
std::string PFileParser::getUntilKeyWithoutPaternExclude(const std::string & patern, const std::string & strNotBeforeEndPatern){
	if(patern == "" || p_nbTotalChar == 0lu || isEndOfFile()) return "";
	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;
}

///Get the string until end sequence and take account recursive patern (embeded strings)
/**	@param patern : end patern
 * 	@param beginPatern : definition of new embeded string
 * 	@param allowedCharAfterBegin : characters allowed after the beginPatern
 * 	@return output string
*/
std::string PFileParser::getUntilKeyWithoutPaternRecurse(const std::string & patern, const std::string & beginPatern,
							 const std::string & 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(findInString(allowedCharAfterBegin, p_fileContent[p_currentChar])){
				out += beginPatern;
				++nbEmbeded;
			}
		}else{
			out += p_fileContent[p_currentChar];
			incrementCurrentChar();
		}
	}
	p_dontSkipSpace = prevSkipSpace;
	return out;
}

///Get the string until end sequence and take account recursive patern (embeded strings)
/**	@param patern : end patern
 * 	@param beginPatern : definition of new embeded string
 * 	@param echapExpr : echap expression
 * 	@return output string
*/
std::string PFileParser::getUntilKeyWithoutPaternRecurseExclude(const std::string & patern, const std::string & beginPatern,
										const std::string & 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;
}

///Get the string until end sequence and take account recursive patern (embeded strings)
/**	@param patern : end patern
 * 	@param beginPatern : definition of new embeded string
 * 	@return output string
*/
std::string PFileParser::getUntilKeyWithoutPaternRecurse(const std::string & patern, const std::string & 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;
}

///Get string composed of the characters in the string charset
/**	@param charset : set of the available characters to get the current string
 * 	@return corresponding string
*/
std::string PFileParser::getStrComposedOf(const std::string & charset){
	std::string tmpWhiteSpace(eraseCharsInStr(p_listWhiteSpace, charset));
	if(tmpWhiteSpace != ""){
		skipChars(tmpWhiteSpace);
	}

	std::string out("");
	bool isInCharSet(true);
	while(!isEndOfFile() && isInCharSet){
		char ch = p_fileContent[p_currentChar];
		isInCharSet = findInString(charset, ch);
		if(isInCharSet){
			out += ch;
			incrementCurrentChar();
		}
	}
	return out;
}

///Get the current parsed row
/**	@return current parsed row
*/
std::string 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);
}

///Says if the patern match with the current caracters of the PFileParser
/**	@param patern : patern we want to check (this patern should not begin with white caracters)
 * 	@return true if the patern match, false otherwise
 * 	If the patern match, the current char will be in the next char of the patern
*/
bool PFileParser::isMatch(const std::string & patern){
	if(patern == "" || isEndOfFile()) 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;
}

///Do a isMatch and then go back at the previous position
/**	@param patern : patern we want to check (this patern should not begin with white caracters)
 * 	@return true if the patern match, false otherwise
 * 	If the patern match, the current char will be in the next char of the patern
*/
bool PFileParser::isMatchRewind(const std::string & patern){
	pushPosition();
	bool b = isMatch(patern);
	popPosition();
	return b;
}

///Match a sequence of token in a vector
/**	@param patern : set of token to match in this order and totally
 * 	@param alwaysPopBack : true to make the PFileParser at the exact same place before the check even is the sequence matches
 * 	@return true if the full sequence matches, false otherwise
*/
bool PFileParser::isMatchSeq(const std::vector<std::string> & patern, bool alwaysPopBack){
	pushPosition();
	std::vector<std::string>::const_iterator it(patern.begin());
	bool matchPatern(true);
	while(it != patern.end() && matchPatern){
		matchPatern = isMatch(*it);
		++it;
	}
	if(!matchPatern || alwaysPopBack){
		popPosition();
	}
	return matchPatern;
}

///Says if the patern match with the current caracters of the PFileParser
/**	@param patern : patern we want to check (this patern should not begin with white caracters)
 * 	@param forbiddenCharBefore : lisr of characters which cannot be just before the first character of the patern
 * 	@return true if the patern match, false otherwise
 * 	If the patern match, the current char will be in the next char of the patern
*/
bool PFileParser::isMatch(const std::string & patern, const std::string & forbiddenCharBefore){
	if(p_currentChar > 0lu){
		//If we find a forbidden character before the current char, the patern is canceled
		if(findInString(forbiddenCharBefore, p_fileContent[p_currentChar - 1lu])){
			return false;
		}
	}
	return isMatch(patern);
}

///Says if the patern match with the current caracters of the PFileParser but treats the string as a token (cannot be part of a word)
/**	@param patern : patern we want to check (this patern should not begin with white caracters)
 * 	@return true if the patern match, false otherwise
 * 	If the patern match, the current char will be in the next char of the patern
*/
bool PFileParser::isMatchToken(const std::string & patern){
	pushPosition();
	if(!isMatch(patern)){
		popPosition();
		return false;
	}

	if(p_currentChar > patern.size()){
		if(findInString("_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", p_fileContent[p_currentChar - patern.size() - 1lu])){
			popPosition();
			return false;
		}
	}
	if(p_nbTotalChar > p_currentChar){
		if(findInString("_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", p_fileContent[p_currentChar])){
			popPosition();
			return false;
		}
	}
	return true;
}

///Check the matching between the current caracters and all the string in the vector
/**	@param patern : vector of the patern we want to check
 * 	@return matching patern if there is one, empty string otherwise
*/
std::string PFileParser::isMatch(const std::vector<std::string> & patern){
	if(patern.size() == 0lu) return "";
	std::vector<std::string>::const_iterator it(patern.begin());
	while(it != patern.end()){
		if(isMatch(*it)) return *it;
		++it;
	}
	return "";
}

///Check the matching between the current caracters and all the string in the list
/**	@param patern : list of the patern we want to check
 * 	@return matching patern if there is one, empty string otherwise
*/
std::string PFileParser::isMatch(const std::list<std::string> & patern){
	if(patern.size() == 0lu) return "";
	std::list<std::string>::const_iterator it(patern.begin());
	while(it != patern.end()){
		if(isMatch(*it)) return *it;
		++it;
	}
	return "";
}

///Check the matching between the current caracters and all the string in the vector but treats the string as a token (cannot be part of a word)
/**	@param patern : vector of the patern we want to check
 * 	@return matching patern if there is one, empty string otherwise
*/
std::string PFileParser::isMatchToken(const std::vector<std::string> & patern){
	if(patern.size() == 0lu) return "";
	std::vector<std::string>::const_iterator it(patern.begin());
	while(it != patern.end()){
		if(isMatchToken(*it)) return *it;
		++it;
	}
	return "";
}

///Check the matching between the current caracters and all the string in the list but treats the string as a token (cannot be part of a word)
/**	@param patern : list of the patern we want to check
 * 	@return matching patern if there is one, empty string otherwise
*/
std::string PFileParser::isMatchToken(const std::list<std::string> & patern){
	if(patern.size() == 0lu) return "";
	std::list<std::string>::const_iterator it(patern.begin());
	while(it != patern.end()){
		if(isMatchToken(*it)) return *it;
		++it;
	}
	return "";
}
///Check the matching between the current caracters and all the string in the list of list of string
/**	@param patern : list of the list of the patern we want to check
 * 	@return matching patern if there is one, empty string otherwise
*/
std::string PFileParser::isMatch(const std::vector<std::vector<std::string> > & patern){
	if(patern.size() == 0lu) return "";
	std::vector<std::vector<std::string> >::const_iterator itList(patern.begin());
	while(itList != patern.end()){
		std::vector<std::string>::const_iterator it(itList->begin());
		while(it != itList->end()){
			if(isMatch(*it)) return *it;
			++it;
		}
		++itList;
	}
	return "";
}

///Check the matching of a sequence in the current file
/**	@param seq : sequence to be checked
 * 	@return matched string
*/
std::string PFileParser::isMatch(const PParseSeq & seq){
	pushPosition();
	std::string 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){
			std::string str(itCmd->getStr());
			if(itCmd->getIsMatch()){
				isMatchedCmd = isMatch(str);
				body += str;
			}else{
				std::string res(getStrComposedOf(str));
				if(res != ""){
					body += res;
					isMatchedCmd = true;
				}
			}
			++itCmd;
		}
		isParseNextStep |= isMatchedCmd;
		++itStep;
	}
	if(!isParseNextStep){
		popPosition();
		body = "";
	}
	return body;
}

///Says if the current char is a white space
/**	@return true if the current char is a white space, false if not
 * 	If it matchs, the current caracter will be put on a non white space caracter
*/
bool PFileParser::isWhiteSpace(){
	if(isEndOfFile()) return false;
	if(findInString(p_listWhiteSpace, p_fileContent[p_currentChar])){
		do{
			incrementCurrentChar();
		}while(findInString(p_listWhiteSpace, p_fileContent[p_currentChar]) && !isEndOfFile());
		return true;
	}else return false;
}

///Skip the white space if there is at the current caracter position
void PFileParser::skipWhiteSpace(){
	if(p_dontSkipSpace){return;}
	if(findInString(p_listWhiteSpace, p_fileContent[p_currentChar])){
		do{
			incrementCurrentChar();
		}while(findInString(p_listWhiteSpace, p_fileContent[p_currentChar]) && !isEndOfFile());
	}
}

///Skip the characters in the given string
/**	@param chToSkip : set of characters tb skip
*/
void PFileParser::skipChars(const std::string & chToSkip){
	if(findInString(chToSkip, p_fileContent[p_currentChar])){
		do{
			incrementCurrentChar();
		}while(findInString(chToSkip, p_fileContent[p_currentChar]) && !isEndOfFile());
	}
}

///renvoie la liste des caractères blancs
/**	@return liste des caractères blancs
*/
std::string PFileParser::getWhiteSpace() const{
	return p_listWhiteSpace;
}

///renvoie la liste des caractères séparateurs
/**	@return liste des caractères séparateurs
*/
std::string PFileParser::getSeparator() const{
	return p_listSeparator;
}

///Renvoie le caractère courant
/**	@return caractère courant
*/
char PFileParser::getCurrentCh() const{
	if(isEndOfFile()) return '\0';
	return p_fileContent[p_currentChar];
}

///Renvoie le caractère courant
/**	@return caractère courant
*/
char PFileParser::getPrevCh() const{
	if(isEndOfFile() && p_currentChar > 0lu) return '\0';
	return p_fileContent[p_currentChar - 1lu];
}

///Fonction qui renvoie le numéro de la ligne courante
/**	@return numéro de la ligne courante
*/
size_t PFileParser::getLine() const{
	return p_currentLine;
}

///Fonction qui renvoie le numéro de la colonne du caractère courant
/**	@return colonne du caractère courant
*/
size_t PFileParser::getColumn() const{
	if(p_currentChar > p_currentLineFirstColumn){
		return p_currentChar - p_currentLineFirstColumn;
	}else{return 0lu;}
}

///Return the number of characters in the current opened file
/**	@return number of characters in the current opened file
*/
size_t PFileParser::getNbTotalChar() const{
	return p_nbTotalChar;
}

///Return the index of the current character
/**	@return index of the current character
*/
size_t PFileParser::getCurrentCharIdx() const{
	return p_currentChar;
}

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

	return indentation;
}

///Fonction qui renvoie la PLocation du PFileParser
/**	@return  PLocation du PFileParser
*/
PLocation PFileParser::getLocation() const{
	return PLocation(p_fileName, p_currentLine, getColumn());
}

///Définition de l'opérateur de flux sortant
/**	@param out : flux dans lequel il faut écrire
 * 	@param other : PFileParser
 * 	@return flux contenant le PFileParser
*/
std::ostream & operator << (std::ostream & out, const PFileParser & other){
	out << "file '" << other.getFileName() << "' line " << other.getLine() << ":" << other.getColumn();
	return out;
}

///Fonction d'initialisation du PFileParser
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;
}

///Increment the current line
void PFileParser::incrementCurrentLine(){
	++p_currentLine;
	p_currentLineFirstColumn = p_currentChar + 1lu;
}

///Increment the current caracter
/**	@param nbChar : number of char to go ahead
*/
void PFileParser::incrementCurrentChar(size_t nbChar){
	bool currentCharEchaped(false);
	for(size_t i(0lu); i < nbChar || currentCharEchaped; ++i){
		if(p_fileContent[p_currentChar] == '\n'){
			incrementCurrentLine();
		}
		if(!currentCharEchaped && p_fileContent[p_currentChar] == p_echapChar && p_echapChar != '\0'){
			currentCharEchaped = true;
		}else{
			currentCharEchaped = false;
		}
		if(p_currentChar < p_nbTotalChar){
			++p_currentChar;
		}
	}
}



Generated by: GCOVR (Version 4.2)