eu07/maszyna
16
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-07-22 19:49:19 +02:00
Code Issues 123 Wiki Activity

Some parser optimisations

Browse Source
This commit is contained in:
Hirek
2026-01-04 23:25:30 +01:00
parent 3c2f4f5123
commit caff196b06
2 changed files with 417 additions and 314 deletions
Download Patch File Download Diff File Expand all files Collapse all files

373
parser.cpp
View File

@@ -24,80 +24,87 @@ http://mozilla.org/MPL/2.0/.
// cParser -- generic class for parsing text data. // cParser -- generic class for parsing text data.
// constructors // constructors
cParser::cParser( std::string const &Stream, buffertype const Type, std::string Path, bool const Loadtraction, std::vector<std::string> Parameters, bool allowRandom ) : cParser::cParser(std::string const &Stream, buffertype const Type, std::string Path, bool const Loadtraction, std::vector<std::string> Parameters, bool allowRandom)
mPath(Path), : mPath(Path), LoadTraction(Loadtraction), allowRandomIncludes(allowRandom)
LoadTraction( Loadtraction ), {
allowRandomIncludes(allowRandom) {
// store to calculate sub-sequent includes from relative path // store to calculate sub-sequent includes from relative path
if( Type == buffertype::buffer_FILE ) { if (Type == buffertype::buffer_FILE)
{
mFile = Stream; mFile = Stream;
} }
// reset pointers and attach proper type of buffer // reset pointers and attach proper type of buffer
switch (Type) { switch (Type)
case buffer_FILE: { {
case buffer_FILE:
{
Path.append(Stream); Path.append(Stream);
mStream = std::make_shared<std::ifstream>(Path, std::ios_base::binary); mStream = std::make_shared<std::ifstream>(Path, std::ios_base::binary);
// content of *.inc files is potentially grouped together // content of *.inc files is potentially grouped together
if( ( Stream.size() >= 4 ) if ((Stream.size() >= 4) && (ToLower(Stream.substr(Stream.size() - 4)) == ".inc"))
&& ( ToLower( Stream.substr( Stream.size() - 4 ) ) == ".inc" ) ) { {
mIncFile = true; mIncFile = true;
scene::Groups.create(); scene::Groups.create();
} }
break; break;
} }
case buffer_TEXT: { case buffer_TEXT:
{
mStream = std::make_shared<std::istringstream>(Stream); mStream = std::make_shared<std::istringstream>(Stream);
break; break;
} }
default: { default:
{
break; break;
} }
} }
// calculate stream size // calculate stream size
if (mStream) if (mStream)
{ {
if( true == mStream->fail() ) { if (true == mStream->fail())
{
ErrorLog("Failed to open file \"" + Path + "\""); ErrorLog("Failed to open file \"" + Path + "\"");
} }
else { else
{
mSize = mStream->rdbuf()->pubseekoff(0, std::ios_base::end); mSize = mStream->rdbuf()->pubseekoff(0, std::ios_base::end);
mStream->rdbuf()->pubseekoff(0, std::ios_base::beg); mStream->rdbuf()->pubseekoff(0, std::ios_base::beg);
mLine = 1; mLine = 1;
} }
} }
// set parameter set if one was provided // set parameter set if one was provided
if( false == Parameters.empty() ) { if (false == Parameters.empty())
{
parameters.swap(Parameters); parameters.swap(Parameters);
} }
} }
// destructor // destructor
cParser::~cParser() { cParser::~cParser()
{
if( true == mIncFile ) { if (true == mIncFile)
{
// wrap up the node group holding content of processed file // wrap up the node group holding content of processed file
scene::Groups.close(); scene::Groups.close();
} }
} }
template <> template <> glm::vec3 cParser::getToken(bool const ToLower, char const *Break)
glm::vec3 {
cParser::getToken( bool const ToLower, char const *Break ) {
// NOTE: this specialization ignores default arguments // NOTE: this specialization ignores default arguments
getTokens(3, false, "\n\r\t ,;[]"); getTokens(3, false, "\n\r\t ,;[]");
glm::vec3 output; glm::vec3 output;
*this *this >> output.x >> output.y >> output.z;
>> output.x
>> output.y
>> output.z;
return output; return output;
}; };
template<> template <> cParser &cParser::operator>>(std::string &Right)
cParser& {
cParser::operator>>( std::string &Right ) {
if( true == this->tokens.empty() ) { return *this; } if (true == this->tokens.empty())
{
return *this;
}
Right = this->tokens.front(); Right = this->tokens.front();
this->tokens.pop_front(); this->tokens.pop_front();
@@ -105,43 +112,44 @@ cParser::operator>>( std::string &Right ) {
return *this; return *this;
} }
template<> template <> cParser &cParser::operator>>(bool &Right)
cParser& {
cParser::operator>>( bool &Right ) {
if( true == this->tokens.empty() ) { return *this; } if (true == this->tokens.empty())
{
return *this;
}
Right = ( ( this->tokens.front() == "true" ) Right = ((this->tokens.front() == "true") || (this->tokens.front() == "yes") || (this->tokens.front() == "1"));
|| ( this->tokens.front() == "yes" )
|| ( this->tokens.front() == "1" ) );
this->tokens.pop_front(); this->tokens.pop_front();
return *this; return *this;
} }
template <> template <> bool cParser::getToken<bool>(bool const ToLower, const char *Break)
bool {
cParser::getToken<bool>( bool const ToLower, const char *Break ) {
auto const token = getToken<std::string>(true, Break); auto const token = getToken<std::string>(true, Break);
return ( ( token == "true" ) return ((token == "true") || (token == "yes") || (token == "1"));
|| ( token == "yes" )
|| ( token == "1" ) );
} }
// methods // methods
cParser & cParser &cParser::autoclear(bool const Autoclear)
cParser::autoclear( bool const Autoclear ) { {
m_autoclear = Autoclear; m_autoclear = Autoclear;
if( mIncludeParser ) { mIncludeParser->autoclear( Autoclear ); } if (mIncludeParser)
{
mIncludeParser->autoclear(Autoclear);
}
return *this; return *this;
} }
bool cParser::getTokens(unsigned int Count, bool ToLower, const char *Break) bool cParser::getTokens(unsigned int Count, bool ToLower, const char *Break)
{ {
if( true == m_autoclear ) { if (true == m_autoclear)
{
// legacy parser behaviour // legacy parser behaviour
tokens.clear(); tokens.clear();
} }
@@ -159,7 +167,8 @@ bool cParser::getTokens(unsigned int Count, bool ToLower, const char *Break)
for (unsigned int i = tokens.size(); i < Count; ++i) for (unsigned int i = tokens.size(); i < Count; ++i)
{ {
std::string token = readToken(ToLower, Break); std::string token = readToken(ToLower, Break);
if( true == token.empty() ) { if (true == token.empty())
{
// no more tokens // no more tokens
break; break;
} }
@@ -183,83 +192,136 @@ bool cParser::getTokens(unsigned int Count, bool ToLower, const char *Break)
return true; return true;
} }
std::string cParser::readToken( bool ToLower, const char *Break ) { std::string cParser::readToken(bool ToLower, const char *Break)
{
std::string token; std::string token;
if( mIncludeParser ) { token.reserve(128);
auto &breakTable = breakTables[Break];
if (breakTable[0] == false)
{ // inicjalizacja tylko raz
for (char c : std::string(Break))
breakTable[(unsigned char)c] = true;
}
if (mIncludeParser)
{
// see if there's include parsing going on. clean up when it's done. // see if there's include parsing going on. clean up when it's done.
token = mIncludeParser->readToken(ToLower, Break); token = mIncludeParser->readToken(ToLower, Break);
if( true == token.empty() ) { if (true == token.empty())
{
mIncludeParser = nullptr; mIncludeParser = nullptr;
} }
} }
if( true == token.empty() ) { if (true == token.empty())
{
// get the token yourself if the delegation attempt failed // get the token yourself if the delegation attempt failed
char c{0}; char c{0};
do { do
while( mStream->peek() != EOF && strchr( Break, c = mStream->get() ) == NULL ) { {
while (mStream->peek() != EOF)
{
c = mStream->peek();
if (breakTable[(unsigned char)c])
break;
mStream->get(); // dopiero TERAZ konsumujemy
if (ToLower) if (ToLower)
c = tolower( c ); c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
token += c; token += c;
if( findQuotes( token ) ) // do glue together words enclosed in quotes
if (c == '"' && findQuotes(token))
continue; continue;
if( skipComments && trimComments( token ) ) // don't glue together words separated with comment
if (skipComments && trimComments(token))
break; break;
} }
if( c == '\n' ) {
// update line counter c = mStream->get();
if (c == '\n')
{
++mLine; ++mLine;
// PRZERWIJ, ale NIE ZJADAJ \n jako separatora tokenów
break;
} }
} while (token == "" && mStream->peek() != EOF); // double check in case of consecutive separators } while (token == "" && mStream->peek() != EOF); // double check in case of consecutive separators
} }
// check the first token for potential presence of utf bom // check the first token for potential presence of utf bom
if( mFirstToken ) { if (mFirstToken)
{
mFirstToken = false; mFirstToken = false;
if( token.rfind( "\xef\xbb\xbf", 0 ) == 0 ) { if (token.rfind("\xef\xbb\xbf", 0) == 0)
{
token.erase(0, 3); token.erase(0, 3);
} }
if( true == token.empty() ) { if (true == token.empty())
{
// potentially possible if our first token was standalone utf bom // potentially possible if our first token was standalone utf bom
token = readToken(ToLower, Break); token = readToken(ToLower, Break);
} }
} }
if( false == parameters.empty() ) { if (!parameters.empty())
// if there's parameter list, check the token for potential parameters to replace {
size_t pos; // początek podmienianego ciągu size_t pos = 0;
while( ( pos = token.find( "(p" ) ) != std::string::npos ) { while ((pos = token.find("(p", pos)) != std::string::npos)
// check if the token is a parameter which should be replaced with stored true value {
auto const parameter{ token.substr( pos + 2, token.find( ")", pos ) - ( pos + 2 ) ) }; // numer parametru size_t end = token.find(')', pos + 2);
token.erase( pos, token.find( ")", pos ) - pos + 1 ); // najpierw usunięcie "(pN)" if (end == std::string::npos)
size_t nr = atoi( parameter.c_str() ) - 1; break; // uszkodzony zapis, przerywamy
if( nr < parameters.size() ) {
token.insert( pos, parameters.at( nr ) ); // wklejenie wartości parametru // parsowanie numeru parametru
if( ToLower ) int idx = 0;
for( ; pos < parameters.at( nr ).size(); ++pos ) bool ok = true;
token[ pos ] = tolower( token[ pos ] ); for (size_t i = pos + 2; i < end; ++i)
{
if (token[i] < '0' || token[i] > '9')
{
ok = false;
break;
} }
idx = idx * 10 + (token[i] - '0');
}
std::string replacement;
if (ok && idx > 0 && static_cast<size_t>(idx - 1) < parameters.size())
replacement = parameters[idx - 1];
else else
token.insert( pos, "none" ); // zabezpieczenie przed brakiem parametru replacement = "none";
if (ToLower)
{
for (char &c : replacement)
c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
}
token.replace(pos, end - pos + 1, replacement);
pos += replacement.size(); // przesuwamy się dalej
} }
} }
// launch child parser if include directive found. // launch child parser if include directive found.
// NOTE: parameter collecting uses default set of token separators. // NOTE: parameter collecting uses default set of token separators.
if( expandIncludes && token == "include" ) { if (expandIncludes && token == "include")
{
std::string includefile = allowRandomIncludes ? deserialize_random_set(*this) : readToken(ToLower); // nazwa pliku std::string includefile = allowRandomIncludes ? deserialize_random_set(*this) : readToken(ToLower); // nazwa pliku
replace_slashes(includefile); replace_slashes(includefile);
if ((true == LoadTraction) || if ((true == LoadTraction) || ((false == contains(includefile, "tr/")) && (false == contains(includefile, "tra/"))))
((false == contains(includefile, "tr/")) && (false == contains(includefile, "tra/"))))
{ {
if (false == contains(includefile, "_ter.scm")) if (false == contains(includefile, "_ter.scm"))
{ {
if (Global.ParserLogIncludes) { if (Global.ParserLogIncludes)
{
// WriteLog("including: " + includefile); // WriteLog("including: " + includefile);
} }
mIncludeParser = std::make_shared<cParser>(includefile, buffer_FILE, mPath, LoadTraction, readParameters(*this)); mIncludeParser = std::make_unique<cParser>(includefile, buffer_FILE, mPath, LoadTraction, readParameters(*this));
mIncludeParser->allowRandomIncludes = allowRandomIncludes; mIncludeParser->allowRandomIncludes = allowRandomIncludes;
mIncludeParser->autoclear(m_autoclear); mIncludeParser->autoclear(m_autoclear);
if (mIncludeParser->mSize <= 0) { if (mIncludeParser->mSize <= 0)
{
ErrorLog("Bad include: can't open file \"" + includefile + "\""); ErrorLog("Bad include: can't open file \"" + includefile + "\"");
} }
} }
@@ -272,11 +334,11 @@ std::string cParser::readToken( bool ToLower, const char *Break ) {
} }
else else
{ {
if (Global.ParserLogIncludes) { if (Global.ParserLogIncludes)
{
WriteLog("including terrain: " + includefile); WriteLog("including terrain: " + includefile);
} }
mIncludeParser = std::make_shared<cParser>(includefile, buffer_FILE, mPath, mIncludeParser = std::make_unique<cParser>(includefile, buffer_FILE, mPath, LoadTraction, readParameters(*this));
LoadTraction, readParameters(*this));
mIncludeParser->allowRandomIncludes = allowRandomIncludes; mIncludeParser->allowRandomIncludes = allowRandomIncludes;
mIncludeParser->autoclear(m_autoclear); mIncludeParser->autoclear(m_autoclear);
if (mIncludeParser->mSize <= 0) if (mIncludeParser->mSize <= 0)
@@ -286,28 +348,30 @@ std::string cParser::readToken( bool ToLower, const char *Break ) {
} }
} }
} }
else { else
while( token != "end" ) { {
while (token != "end")
{
token = readToken(true); // minimize risk of case mismatch on comparison token = readToken(true); // minimize risk of case mismatch on comparison
} }
} }
token = readToken(ToLower, Break); token = readToken(ToLower, Break);
} }
else if( ( std::strcmp( Break, "\n\r" ) == 0 ) && ( token.compare( 0, 7, "include" ) == 0 ) ) { else if ((std::strcmp(Break, "\n\r") == 0) && (token.compare(0, 7, "include") == 0))
{
// HACK: if the parser reads full lines we expect this line to contain entire include directive, to make parsing easier // HACK: if the parser reads full lines we expect this line to contain entire include directive, to make parsing easier
cParser includeparser(token.substr(7)); cParser includeparser(token.substr(7));
std::string includefile = allowRandomIncludes ? deserialize_random_set(includeparser) : includeparser.readToken(ToLower); // nazwa pliku std::string includefile = allowRandomIncludes ? deserialize_random_set(includeparser) : includeparser.readToken(ToLower); // nazwa pliku
replace_slashes(includefile); replace_slashes(includefile);
if ((true == LoadTraction) || if ((true == LoadTraction) || ((false == contains(includefile, "tr/")) && (false == contains(includefile, "tra/"))))
((false == contains(includefile, "tr/")) && (false == contains(includefile, "tra/"))))
{ {
if (false == contains(includefile, "_ter.scm")) if (false == contains(includefile, "_ter.scm"))
{ {
if (Global.ParserLogIncludes) { if (Global.ParserLogIncludes)
{
// WriteLog("including: " + includefile); // WriteLog("including: " + includefile);
} }
mIncludeParser = std::make_shared<cParser>( mIncludeParser = std::make_unique<cParser>(includefile, buffer_FILE, mPath, LoadTraction, readParameters(includeparser));
includefile, buffer_FILE, mPath, LoadTraction, readParameters(includeparser));
mIncludeParser->allowRandomIncludes = allowRandomIncludes; mIncludeParser->allowRandomIncludes = allowRandomIncludes;
mIncludeParser->autoclear(m_autoclear); mIncludeParser->autoclear(m_autoclear);
if (mIncludeParser->mSize <= 0) if (mIncludeParser->mSize <= 0)
@@ -324,19 +388,17 @@ std::string cParser::readToken( bool ToLower, const char *Break ) {
} }
else else
{ {
if (Global.ParserLogIncludes) { if (Global.ParserLogIncludes)
{
WriteLog("including terrain: " + includefile); WriteLog("including terrain: " + includefile);
} }
mIncludeParser = mIncludeParser = std::make_unique<cParser>(includefile, buffer_FILE, mPath, LoadTraction, readParameters(includeparser));
std::make_shared<cParser>(includefile, buffer_FILE, mPath, LoadTraction,
readParameters(includeparser));
mIncludeParser->allowRandomIncludes = allowRandomIncludes; mIncludeParser->allowRandomIncludes = allowRandomIncludes;
mIncludeParser->autoclear(m_autoclear); mIncludeParser->autoclear(m_autoclear);
if (mIncludeParser->mSize <= 0) if (mIncludeParser->mSize <= 0)
{ {
ErrorLog("Bad include: can't open file \"" + includefile + "\""); ErrorLog("Bad include: can't open file \"" + includefile + "\"");
} }
} }
} }
} }
@@ -346,30 +408,38 @@ std::string cParser::readToken( bool ToLower, const char *Break ) {
return token; return token;
} }
std::vector<std::string> cParser::readParameters( cParser &Input ) { std::vector<std::string> cParser::readParameters(cParser &Input)
{
std::vector<std::string> includeparameters; std::vector<std::string> includeparameters;
std::string parameter = Input.readToken(false); // w parametrach nie zmniejszamy std::string parameter = Input.readToken(false); // w parametrach nie zmniejszamy
while( ( parameter.empty() == false ) while ((parameter.empty() == false) && (parameter != "end"))
&& ( parameter != "end" ) ) { {
includeparameters.emplace_back(parameter); includeparameters.emplace_back(parameter);
parameter = Input.readToken(false); parameter = Input.readToken(false);
} }
return includeparameters; return includeparameters;
} }
std::string cParser::readQuotes(char const Quote) { // read the stream until specified char or stream end std::string cParser::readQuotes(char const Quote)
std::string token = ""; { // read the stream until specified char or stream end
std::string token;
token.reserve(128);
char c{0}; char c{0};
bool escaped = false; bool escaped = false;
while( mStream->peek() != EOF ) { // get all chars until the quote mark while (mStream->peek() != EOF)
{ // get all chars until the quote mark
c = mStream->get(); c = mStream->get();
++mReadBytes;
if (escaped) { if (escaped)
{
escaped = false; escaped = false;
} }
else { else
if (c == '\\') { {
if (c == '\\')
{
escaped = true; escaped = true;
continue; continue;
} }
@@ -385,31 +455,37 @@ std::string cParser::readQuotes(char const Quote) { // read the stream until spe
return token; return token;
} }
void cParser::skipComment( std::string const &Endmark ) { // pobieranie znaków aż do znalezienia znacznika końca void cParser::skipComment(std::string const &Endmark)
std::string input = ""; { // pobieranie znaków aż do znalezienia znacznika końca
std::string input;
input.reserve(Endmark.size());
char c{0}; char c{0};
auto const endmarksize = Endmark.size(); auto const endmarksize = Endmark.size();
while( mStream->peek() != EOF ) { while (mStream->peek() != EOF)
{
// o ile nie koniec pliku // o ile nie koniec pliku
c = mStream->get(); // pobranie znaku c = mStream->get(); // pobranie znaku
if( c == '\n' ) { ++mReadBytes;
if (c == '\n')
{
// update line counter // update line counter
++mLine; ++mLine;
} }
input += c; input += c;
if (input == Endmark) // szukanie znacznika końca if (input == Endmark) // szukanie znacznika końca
break; break;
if( input.size() >= endmarksize ) { if (input.size() > endmarksize)
// keep the read text short, to avoid pointless string re-allocations on longer comments input.erase(0, input.size() - endmarksize);
input = input.substr( 1 );
}
} }
return; return;
} }
bool cParser::findQuotes( std::string &String ) { bool cParser::findQuotes(std::string &String)
{
if( String.back() == '\"' ) { if (String.back() == '\"')
{
String.pop_back(); String.pop_back();
String += readQuotes(); String += readQuotes();
@@ -422,7 +498,10 @@ bool cParser::trimComments(std::string &String)
{ {
for (auto const &comment : mComments) for (auto const &comment : mComments)
{ {
if( String.size() < comment.first.size() ) { continue; } if (String.size() < comment.first.size())
{
continue;
}
if (String.compare(String.size() - comment.first.size(), comment.first.size(), comment.first) == 0) if (String.compare(String.size() - comment.first.size(), comment.first.size(), comment.first) == 0)
{ {
@@ -436,37 +515,45 @@ bool cParser::trimComments(std::string &String)
void cParser::injectString(const std::string &str) void cParser::injectString(const std::string &str)
{ {
if (mIncludeParser) { if (mIncludeParser)
{
mIncludeParser->injectString(str); mIncludeParser->injectString(str);
} }
else { else
mIncludeParser = std::make_shared<cParser>( str, buffer_TEXT, "", LoadTraction, std::vector<std::string>(), allowRandomIncludes ); {
mIncludeParser = std::make_unique<cParser>(str, buffer_TEXT, "", LoadTraction, std::vector<std::string>(), allowRandomIncludes);
mIncludeParser->autoclear(m_autoclear); mIncludeParser->autoclear(m_autoclear);
} }
} }
int cParser::getProgress() const int cParser::getProgress() const
{ {
return static_cast<int>( mStream->rdbuf()->pubseekoff(0, std::ios_base::cur) * 100 / mSize ); return mSize ? int(mReadBytes * 100 / mSize) : 0;
} }
int cParser::getFullProgress() const { int cParser::getFullProgress() const
{
int progress = getProgress(); int progress = getProgress();
if( mIncludeParser ) return progress + ( ( 100 - progress )*( mIncludeParser->getProgress() ) / 100 ); if (mIncludeParser)
else return progress; return progress + ((100 - progress) * (mIncludeParser->getProgress()) / 100);
else
return progress;
} }
std::size_t cParser::countTokens( std::string const &Stream, std::string Path ) { std::size_t cParser::countTokens(std::string const &Stream, std::string Path)
{
return cParser(Stream, buffer_FILE, Path).count(); return cParser(Stream, buffer_FILE, Path).count();
} }
std::size_t cParser::count() { std::size_t cParser::count()
{
std::string token; std::string token;
size_t count{0}; size_t count{0};
do { do
{
token = ""; token = "";
token = readToken(false); token = readToken(false);
++count; ++count;
@@ -475,27 +562,41 @@ std::size_t cParser::count() {
return count - 1; return count - 1;
} }
void cParser::addCommentStyle( std::string const &Commentstart, std::string const &Commentend ) { void cParser::addCommentStyle(std::string const &Commentstart, std::string const &Commentend)
{
mComments.insert( commentmap::value_type(Commentstart, Commentend) ); mComments.emplace_back(commentmap::value_type(Commentstart, Commentend));
} }
// returns name of currently open file, or empty string for text type stream // returns name of currently open file, or empty string for text type stream
std::string std::string cParser::Name() const
cParser::Name() const { {
if( mIncludeParser ) { return mIncludeParser->Name(); } if (mIncludeParser)
else { return mPath + mFile; } {
return mIncludeParser->Name();
}
else
{
return mPath + mFile;
}
} }
// returns number of currently processed line // returns number of currently processed line
std::size_t std::size_t cParser::Line() const
cParser::Line() const { {
if( mIncludeParser ) { return mIncludeParser->Line(); } if (mIncludeParser)
else { return mLine; } {
return mIncludeParser->Line();
}
else
{
return mLine;
}
} }
int cParser::LineMain() const { int cParser::LineMain() const
{
return mIncludeParser ? -1 : mLine; return mIncludeParser ? -1 : mLine;
} }

6
parser.h
View File

@@ -104,20 +104,22 @@ class cParser //: public std::stringstream
bool trimComments( std::string &String ); bool trimComments( std::string &String );
std::size_t count(); std::size_t count();
// members: // members:
std::unordered_map<const char*, std::array<bool,256>> breakTables;
bool m_autoclear { true }; // unretrieved tokens are discarded when another read command is issued (legacy behaviour) bool m_autoclear { true }; // unretrieved tokens are discarded when another read command is issued (legacy behaviour)
bool LoadTraction { true }; // load traction? bool LoadTraction { true }; // load traction?
std::shared_ptr<std::istream> mStream; // relevant kind of buffer is attached on creation. std::shared_ptr<std::istream> mStream; // relevant kind of buffer is attached on creation.
std::string mFile; // name of the open file, if any std::string mFile; // name of the open file, if any
std::string mPath; // path to open stream, for relative path lookups. std::string mPath; // path to open stream, for relative path lookups.
std::size_t mReadBytes = 0;
std::streamoff mSize { 0 }; // size of open stream, for progress report. std::streamoff mSize { 0 }; // size of open stream, for progress report.
std::size_t mLine { 0 }; // currently processed line std::size_t mLine { 0 }; // currently processed line
bool mIncFile { false }; // the parser is processing an *.inc file bool mIncFile { false }; // the parser is processing an *.inc file
bool mFirstToken { true }; // processing first token in the current file; helper used when checking for utf bom bool mFirstToken { true }; // processing first token in the current file; helper used when checking for utf bom
typedef std::map<std::string, std::string> commentmap; using commentmap = std::vector<std::pair<std::string,std::string>>;
commentmap mComments { commentmap mComments {
commentmap::value_type( "/*", "*/" ), commentmap::value_type( "/*", "*/" ),
commentmap::value_type( "//", "\n" ) }; commentmap::value_type( "//", "\n" ) };
std::shared_ptr<cParser> mIncludeParser; // child class to handle include directives. std::unique_ptr<cParser> mIncludeParser; // child class to handle include directives.
std::vector<std::string> parameters; // parameter list for included file. std::vector<std::string> parameters; // parameter list for included file.
std::deque<std::string> tokens; std::deque<std::string> tokens;
}; };