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
|
/* This file is part of the Spring engine (GPL v2 or later), see LICENSE.html */
#include "System/mmgr.h"
#include "SimpleParser.h"
#include "FileHandler.h"
#include <sstream>
CSimpleParser::CSimpleParser(CFileHandler& fh)
: file(fh)
, lineNumber(0)
, inComment(false) // /* text */ comments are not implemented
{
}
int CSimpleParser::GetLineNumber() const
{
return lineNumber;
}
std::string CSimpleParser::GetLine()
{
lineNumber++;
std::stringstream s;
while (!file.Eof()) {
char a = '\n'; // break if this is not overwritten
file.Read(&a, 1);
if (a == '\n') { break; }
if (a != '\r') { s << a; }
}
return s.str();
}
std::string CSimpleParser::GetCleanLine()
{
std::string::size_type pos;
while (true) {
if (file.Eof()) {
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;
}
|
