1 |
/* $ANTLR 2.7.5 (20050406): "MDParser.g" -> "MDLexer.cpp"$ */ |
2 |
#include "MDLexer.hpp" |
3 |
#include <antlr/CharBuffer.hpp> |
4 |
#include <antlr/TokenStreamException.hpp> |
5 |
#include <antlr/TokenStreamIOException.hpp> |
6 |
#include <antlr/TokenStreamRecognitionException.hpp> |
7 |
#include <antlr/CharStreamException.hpp> |
8 |
#include <antlr/CharStreamIOException.hpp> |
9 |
#include <antlr/NoViableAltForCharException.hpp> |
10 |
|
11 |
#line 1 "MDParser.g" |
12 |
#line 13 "MDLexer.cpp" |
13 |
MDLexer::MDLexer(ANTLR_USE_NAMESPACE(std)istream& in) |
14 |
: ANTLR_USE_NAMESPACE(antlr)CharScanner(new ANTLR_USE_NAMESPACE(antlr)CharBuffer(in),true) |
15 |
{ |
16 |
initLiterals(); |
17 |
} |
18 |
|
19 |
MDLexer::MDLexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib) |
20 |
: ANTLR_USE_NAMESPACE(antlr)CharScanner(ib,true) |
21 |
{ |
22 |
initLiterals(); |
23 |
} |
24 |
|
25 |
MDLexer::MDLexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state) |
26 |
: ANTLR_USE_NAMESPACE(antlr)CharScanner(state,true) |
27 |
{ |
28 |
initLiterals(); |
29 |
} |
30 |
|
31 |
void MDLexer::initLiterals() |
32 |
{ |
33 |
literals["members"] = 14; |
34 |
literals["position"] = 15; |
35 |
literals["torsion"] = 10; |
36 |
literals["component"] = 4; |
37 |
literals["rigidBody"] = 11; |
38 |
literals["zconstraint"] = 6; |
39 |
literals["cutoffGroup"] = 12; |
40 |
literals["bend"] = 9; |
41 |
literals["orientation"] = 16; |
42 |
literals["fragment"] = 13; |
43 |
literals["bond"] = 8; |
44 |
literals["molecule"] = 5; |
45 |
literals["atom"] = 7; |
46 |
} |
47 |
|
48 |
ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken() |
49 |
{ |
50 |
ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken; |
51 |
for (;;) { |
52 |
ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken; |
53 |
int _ttype = ANTLR_USE_NAMESPACE(antlr)Token::INVALID_TYPE; |
54 |
resetText(); |
55 |
try { // for lexical and char stream error handling |
56 |
switch ( LA(1)) { |
57 |
case 0x3d /* '=' */ : |
58 |
{ |
59 |
mASSIGNEQUAL(true); |
60 |
theRetToken=_returnToken; |
61 |
break; |
62 |
} |
63 |
case 0x3a /* ':' */ : |
64 |
{ |
65 |
mCOLON(true); |
66 |
theRetToken=_returnToken; |
67 |
break; |
68 |
} |
69 |
case 0x2c /* ',' */ : |
70 |
{ |
71 |
mCOMMA(true); |
72 |
theRetToken=_returnToken; |
73 |
break; |
74 |
} |
75 |
case 0x3f /* '?' */ : |
76 |
{ |
77 |
mQUESTIONMARK(true); |
78 |
theRetToken=_returnToken; |
79 |
break; |
80 |
} |
81 |
case 0x3b /* ';' */ : |
82 |
{ |
83 |
mSEMICOLON(true); |
84 |
theRetToken=_returnToken; |
85 |
break; |
86 |
} |
87 |
case 0x28 /* '(' */ : |
88 |
{ |
89 |
mLPAREN(true); |
90 |
theRetToken=_returnToken; |
91 |
break; |
92 |
} |
93 |
case 0x29 /* ')' */ : |
94 |
{ |
95 |
mRPAREN(true); |
96 |
theRetToken=_returnToken; |
97 |
break; |
98 |
} |
99 |
case 0x5b /* '[' */ : |
100 |
{ |
101 |
mLBRACKET(true); |
102 |
theRetToken=_returnToken; |
103 |
break; |
104 |
} |
105 |
case 0x5d /* ']' */ : |
106 |
{ |
107 |
mRBRACKET(true); |
108 |
theRetToken=_returnToken; |
109 |
break; |
110 |
} |
111 |
case 0x7b /* '{' */ : |
112 |
{ |
113 |
mLCURLY(true); |
114 |
theRetToken=_returnToken; |
115 |
break; |
116 |
} |
117 |
case 0x7d /* '}' */ : |
118 |
{ |
119 |
mRCURLY(true); |
120 |
theRetToken=_returnToken; |
121 |
break; |
122 |
} |
123 |
case 0x9 /* '\t' */ : |
124 |
case 0xa /* '\n' */ : |
125 |
case 0xc /* '\14' */ : |
126 |
case 0xd /* '\r' */ : |
127 |
case 0x20 /* ' ' */ : |
128 |
case 0x5c /* '\\' */ : |
129 |
{ |
130 |
mWhitespace(true); |
131 |
theRetToken=_returnToken; |
132 |
break; |
133 |
} |
134 |
case 0x23 /* '#' */ : |
135 |
{ |
136 |
mPREPROC_DIRECTIVE(true); |
137 |
theRetToken=_returnToken; |
138 |
break; |
139 |
} |
140 |
case 0x22 /* '\"' */ : |
141 |
{ |
142 |
mStringLiteral(true); |
143 |
theRetToken=_returnToken; |
144 |
break; |
145 |
} |
146 |
case 0x27 /* '\'' */ : |
147 |
{ |
148 |
mCharLiteral(true); |
149 |
theRetToken=_returnToken; |
150 |
break; |
151 |
} |
152 |
case 0x41 /* 'A' */ : |
153 |
case 0x42 /* 'B' */ : |
154 |
case 0x43 /* 'C' */ : |
155 |
case 0x44 /* 'D' */ : |
156 |
case 0x45 /* 'E' */ : |
157 |
case 0x46 /* 'F' */ : |
158 |
case 0x47 /* 'G' */ : |
159 |
case 0x48 /* 'H' */ : |
160 |
case 0x49 /* 'I' */ : |
161 |
case 0x4a /* 'J' */ : |
162 |
case 0x4b /* 'K' */ : |
163 |
case 0x4c /* 'L' */ : |
164 |
case 0x4d /* 'M' */ : |
165 |
case 0x4e /* 'N' */ : |
166 |
case 0x4f /* 'O' */ : |
167 |
case 0x50 /* 'P' */ : |
168 |
case 0x51 /* 'Q' */ : |
169 |
case 0x52 /* 'R' */ : |
170 |
case 0x53 /* 'S' */ : |
171 |
case 0x54 /* 'T' */ : |
172 |
case 0x55 /* 'U' */ : |
173 |
case 0x56 /* 'V' */ : |
174 |
case 0x57 /* 'W' */ : |
175 |
case 0x58 /* 'X' */ : |
176 |
case 0x59 /* 'Y' */ : |
177 |
case 0x5a /* 'Z' */ : |
178 |
case 0x5f /* '_' */ : |
179 |
case 0x61 /* 'a' */ : |
180 |
case 0x62 /* 'b' */ : |
181 |
case 0x63 /* 'c' */ : |
182 |
case 0x64 /* 'd' */ : |
183 |
case 0x65 /* 'e' */ : |
184 |
case 0x66 /* 'f' */ : |
185 |
case 0x67 /* 'g' */ : |
186 |
case 0x68 /* 'h' */ : |
187 |
case 0x69 /* 'i' */ : |
188 |
case 0x6a /* 'j' */ : |
189 |
case 0x6b /* 'k' */ : |
190 |
case 0x6c /* 'l' */ : |
191 |
case 0x6d /* 'm' */ : |
192 |
case 0x6e /* 'n' */ : |
193 |
case 0x6f /* 'o' */ : |
194 |
case 0x70 /* 'p' */ : |
195 |
case 0x71 /* 'q' */ : |
196 |
case 0x72 /* 'r' */ : |
197 |
case 0x73 /* 's' */ : |
198 |
case 0x74 /* 't' */ : |
199 |
case 0x75 /* 'u' */ : |
200 |
case 0x76 /* 'v' */ : |
201 |
case 0x77 /* 'w' */ : |
202 |
case 0x78 /* 'x' */ : |
203 |
case 0x79 /* 'y' */ : |
204 |
case 0x7a /* 'z' */ : |
205 |
{ |
206 |
mID(true); |
207 |
theRetToken=_returnToken; |
208 |
break; |
209 |
} |
210 |
case 0x2b /* '+' */ : |
211 |
case 0x2d /* '-' */ : |
212 |
case 0x2e /* '.' */ : |
213 |
case 0x30 /* '0' */ : |
214 |
case 0x31 /* '1' */ : |
215 |
case 0x32 /* '2' */ : |
216 |
case 0x33 /* '3' */ : |
217 |
case 0x34 /* '4' */ : |
218 |
case 0x35 /* '5' */ : |
219 |
case 0x36 /* '6' */ : |
220 |
case 0x37 /* '7' */ : |
221 |
case 0x38 /* '8' */ : |
222 |
case 0x39 /* '9' */ : |
223 |
{ |
224 |
mNUM_INT(true); |
225 |
theRetToken=_returnToken; |
226 |
break; |
227 |
} |
228 |
default: |
229 |
if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2a /* '*' */ )) { |
230 |
mComment(true); |
231 |
theRetToken=_returnToken; |
232 |
} |
233 |
else if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2f /* '/' */ )) { |
234 |
mCPPComment(true); |
235 |
theRetToken=_returnToken; |
236 |
} |
237 |
else { |
238 |
if (LA(1)==EOF_CHAR) |
239 |
{ |
240 |
uponEOF(); |
241 |
_returnToken = makeToken(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE); |
242 |
} |
243 |
else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} |
244 |
} |
245 |
} |
246 |
if ( !_returnToken ) |
247 |
goto tryAgain; // found SKIP token |
248 |
|
249 |
_ttype = _returnToken->getType(); |
250 |
_returnToken->setType(_ttype); |
251 |
return _returnToken; |
252 |
} |
253 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& e) { |
254 |
throw ANTLR_USE_NAMESPACE(antlr)TokenStreamRecognitionException(e); |
255 |
} |
256 |
catch (ANTLR_USE_NAMESPACE(antlr)CharStreamIOException& csie) { |
257 |
throw ANTLR_USE_NAMESPACE(antlr)TokenStreamIOException(csie.io); |
258 |
} |
259 |
catch (ANTLR_USE_NAMESPACE(antlr)CharStreamException& cse) { |
260 |
throw ANTLR_USE_NAMESPACE(antlr)TokenStreamException(cse.getMessage()); |
261 |
} |
262 |
tryAgain:; |
263 |
} |
264 |
} |
265 |
|
266 |
void MDLexer::mASSIGNEQUAL(bool _createToken) { |
267 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
268 |
_ttype = ASSIGNEQUAL; |
269 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
270 |
|
271 |
match('=' /* charlit */ ); |
272 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
273 |
_token = makeToken(_ttype); |
274 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
275 |
} |
276 |
_returnToken = _token; |
277 |
_saveIndex=0; |
278 |
} |
279 |
|
280 |
void MDLexer::mCOLON(bool _createToken) { |
281 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
282 |
_ttype = COLON; |
283 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
284 |
|
285 |
match(':' /* charlit */ ); |
286 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
287 |
_token = makeToken(_ttype); |
288 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
289 |
} |
290 |
_returnToken = _token; |
291 |
_saveIndex=0; |
292 |
} |
293 |
|
294 |
void MDLexer::mCOMMA(bool _createToken) { |
295 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
296 |
_ttype = COMMA; |
297 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
298 |
|
299 |
match(',' /* charlit */ ); |
300 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
301 |
_token = makeToken(_ttype); |
302 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
303 |
} |
304 |
_returnToken = _token; |
305 |
_saveIndex=0; |
306 |
} |
307 |
|
308 |
void MDLexer::mQUESTIONMARK(bool _createToken) { |
309 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
310 |
_ttype = QUESTIONMARK; |
311 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
312 |
|
313 |
match('?' /* charlit */ ); |
314 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
315 |
_token = makeToken(_ttype); |
316 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
317 |
} |
318 |
_returnToken = _token; |
319 |
_saveIndex=0; |
320 |
} |
321 |
|
322 |
void MDLexer::mSEMICOLON(bool _createToken) { |
323 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
324 |
_ttype = SEMICOLON; |
325 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
326 |
|
327 |
match(';' /* charlit */ ); |
328 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
329 |
_token = makeToken(_ttype); |
330 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
331 |
} |
332 |
_returnToken = _token; |
333 |
_saveIndex=0; |
334 |
} |
335 |
|
336 |
void MDLexer::mLPAREN(bool _createToken) { |
337 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
338 |
_ttype = LPAREN; |
339 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
340 |
|
341 |
match('(' /* charlit */ ); |
342 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
343 |
_token = makeToken(_ttype); |
344 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
345 |
} |
346 |
_returnToken = _token; |
347 |
_saveIndex=0; |
348 |
} |
349 |
|
350 |
void MDLexer::mRPAREN(bool _createToken) { |
351 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
352 |
_ttype = RPAREN; |
353 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
354 |
|
355 |
match(')' /* charlit */ ); |
356 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
357 |
_token = makeToken(_ttype); |
358 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
359 |
} |
360 |
_returnToken = _token; |
361 |
_saveIndex=0; |
362 |
} |
363 |
|
364 |
void MDLexer::mLBRACKET(bool _createToken) { |
365 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
366 |
_ttype = LBRACKET; |
367 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
368 |
|
369 |
match('[' /* charlit */ ); |
370 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
371 |
_token = makeToken(_ttype); |
372 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
373 |
} |
374 |
_returnToken = _token; |
375 |
_saveIndex=0; |
376 |
} |
377 |
|
378 |
void MDLexer::mRBRACKET(bool _createToken) { |
379 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
380 |
_ttype = RBRACKET; |
381 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
382 |
|
383 |
match(']' /* charlit */ ); |
384 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
385 |
_token = makeToken(_ttype); |
386 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
387 |
} |
388 |
_returnToken = _token; |
389 |
_saveIndex=0; |
390 |
} |
391 |
|
392 |
void MDLexer::mLCURLY(bool _createToken) { |
393 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
394 |
_ttype = LCURLY; |
395 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
396 |
|
397 |
match('{' /* charlit */ ); |
398 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
399 |
_token = makeToken(_ttype); |
400 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
401 |
} |
402 |
_returnToken = _token; |
403 |
_saveIndex=0; |
404 |
} |
405 |
|
406 |
void MDLexer::mRCURLY(bool _createToken) { |
407 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
408 |
_ttype = RCURLY; |
409 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
410 |
|
411 |
match('}' /* charlit */ ); |
412 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
413 |
_token = makeToken(_ttype); |
414 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
415 |
} |
416 |
_returnToken = _token; |
417 |
_saveIndex=0; |
418 |
} |
419 |
|
420 |
void MDLexer::mWhitespace(bool _createToken) { |
421 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
422 |
_ttype = Whitespace; |
423 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
424 |
|
425 |
{ |
426 |
switch ( LA(1)) { |
427 |
case 0x9 /* '\t' */ : |
428 |
case 0xc /* '\14' */ : |
429 |
case 0x20 /* ' ' */ : |
430 |
{ |
431 |
{ |
432 |
switch ( LA(1)) { |
433 |
case 0x20 /* ' ' */ : |
434 |
{ |
435 |
match(' ' /* charlit */ ); |
436 |
break; |
437 |
} |
438 |
case 0x9 /* '\t' */ : |
439 |
{ |
440 |
match('\t' /* charlit */ ); |
441 |
break; |
442 |
} |
443 |
case 0xc /* '\14' */ : |
444 |
{ |
445 |
match('\14' /* charlit */ ); |
446 |
break; |
447 |
} |
448 |
default: |
449 |
{ |
450 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
451 |
} |
452 |
} |
453 |
} |
454 |
break; |
455 |
} |
456 |
case 0xa /* '\n' */ : |
457 |
case 0xd /* '\r' */ : |
458 |
{ |
459 |
{ |
460 |
if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ )) { |
461 |
match('\r' /* charlit */ ); |
462 |
match('\n' /* charlit */ ); |
463 |
} |
464 |
else if ((LA(1) == 0xd /* '\r' */ ) && (true)) { |
465 |
match('\r' /* charlit */ ); |
466 |
} |
467 |
else if ((LA(1) == 0xa /* '\n' */ )) { |
468 |
match('\n' /* charlit */ ); |
469 |
} |
470 |
else { |
471 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
472 |
} |
473 |
|
474 |
} |
475 |
if ( inputState->guessing==0 ) { |
476 |
#line 218 "MDParser.g" |
477 |
newline(); |
478 |
#line 479 "MDLexer.cpp" |
479 |
} |
480 |
break; |
481 |
} |
482 |
case 0x5c /* '\\' */ : |
483 |
{ |
484 |
{ |
485 |
if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (LA(3) == 0xa /* '\n' */ )) { |
486 |
match('\\' /* charlit */ ); |
487 |
match('\r' /* charlit */ ); |
488 |
match('\n' /* charlit */ ); |
489 |
} |
490 |
else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (true)) { |
491 |
match('\\' /* charlit */ ); |
492 |
match('\r' /* charlit */ ); |
493 |
} |
494 |
else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */ )) { |
495 |
match('\\' /* charlit */ ); |
496 |
match('\n' /* charlit */ ); |
497 |
} |
498 |
else { |
499 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
500 |
} |
501 |
|
502 |
} |
503 |
if ( inputState->guessing==0 ) { |
504 |
#line 223 "MDParser.g" |
505 |
printf("CPP_parser.g continuation line detected\n"); |
506 |
deferredNewline(); |
507 |
#line 508 "MDLexer.cpp" |
508 |
} |
509 |
break; |
510 |
} |
511 |
default: |
512 |
{ |
513 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
514 |
} |
515 |
} |
516 |
} |
517 |
if ( inputState->guessing==0 ) { |
518 |
#line 226 "MDParser.g" |
519 |
_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; |
520 |
#line 521 "MDLexer.cpp" |
521 |
} |
522 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
523 |
_token = makeToken(_ttype); |
524 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
525 |
} |
526 |
_returnToken = _token; |
527 |
_saveIndex=0; |
528 |
} |
529 |
|
530 |
void MDLexer::mComment(bool _createToken) { |
531 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
532 |
_ttype = Comment; |
533 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
534 |
|
535 |
match("/*"); |
536 |
{ // ( ... )* |
537 |
for (;;) { |
538 |
if (((LA(1) == 0x2a /* '*' */ ) && ((LA(2) >= 0x0 /* '\0' */ && LA(2) <= 0xff)) && ((LA(3) >= 0x0 /* '\0' */ && LA(3) <= 0xff)))&&(LA(2) != '/')) { |
539 |
match('*' /* charlit */ ); |
540 |
} |
541 |
else if ((LA(1) == 0xa /* '\n' */ || LA(1) == 0xd /* '\r' */ )) { |
542 |
mEndOfLine(false); |
543 |
if ( inputState->guessing==0 ) { |
544 |
#line 233 "MDParser.g" |
545 |
deferredNewline(); |
546 |
#line 547 "MDLexer.cpp" |
547 |
} |
548 |
} |
549 |
else if ((_tokenSet_0.member(LA(1)))) { |
550 |
{ |
551 |
match(_tokenSet_0); |
552 |
} |
553 |
} |
554 |
else { |
555 |
goto _loop78; |
556 |
} |
557 |
|
558 |
} |
559 |
_loop78:; |
560 |
} // ( ... )* |
561 |
match("*/"); |
562 |
if ( inputState->guessing==0 ) { |
563 |
#line 236 "MDParser.g" |
564 |
_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; |
565 |
#line 566 "MDLexer.cpp" |
566 |
} |
567 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
568 |
_token = makeToken(_ttype); |
569 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
570 |
} |
571 |
_returnToken = _token; |
572 |
_saveIndex=0; |
573 |
} |
574 |
|
575 |
void MDLexer::mEndOfLine(bool _createToken) { |
576 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
577 |
_ttype = EndOfLine; |
578 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
579 |
|
580 |
{ |
581 |
if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ ) && (true)) { |
582 |
match("\r\n"); |
583 |
} |
584 |
else if ((LA(1) == 0xd /* '\r' */ ) && (true) && (true)) { |
585 |
match('\r' /* charlit */ ); |
586 |
} |
587 |
else if ((LA(1) == 0xa /* '\n' */ )) { |
588 |
match('\n' /* charlit */ ); |
589 |
} |
590 |
else { |
591 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
592 |
} |
593 |
|
594 |
} |
595 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
596 |
_token = makeToken(_ttype); |
597 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
598 |
} |
599 |
_returnToken = _token; |
600 |
_saveIndex=0; |
601 |
} |
602 |
|
603 |
void MDLexer::mCPPComment(bool _createToken) { |
604 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
605 |
_ttype = CPPComment; |
606 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
607 |
|
608 |
match("//"); |
609 |
{ // ( ... )* |
610 |
for (;;) { |
611 |
if ((_tokenSet_1.member(LA(1)))) { |
612 |
{ |
613 |
match(_tokenSet_1); |
614 |
} |
615 |
} |
616 |
else { |
617 |
goto _loop82; |
618 |
} |
619 |
|
620 |
} |
621 |
_loop82:; |
622 |
} // ( ... )* |
623 |
mEndOfLine(false); |
624 |
if ( inputState->guessing==0 ) { |
625 |
#line 242 "MDParser.g" |
626 |
_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline(); |
627 |
#line 628 "MDLexer.cpp" |
628 |
} |
629 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
630 |
_token = makeToken(_ttype); |
631 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
632 |
} |
633 |
_returnToken = _token; |
634 |
_saveIndex=0; |
635 |
} |
636 |
|
637 |
void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) { |
638 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
639 |
_ttype = PREPROC_DIRECTIVE; |
640 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
641 |
|
642 |
match('#' /* charlit */ ); |
643 |
mLineDirective(false); |
644 |
if ( inputState->guessing==0 ) { |
645 |
#line 249 "MDParser.g" |
646 |
_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline(); |
647 |
#line 648 "MDLexer.cpp" |
648 |
} |
649 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
650 |
_token = makeToken(_ttype); |
651 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
652 |
} |
653 |
_returnToken = _token; |
654 |
_saveIndex=0; |
655 |
} |
656 |
|
657 |
void MDLexer::mLineDirective(bool _createToken) { |
658 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
659 |
_ttype = LineDirective; |
660 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
661 |
ANTLR_USE_NAMESPACE(antlr)RefToken n; |
662 |
ANTLR_USE_NAMESPACE(antlr)RefToken sl; |
663 |
|
664 |
if ( inputState->guessing==0 ) { |
665 |
#line 255 "MDParser.g" |
666 |
|
667 |
deferredLineCount = 0; |
668 |
|
669 |
#line 670 "MDLexer.cpp" |
670 |
} |
671 |
{ |
672 |
switch ( LA(1)) { |
673 |
case 0x6c /* 'l' */ : |
674 |
{ |
675 |
match("line"); |
676 |
break; |
677 |
} |
678 |
case 0x9 /* '\t' */ : |
679 |
case 0xc /* '\14' */ : |
680 |
case 0x20 /* ' ' */ : |
681 |
{ |
682 |
break; |
683 |
} |
684 |
default: |
685 |
{ |
686 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
687 |
} |
688 |
} |
689 |
} |
690 |
{ // ( ... )+ |
691 |
int _cnt87=0; |
692 |
for (;;) { |
693 |
if ((LA(1) == 0x9 /* '\t' */ || LA(1) == 0xc /* '\14' */ || LA(1) == 0x20 /* ' ' */ )) { |
694 |
mSpace(false); |
695 |
} |
696 |
else { |
697 |
if ( _cnt87>=1 ) { goto _loop87; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} |
698 |
} |
699 |
|
700 |
_cnt87++; |
701 |
} |
702 |
_loop87:; |
703 |
} // ( ... )+ |
704 |
mDecimal(true); |
705 |
n=_returnToken; |
706 |
if ( inputState->guessing==0 ) { |
707 |
#line 260 "MDParser.g" |
708 |
setLine(oopse::lexi_cast<int>(n->getText()) - 1); |
709 |
#line 710 "MDLexer.cpp" |
710 |
} |
711 |
{ // ( ... )+ |
712 |
int _cnt89=0; |
713 |
for (;;) { |
714 |
if ((LA(1) == 0x9 /* '\t' */ || LA(1) == 0xc /* '\14' */ || LA(1) == 0x20 /* ' ' */ )) { |
715 |
mSpace(false); |
716 |
} |
717 |
else { |
718 |
if ( _cnt89>=1 ) { goto _loop89; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} |
719 |
} |
720 |
|
721 |
_cnt89++; |
722 |
} |
723 |
_loop89:; |
724 |
} // ( ... )+ |
725 |
{ |
726 |
mStringLiteral(true); |
727 |
sl=_returnToken; |
728 |
} |
729 |
if ( inputState->guessing==0 ) { |
730 |
#line 262 "MDParser.g" |
731 |
std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename); |
732 |
#line 733 "MDLexer.cpp" |
733 |
} |
734 |
{ // ( ... )* |
735 |
for (;;) { |
736 |
if ((LA(1) == 0x9 /* '\t' */ || LA(1) == 0xc /* '\14' */ || LA(1) == 0x20 /* ' ' */ )) { |
737 |
{ // ( ... )+ |
738 |
int _cnt93=0; |
739 |
for (;;) { |
740 |
if ((LA(1) == 0x9 /* '\t' */ || LA(1) == 0xc /* '\14' */ || LA(1) == 0x20 /* ' ' */ )) { |
741 |
mSpace(false); |
742 |
} |
743 |
else { |
744 |
if ( _cnt93>=1 ) { goto _loop93; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} |
745 |
} |
746 |
|
747 |
_cnt93++; |
748 |
} |
749 |
_loop93:; |
750 |
} // ( ... )+ |
751 |
mDecimal(false); |
752 |
} |
753 |
else { |
754 |
goto _loop94; |
755 |
} |
756 |
|
757 |
} |
758 |
_loop94:; |
759 |
} // ( ... )* |
760 |
mEndOfLine(false); |
761 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
762 |
_token = makeToken(_ttype); |
763 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
764 |
} |
765 |
_returnToken = _token; |
766 |
_saveIndex=0; |
767 |
} |
768 |
|
769 |
void MDLexer::mSpace(bool _createToken) { |
770 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
771 |
_ttype = Space; |
772 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
773 |
|
774 |
{ |
775 |
switch ( LA(1)) { |
776 |
case 0x20 /* ' ' */ : |
777 |
{ |
778 |
match(' ' /* charlit */ ); |
779 |
break; |
780 |
} |
781 |
case 0x9 /* '\t' */ : |
782 |
{ |
783 |
match('\t' /* charlit */ ); |
784 |
break; |
785 |
} |
786 |
case 0xc /* '\14' */ : |
787 |
{ |
788 |
match('\14' /* charlit */ ); |
789 |
break; |
790 |
} |
791 |
default: |
792 |
{ |
793 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
794 |
} |
795 |
} |
796 |
} |
797 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
798 |
_token = makeToken(_ttype); |
799 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
800 |
} |
801 |
_returnToken = _token; |
802 |
_saveIndex=0; |
803 |
} |
804 |
|
805 |
void MDLexer::mDecimal(bool _createToken) { |
806 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
807 |
_ttype = Decimal; |
808 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
809 |
|
810 |
{ // ( ... )+ |
811 |
int _cnt124=0; |
812 |
for (;;) { |
813 |
if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { |
814 |
matchRange('0','9'); |
815 |
} |
816 |
else { |
817 |
if ( _cnt124>=1 ) { goto _loop124; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} |
818 |
} |
819 |
|
820 |
_cnt124++; |
821 |
} |
822 |
_loop124:; |
823 |
} // ( ... )+ |
824 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
825 |
_token = makeToken(_ttype); |
826 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
827 |
} |
828 |
_returnToken = _token; |
829 |
_saveIndex=0; |
830 |
} |
831 |
|
832 |
void MDLexer::mStringLiteral(bool _createToken) { |
833 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
834 |
_ttype = StringLiteral; |
835 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
836 |
|
837 |
match('\"' /* charlit */ ); |
838 |
{ // ( ... )* |
839 |
for (;;) { |
840 |
if ((LA(1) == 0x5c /* '\\' */ ) && (_tokenSet_2.member(LA(2)))) { |
841 |
mEscape(false); |
842 |
} |
843 |
else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */ || LA(2) == 0xd /* '\r' */ )) { |
844 |
{ |
845 |
if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (LA(3) == 0xa /* '\n' */ )) { |
846 |
match("\\\r\n"); |
847 |
} |
848 |
else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (_tokenSet_1.member(LA(3)))) { |
849 |
match("\\\r"); |
850 |
} |
851 |
else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */ )) { |
852 |
match("\\\n"); |
853 |
} |
854 |
else { |
855 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
856 |
} |
857 |
|
858 |
} |
859 |
if ( inputState->guessing==0 ) { |
860 |
#line 302 "MDParser.g" |
861 |
deferredNewline(); |
862 |
#line 863 "MDLexer.cpp" |
863 |
} |
864 |
} |
865 |
else if ((_tokenSet_3.member(LA(1)))) { |
866 |
{ |
867 |
match(_tokenSet_3); |
868 |
} |
869 |
} |
870 |
else { |
871 |
goto _loop104; |
872 |
} |
873 |
|
874 |
} |
875 |
_loop104:; |
876 |
} // ( ... )* |
877 |
match('\"' /* charlit */ ); |
878 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
879 |
_token = makeToken(_ttype); |
880 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
881 |
} |
882 |
_returnToken = _token; |
883 |
_saveIndex=0; |
884 |
} |
885 |
|
886 |
void MDLexer::mCharLiteral(bool _createToken) { |
887 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
888 |
_ttype = CharLiteral; |
889 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
890 |
|
891 |
match('\'' /* charlit */ ); |
892 |
{ |
893 |
if ((LA(1) == 0x5c /* '\\' */ ) && (_tokenSet_2.member(LA(2))) && (_tokenSet_4.member(LA(3)))) { |
894 |
mEscape(false); |
895 |
} |
896 |
else if ((_tokenSet_5.member(LA(1))) && (LA(2) == 0x27 /* '\'' */ ) && (true)) { |
897 |
{ |
898 |
match(_tokenSet_5); |
899 |
} |
900 |
} |
901 |
else { |
902 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
903 |
} |
904 |
|
905 |
} |
906 |
match('\'' /* charlit */ ); |
907 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
908 |
_token = makeToken(_ttype); |
909 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
910 |
} |
911 |
_returnToken = _token; |
912 |
_saveIndex=0; |
913 |
} |
914 |
|
915 |
void MDLexer::mEscape(bool _createToken) { |
916 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
917 |
_ttype = Escape; |
918 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
919 |
|
920 |
match('\\' /* charlit */ ); |
921 |
{ |
922 |
switch ( LA(1)) { |
923 |
case 0x61 /* 'a' */ : |
924 |
{ |
925 |
match('a' /* charlit */ ); |
926 |
break; |
927 |
} |
928 |
case 0x62 /* 'b' */ : |
929 |
{ |
930 |
match('b' /* charlit */ ); |
931 |
break; |
932 |
} |
933 |
case 0x66 /* 'f' */ : |
934 |
{ |
935 |
match('f' /* charlit */ ); |
936 |
break; |
937 |
} |
938 |
case 0x6e /* 'n' */ : |
939 |
{ |
940 |
match('n' /* charlit */ ); |
941 |
break; |
942 |
} |
943 |
case 0x72 /* 'r' */ : |
944 |
{ |
945 |
match('r' /* charlit */ ); |
946 |
break; |
947 |
} |
948 |
case 0x74 /* 't' */ : |
949 |
{ |
950 |
match('t' /* charlit */ ); |
951 |
break; |
952 |
} |
953 |
case 0x76 /* 'v' */ : |
954 |
{ |
955 |
match('v' /* charlit */ ); |
956 |
break; |
957 |
} |
958 |
case 0x22 /* '\"' */ : |
959 |
{ |
960 |
match('\"' /* charlit */ ); |
961 |
break; |
962 |
} |
963 |
case 0x27 /* '\'' */ : |
964 |
{ |
965 |
match('\'' /* charlit */ ); |
966 |
break; |
967 |
} |
968 |
case 0x5c /* '\\' */ : |
969 |
{ |
970 |
match('\\' /* charlit */ ); |
971 |
break; |
972 |
} |
973 |
case 0x3f /* '?' */ : |
974 |
{ |
975 |
match('?' /* charlit */ ); |
976 |
break; |
977 |
} |
978 |
case 0x30 /* '0' */ : |
979 |
case 0x31 /* '1' */ : |
980 |
case 0x32 /* '2' */ : |
981 |
case 0x33 /* '3' */ : |
982 |
{ |
983 |
{ |
984 |
matchRange('0','3'); |
985 |
} |
986 |
{ |
987 |
if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) { |
988 |
mDigit(false); |
989 |
{ |
990 |
if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) { |
991 |
mDigit(false); |
992 |
} |
993 |
else if ((_tokenSet_1.member(LA(1))) && (true) && (true)) { |
994 |
} |
995 |
else { |
996 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
997 |
} |
998 |
|
999 |
} |
1000 |
} |
1001 |
else if ((_tokenSet_1.member(LA(1))) && (true) && (true)) { |
1002 |
} |
1003 |
else { |
1004 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
1005 |
} |
1006 |
|
1007 |
} |
1008 |
break; |
1009 |
} |
1010 |
case 0x34 /* '4' */ : |
1011 |
case 0x35 /* '5' */ : |
1012 |
case 0x36 /* '6' */ : |
1013 |
case 0x37 /* '7' */ : |
1014 |
{ |
1015 |
{ |
1016 |
matchRange('4','7'); |
1017 |
} |
1018 |
{ |
1019 |
if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) { |
1020 |
mDigit(false); |
1021 |
} |
1022 |
else if ((_tokenSet_1.member(LA(1))) && (true) && (true)) { |
1023 |
} |
1024 |
else { |
1025 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
1026 |
} |
1027 |
|
1028 |
} |
1029 |
break; |
1030 |
} |
1031 |
case 0x78 /* 'x' */ : |
1032 |
{ |
1033 |
match('x' /* charlit */ ); |
1034 |
{ // ( ... )+ |
1035 |
int _cnt115=0; |
1036 |
for (;;) { |
1037 |
if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) { |
1038 |
mDigit(false); |
1039 |
} |
1040 |
else if (((LA(1) >= 0x61 /* 'a' */ && LA(1) <= 0x66 /* 'f' */ )) && (_tokenSet_1.member(LA(2))) && (true)) { |
1041 |
matchRange('a','f'); |
1042 |
} |
1043 |
else if (((LA(1) >= 0x41 /* 'A' */ && LA(1) <= 0x46 /* 'F' */ )) && (_tokenSet_1.member(LA(2))) && (true)) { |
1044 |
matchRange('A','F'); |
1045 |
} |
1046 |
else { |
1047 |
if ( _cnt115>=1 ) { goto _loop115; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} |
1048 |
} |
1049 |
|
1050 |
_cnt115++; |
1051 |
} |
1052 |
_loop115:; |
1053 |
} // ( ... )+ |
1054 |
break; |
1055 |
} |
1056 |
default: |
1057 |
{ |
1058 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
1059 |
} |
1060 |
} |
1061 |
} |
1062 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
1063 |
_token = makeToken(_ttype); |
1064 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
1065 |
} |
1066 |
_returnToken = _token; |
1067 |
_saveIndex=0; |
1068 |
} |
1069 |
|
1070 |
void MDLexer::mDigit(bool _createToken) { |
1071 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
1072 |
_ttype = Digit; |
1073 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
1074 |
|
1075 |
matchRange('0','9'); |
1076 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
1077 |
_token = makeToken(_ttype); |
1078 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
1079 |
} |
1080 |
_returnToken = _token; |
1081 |
_saveIndex=0; |
1082 |
} |
1083 |
|
1084 |
void MDLexer::mVocabulary(bool _createToken) { |
1085 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
1086 |
_ttype = Vocabulary; |
1087 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
1088 |
|
1089 |
matchRange('\3',static_cast<unsigned char>('\377')); |
1090 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
1091 |
_token = makeToken(_ttype); |
1092 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
1093 |
} |
1094 |
_returnToken = _token; |
1095 |
_saveIndex=0; |
1096 |
} |
1097 |
|
1098 |
void MDLexer::mID(bool _createToken) { |
1099 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
1100 |
_ttype = ID; |
1101 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
1102 |
|
1103 |
{ |
1104 |
switch ( LA(1)) { |
1105 |
case 0x61 /* 'a' */ : |
1106 |
case 0x62 /* 'b' */ : |
1107 |
case 0x63 /* 'c' */ : |
1108 |
case 0x64 /* 'd' */ : |
1109 |
case 0x65 /* 'e' */ : |
1110 |
case 0x66 /* 'f' */ : |
1111 |
case 0x67 /* 'g' */ : |
1112 |
case 0x68 /* 'h' */ : |
1113 |
case 0x69 /* 'i' */ : |
1114 |
case 0x6a /* 'j' */ : |
1115 |
case 0x6b /* 'k' */ : |
1116 |
case 0x6c /* 'l' */ : |
1117 |
case 0x6d /* 'm' */ : |
1118 |
case 0x6e /* 'n' */ : |
1119 |
case 0x6f /* 'o' */ : |
1120 |
case 0x70 /* 'p' */ : |
1121 |
case 0x71 /* 'q' */ : |
1122 |
case 0x72 /* 'r' */ : |
1123 |
case 0x73 /* 's' */ : |
1124 |
case 0x74 /* 't' */ : |
1125 |
case 0x75 /* 'u' */ : |
1126 |
case 0x76 /* 'v' */ : |
1127 |
case 0x77 /* 'w' */ : |
1128 |
case 0x78 /* 'x' */ : |
1129 |
case 0x79 /* 'y' */ : |
1130 |
case 0x7a /* 'z' */ : |
1131 |
{ |
1132 |
matchRange('a','z'); |
1133 |
break; |
1134 |
} |
1135 |
case 0x41 /* 'A' */ : |
1136 |
case 0x42 /* 'B' */ : |
1137 |
case 0x43 /* 'C' */ : |
1138 |
case 0x44 /* 'D' */ : |
1139 |
case 0x45 /* 'E' */ : |
1140 |
case 0x46 /* 'F' */ : |
1141 |
case 0x47 /* 'G' */ : |
1142 |
case 0x48 /* 'H' */ : |
1143 |
case 0x49 /* 'I' */ : |
1144 |
case 0x4a /* 'J' */ : |
1145 |
case 0x4b /* 'K' */ : |
1146 |
case 0x4c /* 'L' */ : |
1147 |
case 0x4d /* 'M' */ : |
1148 |
case 0x4e /* 'N' */ : |
1149 |
case 0x4f /* 'O' */ : |
1150 |
case 0x50 /* 'P' */ : |
1151 |
case 0x51 /* 'Q' */ : |
1152 |
case 0x52 /* 'R' */ : |
1153 |
case 0x53 /* 'S' */ : |
1154 |
case 0x54 /* 'T' */ : |
1155 |
case 0x55 /* 'U' */ : |
1156 |
case 0x56 /* 'V' */ : |
1157 |
case 0x57 /* 'W' */ : |
1158 |
case 0x58 /* 'X' */ : |
1159 |
case 0x59 /* 'Y' */ : |
1160 |
case 0x5a /* 'Z' */ : |
1161 |
{ |
1162 |
matchRange('A','Z'); |
1163 |
break; |
1164 |
} |
1165 |
case 0x5f /* '_' */ : |
1166 |
{ |
1167 |
match('_' /* charlit */ ); |
1168 |
break; |
1169 |
} |
1170 |
default: |
1171 |
{ |
1172 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
1173 |
} |
1174 |
} |
1175 |
} |
1176 |
{ // ( ... )* |
1177 |
for (;;) { |
1178 |
switch ( LA(1)) { |
1179 |
case 0x61 /* 'a' */ : |
1180 |
case 0x62 /* 'b' */ : |
1181 |
case 0x63 /* 'c' */ : |
1182 |
case 0x64 /* 'd' */ : |
1183 |
case 0x65 /* 'e' */ : |
1184 |
case 0x66 /* 'f' */ : |
1185 |
case 0x67 /* 'g' */ : |
1186 |
case 0x68 /* 'h' */ : |
1187 |
case 0x69 /* 'i' */ : |
1188 |
case 0x6a /* 'j' */ : |
1189 |
case 0x6b /* 'k' */ : |
1190 |
case 0x6c /* 'l' */ : |
1191 |
case 0x6d /* 'm' */ : |
1192 |
case 0x6e /* 'n' */ : |
1193 |
case 0x6f /* 'o' */ : |
1194 |
case 0x70 /* 'p' */ : |
1195 |
case 0x71 /* 'q' */ : |
1196 |
case 0x72 /* 'r' */ : |
1197 |
case 0x73 /* 's' */ : |
1198 |
case 0x74 /* 't' */ : |
1199 |
case 0x75 /* 'u' */ : |
1200 |
case 0x76 /* 'v' */ : |
1201 |
case 0x77 /* 'w' */ : |
1202 |
case 0x78 /* 'x' */ : |
1203 |
case 0x79 /* 'y' */ : |
1204 |
case 0x7a /* 'z' */ : |
1205 |
{ |
1206 |
matchRange('a','z'); |
1207 |
break; |
1208 |
} |
1209 |
case 0x41 /* 'A' */ : |
1210 |
case 0x42 /* 'B' */ : |
1211 |
case 0x43 /* 'C' */ : |
1212 |
case 0x44 /* 'D' */ : |
1213 |
case 0x45 /* 'E' */ : |
1214 |
case 0x46 /* 'F' */ : |
1215 |
case 0x47 /* 'G' */ : |
1216 |
case 0x48 /* 'H' */ : |
1217 |
case 0x49 /* 'I' */ : |
1218 |
case 0x4a /* 'J' */ : |
1219 |
case 0x4b /* 'K' */ : |
1220 |
case 0x4c /* 'L' */ : |
1221 |
case 0x4d /* 'M' */ : |
1222 |
case 0x4e /* 'N' */ : |
1223 |
case 0x4f /* 'O' */ : |
1224 |
case 0x50 /* 'P' */ : |
1225 |
case 0x51 /* 'Q' */ : |
1226 |
case 0x52 /* 'R' */ : |
1227 |
case 0x53 /* 'S' */ : |
1228 |
case 0x54 /* 'T' */ : |
1229 |
case 0x55 /* 'U' */ : |
1230 |
case 0x56 /* 'V' */ : |
1231 |
case 0x57 /* 'W' */ : |
1232 |
case 0x58 /* 'X' */ : |
1233 |
case 0x59 /* 'Y' */ : |
1234 |
case 0x5a /* 'Z' */ : |
1235 |
{ |
1236 |
matchRange('A','Z'); |
1237 |
break; |
1238 |
} |
1239 |
case 0x5f /* '_' */ : |
1240 |
{ |
1241 |
match('_' /* charlit */ ); |
1242 |
break; |
1243 |
} |
1244 |
case 0x30 /* '0' */ : |
1245 |
case 0x31 /* '1' */ : |
1246 |
case 0x32 /* '2' */ : |
1247 |
case 0x33 /* '3' */ : |
1248 |
case 0x34 /* '4' */ : |
1249 |
case 0x35 /* '5' */ : |
1250 |
case 0x36 /* '6' */ : |
1251 |
case 0x37 /* '7' */ : |
1252 |
case 0x38 /* '8' */ : |
1253 |
case 0x39 /* '9' */ : |
1254 |
{ |
1255 |
matchRange('0','9'); |
1256 |
break; |
1257 |
} |
1258 |
default: |
1259 |
{ |
1260 |
goto _loop120; |
1261 |
} |
1262 |
} |
1263 |
} |
1264 |
_loop120:; |
1265 |
} // ( ... )* |
1266 |
_ttype = testLiteralsTable(_ttype); |
1267 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
1268 |
_token = makeToken(_ttype); |
1269 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
1270 |
} |
1271 |
_returnToken = _token; |
1272 |
_saveIndex=0; |
1273 |
} |
1274 |
|
1275 |
void MDLexer::mHEX_DIGIT(bool _createToken) { |
1276 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
1277 |
_ttype = HEX_DIGIT; |
1278 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
1279 |
|
1280 |
{ |
1281 |
switch ( LA(1)) { |
1282 |
case 0x30 /* '0' */ : |
1283 |
case 0x31 /* '1' */ : |
1284 |
case 0x32 /* '2' */ : |
1285 |
case 0x33 /* '3' */ : |
1286 |
case 0x34 /* '4' */ : |
1287 |
case 0x35 /* '5' */ : |
1288 |
case 0x36 /* '6' */ : |
1289 |
case 0x37 /* '7' */ : |
1290 |
case 0x38 /* '8' */ : |
1291 |
case 0x39 /* '9' */ : |
1292 |
{ |
1293 |
matchRange('0','9'); |
1294 |
break; |
1295 |
} |
1296 |
case 0x41 /* 'A' */ : |
1297 |
case 0x42 /* 'B' */ : |
1298 |
case 0x43 /* 'C' */ : |
1299 |
case 0x44 /* 'D' */ : |
1300 |
case 0x45 /* 'E' */ : |
1301 |
case 0x46 /* 'F' */ : |
1302 |
{ |
1303 |
matchRange('A','F'); |
1304 |
break; |
1305 |
} |
1306 |
case 0x61 /* 'a' */ : |
1307 |
case 0x62 /* 'b' */ : |
1308 |
case 0x63 /* 'c' */ : |
1309 |
case 0x64 /* 'd' */ : |
1310 |
case 0x65 /* 'e' */ : |
1311 |
case 0x66 /* 'f' */ : |
1312 |
{ |
1313 |
matchRange('a','f'); |
1314 |
break; |
1315 |
} |
1316 |
default: |
1317 |
{ |
1318 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
1319 |
} |
1320 |
} |
1321 |
} |
1322 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
1323 |
_token = makeToken(_ttype); |
1324 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
1325 |
} |
1326 |
_returnToken = _token; |
1327 |
_saveIndex=0; |
1328 |
} |
1329 |
|
1330 |
void MDLexer::mNUM_INT(bool _createToken) { |
1331 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
1332 |
_ttype = NUM_INT; |
1333 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
1334 |
ANTLR_USE_NAMESPACE(antlr)RefToken f1; |
1335 |
ANTLR_USE_NAMESPACE(antlr)RefToken f2; |
1336 |
ANTLR_USE_NAMESPACE(antlr)RefToken f3; |
1337 |
ANTLR_USE_NAMESPACE(antlr)RefToken f4; |
1338 |
#line 395 "MDParser.g" |
1339 |
|
1340 |
bool isDecimal = false; |
1341 |
ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken; |
1342 |
|
1343 |
#line 1344 "MDLexer.cpp" |
1344 |
|
1345 |
{ |
1346 |
switch ( LA(1)) { |
1347 |
case 0x2b /* '+' */ : |
1348 |
{ |
1349 |
match('+' /* charlit */ ); |
1350 |
break; |
1351 |
} |
1352 |
case 0x2d /* '-' */ : |
1353 |
{ |
1354 |
match('-' /* charlit */ ); |
1355 |
break; |
1356 |
} |
1357 |
case 0x2e /* '.' */ : |
1358 |
case 0x30 /* '0' */ : |
1359 |
case 0x31 /* '1' */ : |
1360 |
case 0x32 /* '2' */ : |
1361 |
case 0x33 /* '3' */ : |
1362 |
case 0x34 /* '4' */ : |
1363 |
case 0x35 /* '5' */ : |
1364 |
case 0x36 /* '6' */ : |
1365 |
case 0x37 /* '7' */ : |
1366 |
case 0x38 /* '8' */ : |
1367 |
case 0x39 /* '9' */ : |
1368 |
{ |
1369 |
break; |
1370 |
} |
1371 |
default: |
1372 |
{ |
1373 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
1374 |
} |
1375 |
} |
1376 |
} |
1377 |
{ |
1378 |
switch ( LA(1)) { |
1379 |
case 0x2e /* '.' */ : |
1380 |
{ |
1381 |
match('.' /* charlit */ ); |
1382 |
if ( inputState->guessing==0 ) { |
1383 |
#line 402 "MDParser.g" |
1384 |
_ttype = DOT; |
1385 |
#line 1386 "MDLexer.cpp" |
1386 |
} |
1387 |
{ |
1388 |
if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { |
1389 |
{ // ( ... )+ |
1390 |
int _cnt132=0; |
1391 |
for (;;) { |
1392 |
if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { |
1393 |
matchRange('0','9'); |
1394 |
} |
1395 |
else { |
1396 |
if ( _cnt132>=1 ) { goto _loop132; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} |
1397 |
} |
1398 |
|
1399 |
_cnt132++; |
1400 |
} |
1401 |
_loop132:; |
1402 |
} // ( ... )+ |
1403 |
{ |
1404 |
if ((LA(1) == 0x45 /* 'E' */ || LA(1) == 0x65 /* 'e' */ )) { |
1405 |
mEXPONENT(false); |
1406 |
} |
1407 |
else { |
1408 |
} |
1409 |
|
1410 |
} |
1411 |
{ |
1412 |
if ((_tokenSet_6.member(LA(1)))) { |
1413 |
mFLOAT_SUFFIX(true); |
1414 |
f1=_returnToken; |
1415 |
if ( inputState->guessing==0 ) { |
1416 |
#line 403 "MDParser.g" |
1417 |
t=f1; |
1418 |
#line 1419 "MDLexer.cpp" |
1419 |
} |
1420 |
} |
1421 |
else { |
1422 |
} |
1423 |
|
1424 |
} |
1425 |
if ( inputState->guessing==0 ) { |
1426 |
#line 404 "MDParser.g" |
1427 |
|
1428 |
if ( t && |
1429 |
(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos || |
1430 |
t->getText().find('F') != ANTLR_USE_NAMESPACE(std)string::npos ) ) { |
1431 |
_ttype = NUM_FLOAT; |
1432 |
} |
1433 |
else { |
1434 |
_ttype = NUM_DOUBLE; // assume double |
1435 |
} |
1436 |
|
1437 |
#line 1438 "MDLexer.cpp" |
1438 |
} |
1439 |
} |
1440 |
else { |
1441 |
} |
1442 |
|
1443 |
} |
1444 |
break; |
1445 |
} |
1446 |
case 0x30 /* '0' */ : |
1447 |
case 0x31 /* '1' */ : |
1448 |
case 0x32 /* '2' */ : |
1449 |
case 0x33 /* '3' */ : |
1450 |
case 0x34 /* '4' */ : |
1451 |
case 0x35 /* '5' */ : |
1452 |
case 0x36 /* '6' */ : |
1453 |
case 0x37 /* '7' */ : |
1454 |
case 0x38 /* '8' */ : |
1455 |
case 0x39 /* '9' */ : |
1456 |
{ |
1457 |
{ |
1458 |
switch ( LA(1)) { |
1459 |
case 0x30 /* '0' */ : |
1460 |
{ |
1461 |
match('0' /* charlit */ ); |
1462 |
if ( inputState->guessing==0 ) { |
1463 |
#line 416 "MDParser.g" |
1464 |
isDecimal = true; |
1465 |
#line 1466 "MDLexer.cpp" |
1466 |
} |
1467 |
{ |
1468 |
if ((LA(1) == 0x58 /* 'X' */ || LA(1) == 0x78 /* 'x' */ )) { |
1469 |
{ |
1470 |
switch ( LA(1)) { |
1471 |
case 0x78 /* 'x' */ : |
1472 |
{ |
1473 |
match('x' /* charlit */ ); |
1474 |
break; |
1475 |
} |
1476 |
case 0x58 /* 'X' */ : |
1477 |
{ |
1478 |
match('X' /* charlit */ ); |
1479 |
break; |
1480 |
} |
1481 |
default: |
1482 |
{ |
1483 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
1484 |
} |
1485 |
} |
1486 |
} |
1487 |
{ // ( ... )+ |
1488 |
int _cnt139=0; |
1489 |
for (;;) { |
1490 |
if ((_tokenSet_7.member(LA(1))) && (true) && (true)) { |
1491 |
mHEX_DIGIT(false); |
1492 |
} |
1493 |
else { |
1494 |
if ( _cnt139>=1 ) { goto _loop139; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} |
1495 |
} |
1496 |
|
1497 |
_cnt139++; |
1498 |
} |
1499 |
_loop139:; |
1500 |
} // ( ... )+ |
1501 |
} |
1502 |
else { |
1503 |
bool synPredMatched144 = false; |
1504 |
if ((((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) { |
1505 |
int _m144 = mark(); |
1506 |
synPredMatched144 = true; |
1507 |
inputState->guessing++; |
1508 |
try { |
1509 |
{ |
1510 |
{ // ( ... )+ |
1511 |
int _cnt142=0; |
1512 |
for (;;) { |
1513 |
if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { |
1514 |
matchRange('0','9'); |
1515 |
} |
1516 |
else { |
1517 |
if ( _cnt142>=1 ) { goto _loop142; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} |
1518 |
} |
1519 |
|
1520 |
_cnt142++; |
1521 |
} |
1522 |
_loop142:; |
1523 |
} // ( ... )+ |
1524 |
{ |
1525 |
switch ( LA(1)) { |
1526 |
case 0x2e /* '.' */ : |
1527 |
{ |
1528 |
match('.' /* charlit */ ); |
1529 |
break; |
1530 |
} |
1531 |
case 0x45 /* 'E' */ : |
1532 |
case 0x65 /* 'e' */ : |
1533 |
{ |
1534 |
mEXPONENT(false); |
1535 |
break; |
1536 |
} |
1537 |
case 0x44 /* 'D' */ : |
1538 |
case 0x46 /* 'F' */ : |
1539 |
case 0x64 /* 'd' */ : |
1540 |
case 0x66 /* 'f' */ : |
1541 |
{ |
1542 |
mFLOAT_SUFFIX(false); |
1543 |
break; |
1544 |
} |
1545 |
default: |
1546 |
{ |
1547 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
1548 |
} |
1549 |
} |
1550 |
} |
1551 |
} |
1552 |
} |
1553 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { |
1554 |
synPredMatched144 = false; |
1555 |
} |
1556 |
rewind(_m144); |
1557 |
inputState->guessing--; |
1558 |
} |
1559 |
if ( synPredMatched144 ) { |
1560 |
{ // ( ... )+ |
1561 |
int _cnt146=0; |
1562 |
for (;;) { |
1563 |
if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { |
1564 |
matchRange('0','9'); |
1565 |
} |
1566 |
else { |
1567 |
if ( _cnt146>=1 ) { goto _loop146; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} |
1568 |
} |
1569 |
|
1570 |
_cnt146++; |
1571 |
} |
1572 |
_loop146:; |
1573 |
} // ( ... )+ |
1574 |
} |
1575 |
else if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) { |
1576 |
{ // ( ... )+ |
1577 |
int _cnt148=0; |
1578 |
for (;;) { |
1579 |
if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x37 /* '7' */ ))) { |
1580 |
matchRange('0','7'); |
1581 |
} |
1582 |
else { |
1583 |
if ( _cnt148>=1 ) { goto _loop148; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} |
1584 |
} |
1585 |
|
1586 |
_cnt148++; |
1587 |
} |
1588 |
_loop148:; |
1589 |
} // ( ... )+ |
1590 |
} |
1591 |
else { |
1592 |
} |
1593 |
} |
1594 |
} |
1595 |
break; |
1596 |
} |
1597 |
case 0x31 /* '1' */ : |
1598 |
case 0x32 /* '2' */ : |
1599 |
case 0x33 /* '3' */ : |
1600 |
case 0x34 /* '4' */ : |
1601 |
case 0x35 /* '5' */ : |
1602 |
case 0x36 /* '6' */ : |
1603 |
case 0x37 /* '7' */ : |
1604 |
case 0x38 /* '8' */ : |
1605 |
case 0x39 /* '9' */ : |
1606 |
{ |
1607 |
{ |
1608 |
matchRange('1','9'); |
1609 |
} |
1610 |
{ // ( ... )* |
1611 |
for (;;) { |
1612 |
if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { |
1613 |
matchRange('0','9'); |
1614 |
} |
1615 |
else { |
1616 |
goto _loop151; |
1617 |
} |
1618 |
|
1619 |
} |
1620 |
_loop151:; |
1621 |
} // ( ... )* |
1622 |
if ( inputState->guessing==0 ) { |
1623 |
#line 433 "MDParser.g" |
1624 |
isDecimal=true; |
1625 |
#line 1626 "MDLexer.cpp" |
1626 |
} |
1627 |
break; |
1628 |
} |
1629 |
default: |
1630 |
{ |
1631 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
1632 |
} |
1633 |
} |
1634 |
} |
1635 |
{ |
1636 |
if ((LA(1) == 0x4c /* 'L' */ || LA(1) == 0x6c /* 'l' */ )) { |
1637 |
{ |
1638 |
switch ( LA(1)) { |
1639 |
case 0x6c /* 'l' */ : |
1640 |
{ |
1641 |
match('l' /* charlit */ ); |
1642 |
break; |
1643 |
} |
1644 |
case 0x4c /* 'L' */ : |
1645 |
{ |
1646 |
match('L' /* charlit */ ); |
1647 |
break; |
1648 |
} |
1649 |
default: |
1650 |
{ |
1651 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
1652 |
} |
1653 |
} |
1654 |
} |
1655 |
if ( inputState->guessing==0 ) { |
1656 |
#line 435 "MDParser.g" |
1657 |
_ttype = NUM_LONG; |
1658 |
#line 1659 "MDLexer.cpp" |
1659 |
} |
1660 |
} |
1661 |
else if (((_tokenSet_8.member(LA(1))))&&(isDecimal)) { |
1662 |
{ |
1663 |
switch ( LA(1)) { |
1664 |
case 0x2e /* '.' */ : |
1665 |
{ |
1666 |
match('.' /* charlit */ ); |
1667 |
{ // ( ... )* |
1668 |
for (;;) { |
1669 |
if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { |
1670 |
matchRange('0','9'); |
1671 |
} |
1672 |
else { |
1673 |
goto _loop156; |
1674 |
} |
1675 |
|
1676 |
} |
1677 |
_loop156:; |
1678 |
} // ( ... )* |
1679 |
{ |
1680 |
if ((LA(1) == 0x45 /* 'E' */ || LA(1) == 0x65 /* 'e' */ )) { |
1681 |
mEXPONENT(false); |
1682 |
} |
1683 |
else { |
1684 |
} |
1685 |
|
1686 |
} |
1687 |
{ |
1688 |
if ((_tokenSet_6.member(LA(1)))) { |
1689 |
mFLOAT_SUFFIX(true); |
1690 |
f2=_returnToken; |
1691 |
if ( inputState->guessing==0 ) { |
1692 |
#line 439 "MDParser.g" |
1693 |
t=f2; |
1694 |
#line 1695 "MDLexer.cpp" |
1695 |
} |
1696 |
} |
1697 |
else { |
1698 |
} |
1699 |
|
1700 |
} |
1701 |
break; |
1702 |
} |
1703 |
case 0x45 /* 'E' */ : |
1704 |
case 0x65 /* 'e' */ : |
1705 |
{ |
1706 |
mEXPONENT(false); |
1707 |
{ |
1708 |
if ((_tokenSet_6.member(LA(1)))) { |
1709 |
mFLOAT_SUFFIX(true); |
1710 |
f3=_returnToken; |
1711 |
if ( inputState->guessing==0 ) { |
1712 |
#line 440 "MDParser.g" |
1713 |
t=f3; |
1714 |
#line 1715 "MDLexer.cpp" |
1715 |
} |
1716 |
} |
1717 |
else { |
1718 |
} |
1719 |
|
1720 |
} |
1721 |
break; |
1722 |
} |
1723 |
case 0x44 /* 'D' */ : |
1724 |
case 0x46 /* 'F' */ : |
1725 |
case 0x64 /* 'd' */ : |
1726 |
case 0x66 /* 'f' */ : |
1727 |
{ |
1728 |
mFLOAT_SUFFIX(true); |
1729 |
f4=_returnToken; |
1730 |
if ( inputState->guessing==0 ) { |
1731 |
#line 441 "MDParser.g" |
1732 |
t=f4; |
1733 |
#line 1734 "MDLexer.cpp" |
1734 |
} |
1735 |
break; |
1736 |
} |
1737 |
default: |
1738 |
{ |
1739 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
1740 |
} |
1741 |
} |
1742 |
} |
1743 |
if ( inputState->guessing==0 ) { |
1744 |
#line 443 "MDParser.g" |
1745 |
|
1746 |
if ( t && |
1747 |
(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos || |
1748 |
t->getText().find('F') != ANTLR_USE_NAMESPACE(std)string::npos ) ) { |
1749 |
_ttype = NUM_FLOAT; |
1750 |
} |
1751 |
else { |
1752 |
_ttype = NUM_DOUBLE; // assume double |
1753 |
} |
1754 |
|
1755 |
#line 1756 "MDLexer.cpp" |
1756 |
} |
1757 |
} |
1758 |
else { |
1759 |
} |
1760 |
|
1761 |
} |
1762 |
break; |
1763 |
} |
1764 |
default: |
1765 |
{ |
1766 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
1767 |
} |
1768 |
} |
1769 |
} |
1770 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
1771 |
_token = makeToken(_ttype); |
1772 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
1773 |
} |
1774 |
_returnToken = _token; |
1775 |
_saveIndex=0; |
1776 |
} |
1777 |
|
1778 |
void MDLexer::mEXPONENT(bool _createToken) { |
1779 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
1780 |
_ttype = EXPONENT; |
1781 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
1782 |
|
1783 |
{ |
1784 |
switch ( LA(1)) { |
1785 |
case 0x65 /* 'e' */ : |
1786 |
{ |
1787 |
match('e' /* charlit */ ); |
1788 |
break; |
1789 |
} |
1790 |
case 0x45 /* 'E' */ : |
1791 |
{ |
1792 |
match('E' /* charlit */ ); |
1793 |
break; |
1794 |
} |
1795 |
default: |
1796 |
{ |
1797 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
1798 |
} |
1799 |
} |
1800 |
} |
1801 |
{ |
1802 |
switch ( LA(1)) { |
1803 |
case 0x2b /* '+' */ : |
1804 |
{ |
1805 |
match('+' /* charlit */ ); |
1806 |
break; |
1807 |
} |
1808 |
case 0x2d /* '-' */ : |
1809 |
{ |
1810 |
match('-' /* charlit */ ); |
1811 |
break; |
1812 |
} |
1813 |
case 0x30 /* '0' */ : |
1814 |
case 0x31 /* '1' */ : |
1815 |
case 0x32 /* '2' */ : |
1816 |
case 0x33 /* '3' */ : |
1817 |
case 0x34 /* '4' */ : |
1818 |
case 0x35 /* '5' */ : |
1819 |
case 0x36 /* '6' */ : |
1820 |
case 0x37 /* '7' */ : |
1821 |
case 0x38 /* '8' */ : |
1822 |
case 0x39 /* '9' */ : |
1823 |
{ |
1824 |
break; |
1825 |
} |
1826 |
default: |
1827 |
{ |
1828 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
1829 |
} |
1830 |
} |
1831 |
} |
1832 |
{ // ( ... )+ |
1833 |
int _cnt164=0; |
1834 |
for (;;) { |
1835 |
if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { |
1836 |
matchRange('0','9'); |
1837 |
} |
1838 |
else { |
1839 |
if ( _cnt164>=1 ) { goto _loop164; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} |
1840 |
} |
1841 |
|
1842 |
_cnt164++; |
1843 |
} |
1844 |
_loop164:; |
1845 |
} // ( ... )+ |
1846 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
1847 |
_token = makeToken(_ttype); |
1848 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
1849 |
} |
1850 |
_returnToken = _token; |
1851 |
_saveIndex=0; |
1852 |
} |
1853 |
|
1854 |
void MDLexer::mFLOAT_SUFFIX(bool _createToken) { |
1855 |
int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); |
1856 |
_ttype = FLOAT_SUFFIX; |
1857 |
ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; |
1858 |
|
1859 |
switch ( LA(1)) { |
1860 |
case 0x66 /* 'f' */ : |
1861 |
{ |
1862 |
match('f' /* charlit */ ); |
1863 |
break; |
1864 |
} |
1865 |
case 0x46 /* 'F' */ : |
1866 |
{ |
1867 |
match('F' /* charlit */ ); |
1868 |
break; |
1869 |
} |
1870 |
case 0x64 /* 'd' */ : |
1871 |
{ |
1872 |
match('d' /* charlit */ ); |
1873 |
break; |
1874 |
} |
1875 |
case 0x44 /* 'D' */ : |
1876 |
{ |
1877 |
match('D' /* charlit */ ); |
1878 |
break; |
1879 |
} |
1880 |
default: |
1881 |
{ |
1882 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); |
1883 |
} |
1884 |
} |
1885 |
if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { |
1886 |
_token = makeToken(_ttype); |
1887 |
_token->setText(text.substr(_begin, text.length()-_begin)); |
1888 |
} |
1889 |
_returnToken = _token; |
1890 |
_saveIndex=0; |
1891 |
} |
1892 |
|
1893 |
|
1894 |
const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; |
1895 |
// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 |
1896 |
// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! |
1897 |
// \" # $ % & \' ( ) + , - . / 0 1 2 |
1898 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_0(_tokenSet_0_data_,16); |
1899 |
const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; |
1900 |
// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 |
1901 |
// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! |
1902 |
// \" # $ % & \' ( ) * + , - . / 0 1 2 |
1903 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_1(_tokenSet_1_data_,16); |
1904 |
const unsigned long MDLexer::_tokenSet_2_data_[] = { 0UL, 2164195460UL, 268435456UL, 22298694UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; |
1905 |
// \" \' 0 1 2 |
1906 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_2(_tokenSet_2_data_,10); |
1907 |
const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958079UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; |
1908 |
// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 |
1909 |
// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! |
1910 |
// # $ % & \' ( ) * + , - . / 0 1 2 |
1911 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_3(_tokenSet_3_data_,16); |
1912 |
const unsigned long MDLexer::_tokenSet_4_data_[] = { 0UL, 67043456UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; |
1913 |
// \' 0 1 2 |
1914 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_4(_tokenSet_4_data_,10); |
1915 |
const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; |
1916 |
// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10 |
1917 |
// 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e |
1918 |
// 0x1f ! \" # $ % & ( ) * + , - . / 0 1 2 |
1919 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16); |
1920 |
const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; |
1921 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10); |
1922 |
const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; |
1923 |
// 0 1 2 |
1924 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_7(_tokenSet_7_data_,10); |
1925 |
const unsigned long MDLexer::_tokenSet_8_data_[] = { 0UL, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; |
1926 |
// . |
1927 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_8(_tokenSet_8_data_,10); |
1928 |
|