1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
/* This file is part of the Spring engine (GPL v2 or later), see LICENSE.html */
#include "SimpleParser.h"
#include "FileHandler.h"
#include <sstream>
CSimpleParser::CSimpleParser(CFileHandler& fh)
: curPos(0)
, lineNumber(0)
// , inComment(false) // /* text */ comments are not implemented
{
fh.LoadStringData(file);
}
CSimpleParser::CSimpleParser(const std::string& filecontent)
: file(filecontent)
, curPos(0)
, lineNumber(0)
// , inComment(false) // /* text */ comments are not implemented
{
}
int CSimpleParser::GetLineNumber() const
{
return lineNumber;
}
std::string CSimpleParser::GetLine()
{
lineNumber++;
std::stringstream s;
while (curPos < file.size()) {
char& a = file[curPos++];
if (a == '\n') { break; }
if (a != '\r') { s << a; }
}
return s.str();
}
std::string CSimpleParser::GetCleanLine()
{
std::string::size_type pos;
while (true) {
if (curPos >= file.size()) {
return ""; // end of file
}
std::string line = GetLine();
pos = line.find_first_not_of(" \t");
if (pos == std::string::npos) {
continue; // blank line
}
pos = line.find("//");
if (pos != std::string::npos) {
line.erase(pos);
pos = line.find_first_not_of(" \t");
if (pos == std::string::npos) {
continue; // blank line (after removing comments)
}
}
return line;
}
}
std::vector<std::string> CSimpleParser::Tokenize(const std::string& line, int minWords)
{
std::vector<std::string> words;
std::string::size_type start;
std::string::size_type end = 0;
while (true) {
start = line.find_first_not_of(" \t", end);
if (start == std::string::npos) {
break;
}
std::string word;
if ((minWords > 0) && ((int)words.size() >= minWords)) {
word = line.substr(start);
// strip trailing whitespace
std::string::size_type pos = word.find_last_not_of(" \t");
if (pos != (word.size() - 1)) {
word.resize(pos + 1);
}
end = std::string::npos;
}
else {
end = line.find_first_of(" \t", start);
if (end == std::string::npos) {
word = line.substr(start);
} else {
word = line.substr(start, end - start);
}
}
words.push_back(word);
if (end == std::string::npos) {
break;
}
}
return words;
}
std::vector<std::string> CSimpleParser::Split(const std::string& str, const std::string& delimitters) {
std::vector<std::string> tokens;
// Skip delimiters at beginning.
std::string::size_type lastPos = str.find_first_not_of(delimitters, 0);
// Find first "non-delimiter".
std::string::size_type pos = str.find_first_of(delimitters, lastPos);
while (std::string::npos != pos || std::string::npos != lastPos) {
// Found a token, add it to the vector.
tokens.push_back(str.substr(lastPos, pos - lastPos));
// Skip delimiters. Note the "not_of"
lastPos = str.find_first_not_of(delimitters, pos);
// Find next "non-delimiter"
pos = str.find_first_of(delimitters, lastPos);
}
return tokens;
}
|
