Subversion Repositories spk

Rev

Rev 1 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1 cycrow 1 
#include "bod_text_parser.h"
2 
#include "../common/strutils.h"
3 
 
4 
#include <memory.h>
5 
//---------------------------------------------------------------------------------
6 
// TOKEN
7 
const char* bod_text_parser::token::specialChars[]={ "{", "}", ";", ":", "/!", "!/" };
8 
char bod_text_parser::token::tabWidth;
9 
 
10 
const char* bod_text_parser::token::getText() const
11 
{
12 
	if(type >= t_text)
13 
		return text;
14 
	else
15 
		return specialChars[(int)type];
16 
}
17 
//---------------------------------------------------------------------------------
18 
void bod_text_parser::preParseBuffer(char *pszBuffer, size_t size)
19 
{
20 
	//m_lineCount=parseLines(pszBuffer, size, &m_lines);
21 
	m_pszBuffer=pszBuffer;
22 
	m_buffLen=size;
23 
}
24 
//---------------------------------------------------------------------------------
25 
size_t bod_text_parser::parseBuffer(size_t limit)
26 
{
27 
	size_t old=tokens.size();
28 
	/*for(size_t i=m_newLineIdx; i < m_lineCount; i++){
29 
		parseLine(m_lines[i], (int)i + 1);
30 
		if(limit!=-1 && ((tokens.size() - old) >= limit)){
31 
			i++;
32 
			break;
33 
		}
34 
	}
35 
	m_newLineIdx=i;*/
36 
 
37 
	char *ln;
38 
	while(ln=nextLine()){
39 
		parseLine(ln, ++m_lineIdx);
40 
		if(limit!=-1 && ((tokens.size() - old) >= limit)){
41 
			break;
42 
		}
43 
	}
44 
	return tokens.size() - old;
45 
}
46 
//---------------------------------------------------------------------------------
47 
void bod_text_parser::parseLine(char *line, int idx)
48 
{
49 
	char *old=line, *pos=line, ch;
50 
	token *t;
51 
 
52 
	while(*pos!=0){
53 
		ch=*pos;
54 
		if(ch==';' || ch==':') {
55 
			*pos=0;
56 
 
57 
			if(*old!=0){
58 
				t=new token();
59 
				t->type=token::t_text;
60 
				t->line=idx;
61 
				t->text=old;
62 
				t->col=(int)(old - line + 1);
63 
				tokens.push_back(t);
64 
			}
65 
			t=new token();
66 
			t->type=(ch==';' ? token::t_semicolon : token::t_colon);
67 
			t->line=idx;
68 
			t->col=(int)(pos - line + 1);
69 
			tokens.push_back(t);
70 
 
71 
			old=pos + 1;
72 
		}
73 
		// space or tabulator
74 
		else if(ch==' ' || ch==0x9){
75 
			*pos=0;
76 
			if(*old!=0){
77 
				t=new token();
78 
				t->type=token::t_text;
79 
				t->line=idx;
80 
				t->text=old;
81 
				t->col=(int)(old - line + 1);
82 
				tokens.push_back(t);
83 
			}
84 
			old=pos + 1;
85 
		}
86 
		else if(ch=='{' || ch=='}') {
87 
			*pos=0;
88 
			if(*old!=0){
89 
				t=new token();
90 
				t->text=old;
91 
				t->line=idx;
92 
				t->col=(int)(old - line) + 1;
93 
				t->type=token::t_text;
94 
				tokens.push_back(t);
95 
			}
96 
			t=new token();
97 
			t->type=(ch=='{' ? token::t_openBracket : token::t_closeBracket);
98 
			t->line=idx;
99 
			t->col=(int)(old - line + 1);
100 
			old=pos + 1;
101 
 
102 
			tokens.push_back(t);
103 
		}
104 
		// either comment, header info or processing instruction
105 
		else if(ch=='/') {
106 
			if(pos[1]=='#'){
107 
				t=new token();
108 
				t->text=pos + 2;
109 
				while(*t->text!=0 && *t->text==' ')
110 
					t->text++;
111 
				if(*t->text==0)
112 
					delete t;
113 
				else{
114 
					t->line=idx;
115 
					t->col=(int)(pos - line) + 1;
116 
					t->type=token::t_hdrinfo;
117 
					tokens.push_back(t);
118 
				}
119 
			}
120 
			// open proc instruction /!
121 
			if(pos[1]=='!') {
122 
 
123 
				t=new token();
124 
				t->type=token::t_openInstrBlock;
125 
				t->line=idx;
126 
				t->col=(int)(pos - line) + 1;
127 
				tokens.push_back(t);
128 
				old=pos + 2;
129 
				pos++;
130 
			}
131 
			// comment
132 
			else if(ignoreRemarks()==false){
133 
				*pos=0;
134 
				break;
135 
			}
136 
		}
137 
		// close proc instruction !/
138 
		else if(ch=='!' && pos[1]=='/'){
139 
			*pos=0;
140 
			if(*old!=0){
141 
				t=new token();
142 
				t->text=old;
143 
				t->line=idx;
144 
				t->col=(int)(old - line) + 1;
145 
				t->type=token::t_text;
146 
				tokens.push_back(t);
147 
			}
148 
			t=new token();
149 
			t->type=token::t_closeInstrBlock;
150 
			t->line=idx;
151 
			t->col=(int)(pos - line) + 1;
152 
			tokens.push_back(t);
153 
			old=pos + 2;
154 
			pos++;
155 
		}
156 
		pos++;
157 
	}
158 
	// if there are some chars left after last delimeter (usually ;) this will process them
159 
	if(old!=pos){
160 
		t=new token();
161 
		t->text=old;
162 
		t->line=idx;
163 
		t->col=(int)(old - line) + 1;
164 
		t->type=token::t_text;
165 
		tokens.push_back(t);
166 
	}
167 
}
168 
//---------------------------------------------------------------------------------
169 
/*size_t bod_text_parser::parseLines(char *buffer, size_t size, char ***array_ptr)
170 
{
171 
	size_t lineCount=1;
172 
	size_t i;
173 
	for(i=0; i < size; i++){
174 
		if(buffer[i]==0xD){
175 
			buffer[i]=0;
176 
			lineCount++;
177 
			if(((i + 1) < size) && buffer[i+1]==0xA)
178 
				buffer[i+1]=1;
179 
		}
180 
		else if(buffer[i]==0xA){
181 
			buffer[i]=0;
182 
			lineCount++;
183 
		}
184 
	}
185 
 
186 
	char **lines=new char*[lineCount];
187 
 
188 
	char *ptr=buffer, *end=buffer + size;
189 
 
190 
	i=0;
191 
	do{
192 
		if(ptr && *ptr==1)
193 
			ptr++;
194 
 
195 
		lines[i]=ptr;
196 
		ptr=(char*)memchr(ptr, 0, end - ptr);
197 
		if(ptr) ptr++;
198 
		// this will protect us from binary files where are more zeroes than we expect
199 
		if(++i==lineCount)
200 
			break;
201 
	}
202 
	while(ptr);
203 
 
204 
	*array_ptr=lines;
205 
	return lineCount;
206 
}*/
207 
//---------------------------------------------------------------------------------
208 
char * bod_text_parser::nextLine()
209 
{
210 
/*
211 
	size_t i, size=m_buffLen;
212 
	char *line=0, *buffer=(char*)m_pszBuffer;
213 
 
214 
	for(i=m_lastCharPos; i < size; i++){
215 
		if(buffer[i]==0xD){
216 
			buffer[i]=0;
217 
			if(((i + 1) < size) && buffer[i+1]==0xA)
218 
				buffer[i+1]=1;
219 
 
220 
			line=buffer + m_lastCharPos;
221 
			break;
222 
		}
223 
		else if(buffer[i]==0xA){
224 
			buffer[i]=0;
225 
			line=buffer + m_lastCharPos;
226 
			break;
227 
		}
228 
	}
229 
	if(line==0) line=buffer + m_lastCharPos;
230 
	if(*line==0) line++;
231 
 
232 
	if(m_lastCharPos==size) return NULL;
233 
 
234 
	m_lastCharPos=i;
235 
 
236 
	if(line[0]==1)
237 
		line++;
238 
	return line;
239 
	*/
240 
 
241 
	size_t i, size=m_buffLen;
242 
	char *line=0, *buffer=(char*)m_pszBuffer;
243 
 
244 
	for(i=m_lastPos; i < size; i++){
245 
		if(buffer[i]==0xD){
246 
			buffer[i]=0;
247 
			m_newPos=i;
248 
			if(((i + 1) < size) && buffer[i+1]==0xA) {
249 
				m_newPos++;
250 
			}
251 
			m_newPos++;
252 
			line=buffer + m_lastPos;
253 
 
254 
			break;
255 
		}
256 
		else if(buffer[i]==0xA){
257 
			buffer[i]=0;
258 
			m_newPos=i + 1;
259 
 
260 
			line=buffer + m_lastPos;
261 
			break;
262 
		}
263 
	}
264 
	if(m_lastPos > size) return NULL;
265 
 
266 
	if(line==0) {
267 
		line=buffer + m_lastPos;
268 
		m_newPos=size + 1;
269 
	}
270 
 
271 
	m_lastPos=m_newPos;
272 
 
273 
	return line;
274 
}
275 
//---------------------------------------------------------------------------------