Datei: NDODLL/NDOql/Parser.cs
Last Commit (fe801ed)
1 | using System.Collections.Generic; |
2 | using System.Text; |
3 | using System.Globalization; |
4 | using NDOql.Expressions; |
5 | |
6 | |
7 | |
8 | // |
9 | // This is generated code. Do not change it directly, change the Parser.frame file and rebuild the grammar. |
10 | // |
11 | |
12 | using System; |
13 | #pragma warning disable 3008, 1591 |
14 | |
15 | namespace NDOql { |
16 | |
17 | |
18 | |
19 | public class Parser { |
20 | ····public const int _EOF = 0; |
21 | ····public const int _ident = 1; |
22 | ····public const int _realCon = 2; |
23 | ····public const int _intCon = 3; |
24 | ····public const int _stringCon = 4; |
25 | ····public const int _AND = 5; |
26 | ····public const int _OR = 6; |
27 | ····public const int _NOT = 7; |
28 | ····public const int _LIKE = 8; |
29 | ····public const int _ESCAPE = 9; |
30 | ····public const int _BETWEEN = 10; |
31 | ····public const int _IS = 11; |
32 | ····public const int _NULL = 12; |
33 | ····public const int _TRUE = 13; |
34 | ····public const int _MOD = 14; |
35 | ····public const int _IN = 15; |
36 | ····public const int _parameter = 16; |
37 | ····public const int maxT = 39; |
38 | |
39 | ····const bool T = true; |
40 | ····const bool x = false; |
41 | ····const int minErrDist = 2; |
42 | ···· |
43 | ····public Scanner scanner; |
44 | ····public Errors··errors; |
45 | |
46 | ····public Token t;····// last recognized token |
47 | ····public Token la;·· // lookahead token |
48 | ····int errDist = minErrDist; |
49 | |
50 | OqlExpression rootExpression; |
51 | public OqlExpression RootExpression |
52 | { |
53 | ····get { return rootExpression; } |
54 | } |
55 | |
56 | |
57 | |
58 | /*------------------------------------------------------------------------* |
59 | *----- SCANNER DESCRIPTION ----------------------------------------------* |
60 | *------------------------------------------------------------------------*/ |
61 | |
62 | |
63 | |
64 | ····public Parser(Scanner scanner) { |
65 | ········this.scanner = scanner; |
66 | ········errors = new Errors(); |
67 | ····} |
68 | |
69 | ····void SynErr (int n) { |
70 | ········if (errDist >= minErrDist) errors.SynErr(la.line, la.col, n); |
71 | ········errDist = 0; |
72 | ····} |
73 | |
74 | ····public void SemErr (string msg) { |
75 | ········if (errDist >= minErrDist) errors.SemErr(t.line, t.col, msg); |
76 | ········errDist = 0; |
77 | ····} |
78 | ···· |
79 | ····void Get () { |
80 | ········for (;;) { |
81 | ············t = la; |
82 | ············la = scanner.Scan(); |
83 | ············if (la.kind <= maxT) { ++errDist; break; } |
84 | |
85 | ············la = t; |
86 | ········} |
87 | ····} |
88 | ···· |
89 | ····void Expect (int n) { |
90 | ········if (la.kind==n) Get(); else { SynErr(n); } |
91 | ····} |
92 | ···· |
93 | ····bool StartOf (int s) { |
94 | ········return set[s, la.kind]; |
95 | ····} |
96 | ···· |
97 | ····void ExpectWeak (int n, int follow) { |
98 | ········if (la.kind == n) Get(); |
99 | ········else { |
100 | ············SynErr(n); |
101 | ············while (!StartOf(follow)) Get(); |
102 | ········} |
103 | ····} |
104 | |
105 | |
106 | ····bool WeakSeparator(int n, int syFol, int repFol) { |
107 | ········int kind = la.kind; |
108 | ········if (kind == n) {Get(); return true;} |
109 | ········else if (StartOf(repFol)) {return false;} |
110 | ········else { |
111 | ············SynErr(n); |
112 | ············while (!(set[syFol, kind] || set[repFol, kind] || set[0, kind])) { |
113 | ················Get(); |
114 | ················kind = la.kind; |
115 | ············} |
116 | ············return StartOf(syFol); |
117 | ········} |
118 | ····} |
119 | |
120 | ····bool IsOidIdentifier(OqlExpression iexp) { |
121 | ········return ((string)iexp.Value).EndsWith("oid"); |
122 | ····} |
123 | |
124 | ···· |
125 | ····void NDOQL() { |
126 | ········RootExpr(out this.rootExpression); |
127 | ····} |
128 | |
129 | ····void RootExpr(out OqlExpression expression) { |
130 | ········OqlExpression child; |
131 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
132 | ········bool negated = false; |
133 | ········ |
134 | ········if (la.kind == 7) { |
135 | ············Get(); |
136 | ············negated = true; |
137 | ········} |
138 | ········OrExpr(out child); |
139 | ········if (negated) result.UnaryOp = "NOT"; |
140 | ········result.Add(child); |
141 | ········expression = result.Simplify(); |
142 | ········ |
143 | ····} |
144 | |
145 | ····void OrExpr(out OqlExpression expression) { |
146 | ········OqlExpression child; |
147 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
148 | ········ |
149 | ········AndExpr(out child); |
150 | ········result.Add(child); |
151 | ········while (la.kind == 6) { |
152 | ············Get(); |
153 | ············bool negated = false; |
154 | ············if (la.kind == 7) { |
155 | ················Get(); |
156 | ················negated = true; |
157 | ············} |
158 | ············AndExpr(out child); |
159 | ············if (negated) child.UnaryOp = "NOT"; result.Add(child, "OR"); |
160 | ········} |
161 | ········expression = result.Simplify(); |
162 | ····} |
163 | |
164 | ····void AndExpr(out OqlExpression expression) { |
165 | ········OqlExpression child; |
166 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
167 | ········ |
168 | ········EqlExpr(out child); |
169 | ········result.Add(child); |
170 | ········while (la.kind == 5) { |
171 | ············Get(); |
172 | ············bool negated = false; |
173 | ············if (la.kind == 7) { |
174 | ················Get(); |
175 | ················negated = true; |
176 | ············} |
177 | ············EqlExpr(out child); |
178 | ············if (negated) child.UnaryOp = "NOT"; result.Add(child, "AND"); |
179 | ········} |
180 | ········expression = result.Simplify(); |
181 | ····} |
182 | |
183 | ····void EqlExpr(out OqlExpression expression) { |
184 | ········OqlExpression child; |
185 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
186 | ········string newOp = null; |
187 | ········bool negated = false; |
188 | ········ |
189 | ········if (!(scanner.Peek().kind==_IN)) { |
190 | ············RelExpr(out child); |
191 | ············result.Add(child); |
192 | ············while (StartOf(1)) { |
193 | ················if (la.kind == 17) { |
194 | ····················Get(); |
195 | ····················newOp = "<>"; |
196 | ················} else if (la.kind == 18) { |
197 | ····················Get(); |
198 | ····················newOp = "<>"; |
199 | ················} else if (la.kind == 19) { |
200 | ····················Get(); |
201 | ····················newOp = "="; |
202 | ····················if (la.kind == 7) { |
203 | ························Get(); |
204 | ························negated = true; |
205 | ····················} |
206 | ················} else { |
207 | ····················Get(); |
208 | ····················newOp = "LIKE"; |
209 | ················} |
210 | ················RelExpr(out child); |
211 | ················if (negated) child.UnaryOp = "NOT"; result.Add(child, newOp); |
212 | ············} |
213 | ········} else if (la.kind == 1) { |
214 | ············Identifier(out child); |
215 | ············result.Add(child); |
216 | ············Expect(15); |
217 | ············Expect(20); |
218 | ············if (la.kind == 2 || la.kind == 3) { |
219 | ················NumList(out child); |
220 | ················child.HasBrackets = true; result.Add(child, "IN"); |
221 | ············} else if (la.kind == 4) { |
222 | ················StringList(out child); |
223 | ················child.HasBrackets = true; result.Add(child, "IN"); |
224 | ············} else SynErr(40); |
225 | ············Expect(21); |
226 | ········} else SynErr(41); |
227 | ········expression = result.Simplify(); |
228 | ····} |
229 | |
230 | ····void RelExpr(out OqlExpression expression) { |
231 | ········OqlExpression child; |
232 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
233 | ········string newOp = null; |
234 | ········bool negated = false; |
235 | ········ |
236 | ········BitOrExpr(out child); |
237 | ········result.Add(child); |
238 | ········if (StartOf(2)) { |
239 | ············if (StartOf(3)) { |
240 | ················switch (la.kind) { |
241 | ················case 22: { |
242 | ····················Get(); |
243 | ····················newOp = "<"; |
244 | ····················break; |
245 | ················} |
246 | ················case 23: { |
247 | ····················Get(); |
248 | ····················newOp = ">"; |
249 | ····················break; |
250 | ················} |
251 | ················case 24: { |
252 | ····················Get(); |
253 | ····················newOp = "<="; |
254 | ····················break; |
255 | ················} |
256 | ················case 25: { |
257 | ····················Get(); |
258 | ····················newOp = ">="; |
259 | ····················break; |
260 | ················} |
261 | ················case 26: { |
262 | ····················Get(); |
263 | ····················newOp = ">="; |
264 | ····················break; |
265 | ················} |
266 | ················case 27: { |
267 | ····················Get(); |
268 | ····················newOp = "<="; |
269 | ····················break; |
270 | ················} |
271 | ················} |
272 | ················BitOrExpr(out child); |
273 | ················result.Add(child, newOp); |
274 | ············} else if (la.kind == 11) { |
275 | ················Get(); |
276 | ················if (la.kind == 7) { |
277 | ····················Get(); |
278 | ····················negated = true; |
279 | ················} |
280 | ················Expect(12); |
281 | ················result.Add(new NamedConstantExpression("NULL", negated, t.line, t.col), "IS"); |
282 | ············} else { |
283 | ················if (la.kind == 7) { |
284 | ····················Get(); |
285 | ····················negated = true; |
286 | ················} |
287 | ················Expect(10); |
288 | ················BitOrExpr(out child); |
289 | ················result.Add(child, "BETWEEN"); |
290 | ················Expect(5); |
291 | ················BitOrExpr(out child); |
292 | ················result.Add(child, "BETWEEN"); |
293 | ············} |
294 | ········} |
295 | ········expression = result.Simplify(); |
296 | ····} |
297 | |
298 | ····void Identifier(out OqlExpression expression) { |
299 | ········OqlExpression result = null; |
300 | ········ |
301 | ········Expect(1); |
302 | ········result = new IdentifierExpression(t.val, t.line, t.col); |
303 | ········expression = result.Simplify(); |
304 | ····} |
305 | |
306 | ····void NumList(out OqlExpression expression) { |
307 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
308 | ········ |
309 | ········if (la.kind == 2) { |
310 | ············Get(); |
311 | ············result.Add(new NumberExpression(double.Parse(t.val, CultureInfo.InvariantCulture ), t.line, t.col)); |
312 | ········} else if (la.kind == 3) { |
313 | ············Get(); |
314 | ············result.Add(new NumberExpression(int.Parse(t.val), t.line, t.col)); |
315 | ········} else SynErr(42); |
316 | ········while (la.kind == 37) { |
317 | ············Get(); |
318 | ············if (la.kind == 2) { |
319 | ················Get(); |
320 | ················result.Add(new NumberExpression(double.Parse(t.val, CultureInfo.InvariantCulture ), t.line, t.col), ","); |
321 | ············} else if (la.kind == 3) { |
322 | ················Get(); |
323 | ················result.Add(new NumberExpression(int.Parse(t.val), t.line, t.col), ","); |
324 | ············} else SynErr(43); |
325 | ········} |
326 | expression = result. Simplify( ) ; |
327 | ····} |
328 | |
329 | ····void StringList(out OqlExpression expression) { |
330 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
331 | ········ |
332 | ········Expect(4); |
333 | ········result.Add(new StringLiteralExpression(t.val, t.line, t.col)); |
334 | ········while (la.kind == 37) { |
335 | ············Get(); |
336 | ············Expect(4); |
337 | ············result.Add(new StringLiteralExpression(t.val, t.line, t.col), ","); |
338 | ········} |
339 | expression = result; /* Do not simplify here, because otherwise the brackets are missing */ |
340 | ····} |
341 | |
342 | ····void BitOrExpr(out OqlExpression expression) { |
343 | ········OqlExpression child; |
344 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
345 | ········ |
346 | ········BitXorExpr(out child); |
347 | ········result.Add(child); |
348 | ········while (la.kind == 28) { |
349 | ············Get(); |
350 | ············BitXorExpr(out child); |
351 | ············result.Add(child, "|"); |
352 | ········} |
353 | ········expression = result.Simplify(); |
354 | ····} |
355 | |
356 | ····void BitXorExpr(out OqlExpression expression) { |
357 | ········OqlExpression child; |
358 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
359 | ········ |
360 | ········BitAndExpr(out child); |
361 | ········result.Add(child); |
362 | ········while (la.kind == 29) { |
363 | ············Get(); |
364 | ············BitAndExpr(out child); |
365 | ············result.Add(child, "^"); |
366 | ········} |
367 | ········expression = result.Simplify(); |
368 | ····} |
369 | |
370 | ····void BitAndExpr(out OqlExpression expression) { |
371 | ········OqlExpression child; |
372 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
373 | ········ |
374 | ········AddExpr(out child); |
375 | ········result.Add(child); |
376 | ········while (la.kind == 30) { |
377 | ············Get(); |
378 | ············AddExpr(out child); |
379 | ············result.Add(child, "&"); |
380 | ········} |
381 | ········expression = result.Simplify(); |
382 | ····} |
383 | |
384 | ····void AddExpr(out OqlExpression expression) { |
385 | ········OqlExpression child; |
386 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
387 | ········string newOp = null; |
388 | ········ |
389 | ········MulExpr(out child); |
390 | ········result.Add(child); |
391 | ········while (la.kind == 31 || la.kind == 32) { |
392 | ············if (la.kind == 31) { |
393 | ················Get(); |
394 | ················newOp = "+"; |
395 | ············} else { |
396 | ················Get(); |
397 | ················newOp = "-"; |
398 | ············} |
399 | ············MulExpr(out child); |
400 | ············result.Add(child, newOp); |
401 | ········} |
402 | ········expression = result.Simplify(); |
403 | ····} |
404 | |
405 | ····void MulExpr(out OqlExpression expression) { |
406 | ········OqlExpression child; |
407 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
408 | ········string newOp = null; |
409 | ········ |
410 | ········Unary(out child); |
411 | ········result.Add(child); |
412 | ········while (StartOf(4)) { |
413 | ············if (la.kind == 33) { |
414 | ················Get(); |
415 | ················newOp = "*"; |
416 | ············} else if (la.kind == 34) { |
417 | ················Get(); |
418 | ················newOp = "/"; |
419 | ············} else if (la.kind == 35) { |
420 | ················Get(); |
421 | ················newOp = "%"; |
422 | ············} else { |
423 | ················Get(); |
424 | ················newOp = "MOD"; |
425 | ············} |
426 | ············Unary(out child); |
427 | ············result.Add(child, newOp); |
428 | ········} |
429 | ········expression = result.Simplify(); |
430 | ····} |
431 | |
432 | ····void Unary(out OqlExpression expression) { |
433 | ········OqlExpression child; |
434 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
435 | ········string newOp = null; |
436 | ········ |
437 | ········if (la.kind == 31 || la.kind == 32 || la.kind == 36) { |
438 | ············if (la.kind == 31) { |
439 | ················Get(); |
440 | ················newOp = "+"; |
441 | ············} else if (la.kind == 32) { |
442 | ················Get(); |
443 | ················newOp = "-"; |
444 | ············} else { |
445 | ················Get(); |
446 | ················newOp = "~"; |
447 | ············} |
448 | ········} |
449 | ········Primary(out child); |
450 | ········result.Add(child); child.UnaryOp = newOp; |
451 | ········expression = result.Simplify(); |
452 | ····} |
453 | |
454 | ····void Primary(out OqlExpression expression) { |
455 | ········OqlExpression result = null; |
456 | ········OqlExpression child; |
457 | ········ |
458 | ········if (la.kind == 1) { |
459 | ············Get(); |
460 | ············result = new IdentifierExpression(t.val, t.line, t.col); |
461 | ············if (la.kind == 20) { |
462 | ················if (IsOidIdentifier(result)) { |
463 | ····················Expect(20); |
464 | ····················Expect(3); |
465 | ····················result.UnaryOp=""; |
466 | ····················result.Add(new IndexExpression(int.Parse(t.val), t.line, t.col)); |
467 | ···················· |
468 | ····················Expect(21); |
469 | ················} else { |
470 | ····················Get(); |
471 | ····················ParameterList(out child); |
472 | ····················result = new FunctionExpression(result.Value, t.line, t.col); |
473 | ····················result.UnaryOp="";························ |
474 | ····················result.Add(child); |
475 | ···················· |
476 | ····················Expect(21); |
477 | ················} |
478 | ············} |
479 | ········} else if (StartOf(5)) { |
480 | ············Literal(out result); |
481 | ········} else if (la.kind == 16) { |
482 | ············Get(); |
483 | ············result = new ParameterExpression(t.val, t.line, t.col); |
484 | ········} else if (la.kind == 20) { |
485 | ············Get(); |
486 | ············RootExpr(out result); |
487 | ············result.HasBrackets = true; |
488 | ············Expect(21); |
489 | ········} else SynErr(44); |
490 | ········expression = result.Simplify(); |
491 | ····} |
492 | |
493 | ····void ParameterList(out OqlExpression expression) { |
494 | ········OqlExpression result = new ParameterListExpression(la.line, la.col); |
495 | ········OqlExpression child; |
496 | ········ |
497 | ········if (StartOf(6)) { |
498 | ············Primary(out child); |
499 | ············result.Add(child); |
500 | ············while (la.kind == 37) { |
501 | ················Get(); |
502 | ················Primary(out child); |
503 | ················result.Add(child, ","); |
504 | ············} |
505 | ········} |
506 | ········expression = result; /* Do not simplify here, because otherwise the brackets are missing */ |
507 | ····} |
508 | |
509 | ····void Literal(out OqlExpression expression) { |
510 | ········OqlExpression result = null; |
511 | ········ |
512 | ········switch (la.kind) { |
513 | ········case 2: { |
514 | ············Get(); |
515 | ············result = new NumberExpression(double.Parse(t.val, CultureInfo.InvariantCulture ), t.line, t.col); |
516 | ············break; |
517 | ········} |
518 | ········case 3: { |
519 | ············Get(); |
520 | ············result = new NumberExpression(int.Parse(t.val), t.line, t.col); |
521 | ············break; |
522 | ········} |
523 | ········case 4: { |
524 | ············Get(); |
525 | ············result = new StringLiteralExpression(t.val, t.line, t.col); |
526 | ············break; |
527 | ········} |
528 | ········case 13: { |
529 | ············Get(); |
530 | ············result = new NamedConstantExpression("TRUE", t.line, t.col); |
531 | ············break; |
532 | ········} |
533 | ········case 38: { |
534 | ············Get(); |
535 | ············result = new NamedConstantExpression("FALSE", t.line, t.col); |
536 | ············break; |
537 | ········} |
538 | ········case 12: { |
539 | ············Get(); |
540 | ············result = new NamedConstantExpression("NULL", t.line, t.col); |
541 | ············break; |
542 | ········} |
543 | ········default: SynErr(45); break; |
544 | ········} |
545 | ········expression = result.Simplify(); |
546 | ····} |
547 | |
548 | |
549 | |
550 | ····public void Parse() { |
551 | ········la = new Token(); |
552 | ········la.val = "";········ |
553 | ········Get(); |
554 | ········NDOQL(); |
555 | ········Expect(0); |
556 | |
557 | ····} |
558 | ···· |
559 | ····static readonly bool[,] set = { |
560 | ········{T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x}, |
561 | ········{x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,T,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x}, |
562 | ········{x,x,x,x, x,x,x,T, x,x,T,T, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x}, |
563 | ········{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x}, |
564 | ········{x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,T,T, x,x,x,x, x}, |
565 | ········{x,x,T,T, T,x,x,x, x,x,x,x, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x}, |
566 | ········{x,T,T,T, T,x,x,x, x,x,x,x, T,T,x,x, T,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x} |
567 | |
568 | ····}; |
569 | } // end Parser |
570 | |
571 | |
572 | public class Errors { |
573 | ····public int count = 0;····································// number of errors detected |
574 | ····public System.IO.TextWriter errorStream = Console.Out;·· // error messages go to this stream |
575 | ····public string errMsgFormat = "-- line {0} col {1}: {2}"; // 0=line, 1=column, 2=text |
576 | |
577 | ····public virtual void SynErr (int line, int col, int n) { |
578 | ········string s; |
579 | ········switch (n) { |
580 | ············case 0: s = "EOF expected"; break; |
581 | ············case 1: s = "ident expected"; break; |
582 | ············case 2: s = "realCon expected"; break; |
583 | ············case 3: s = "intCon expected"; break; |
584 | ············case 4: s = "stringCon expected"; break; |
585 | ············case 5: s = "AND expected"; break; |
586 | ············case 6: s = "OR expected"; break; |
587 | ············case 7: s = "NOT expected"; break; |
588 | ············case 8: s = "LIKE expected"; break; |
589 | ············case 9: s = "ESCAPE expected"; break; |
590 | ············case 10: s = "BETWEEN expected"; break; |
591 | ············case 11: s = "IS expected"; break; |
592 | ············case 12: s = "NULL expected"; break; |
593 | ············case 13: s = "TRUE expected"; break; |
594 | ············case 14: s = "MOD expected"; break; |
595 | ············case 15: s = "IN expected"; break; |
596 | ············case 16: s = "parameter expected"; break; |
597 | ············case 17: s = "\"!=\" expected"; break; |
598 | ············case 18: s = "\"<>\" expected"; break; |
599 | ············case 19: s = "\"=\" expected"; break; |
600 | ············case 20: s = "\"(\" expected"; break; |
601 | ············case 21: s = "\")\" expected"; break; |
602 | ············case 22: s = "\"<\" expected"; break; |
603 | ············case 23: s = "\">\" expected"; break; |
604 | ············case 24: s = "\"<=\" expected"; break; |
605 | ············case 25: s = "\">=\" expected"; break; |
606 | ············case 26: s = "\"!<\" expected"; break; |
607 | ············case 27: s = "\"!>\" expected"; break; |
608 | ············case 28: s = "\"|\" expected"; break; |
609 | ············case 29: s = "\"^\" expected"; break; |
610 | ············case 30: s = "\"&\" expected"; break; |
611 | ············case 31: s = "\"+\" expected"; break; |
612 | ············case 32: s = "\"-\" expected"; break; |
613 | ············case 33: s = "\"*\" expected"; break; |
614 | ············case 34: s = "\"/\" expected"; break; |
615 | ············case 35: s = "\"%\" expected"; break; |
616 | ············case 36: s = "\"~\" expected"; break; |
617 | ············case 37: s = "\",\" expected"; break; |
618 | ············case 38: s = "\"false\" expected"; break; |
619 | ············case 39: s = "??? expected"; break; |
620 | ············case 40: s = "invalid EqlExpr"; break; |
621 | ············case 41: s = "invalid EqlExpr"; break; |
622 | ············case 42: s = "invalid NumList"; break; |
623 | ············case 43: s = "invalid NumList"; break; |
624 | ············case 44: s = "invalid Primary"; break; |
625 | ············case 45: s = "invalid Literal"; break; |
626 | |
627 | ············default: s = "error " + n; break; |
628 | ········} |
629 | ········errorStream.WriteLine(errMsgFormat, line, col, s); |
630 | ········count++; |
631 | ····} |
632 | |
633 | ····public virtual void SemErr (int line, int col, string s) { |
634 | ········errorStream.WriteLine(errMsgFormat, line, col, s); |
635 | ········count++; |
636 | ····} |
637 | ···· |
638 | ····public virtual void SemErr (string s) { |
639 | ········errorStream.WriteLine(s); |
640 | ········count++; |
641 | ····} |
642 | ···· |
643 | ····public virtual void Warning (int line, int col, string s) { |
644 | ········errorStream.WriteLine(errMsgFormat, line, col, s); |
645 | ····} |
646 | ···· |
647 | ····public virtual void Warning(string s) { |
648 | ········errorStream.WriteLine(s); |
649 | ····} |
650 | } // Errors |
651 | |
652 | |
653 | public class FatalError: Exception { |
654 | ····public FatalError(string m): base(m) {} |
655 | } |
656 | } |
New Commit (397e4c7)
1 | using System.Collections.Generic; |
2 | using System.Text; |
3 | using System.Globalization; |
4 | using NDOql.Expressions; |
5 | |
6 | |
7 | |
8 | // |
9 | // This is generated code. Do not change it directly, change the Parser.frame file and rebuild the grammar. |
10 | // |
11 | |
12 | using System; |
13 | #pragma warning disable 3008, 1591 |
14 | |
15 | namespace NDOql { |
16 | |
17 | |
18 | |
19 | public class Parser { |
20 | ····public const int _EOF = 0; |
21 | ····public const int _ident = 1; |
22 | ····public const int _realCon = 2; |
23 | ····public const int _intCon = 3; |
24 | ····public const int _stringCon = 4; |
25 | ····public const int _AND = 5; |
26 | ····public const int _OR = 6; |
27 | ····public const int _NOT = 7; |
28 | ····public const int _LIKE = 8; |
29 | ····public const int _ESCAPE = 9; |
30 | ····public const int _BETWEEN = 10; |
31 | ····public const int _IS = 11; |
32 | ····public const int _NULL = 12; |
33 | ····public const int _TRUE = 13; |
34 | ····public const int _MOD = 14; |
35 | ····public const int _IN = 15; |
36 | ····public const int _parameter = 16; |
37 | ····public const int maxT = 39; |
38 | |
39 | ····const bool T = true; |
40 | ····const bool x = false; |
41 | ····const int minErrDist = 2; |
42 | ···· |
43 | ····public Scanner scanner; |
44 | ····public Errors··errors; |
45 | |
46 | ····public Token t;····// last recognized token |
47 | ····public Token la;·· // lookahead token |
48 | ····int errDist = minErrDist; |
49 | |
50 | OqlExpression rootExpression; |
51 | public OqlExpression RootExpression |
52 | { |
53 | ····get { return rootExpression; } |
54 | } |
55 | |
56 | |
57 | |
58 | /*------------------------------------------------------------------------* |
59 | *----- SCANNER DESCRIPTION ----------------------------------------------* |
60 | *------------------------------------------------------------------------*/ |
61 | |
62 | |
63 | |
64 | ····public Parser(Scanner scanner) { |
65 | ········this.scanner = scanner; |
66 | ········errors = new Errors(); |
67 | ····} |
68 | |
69 | ····void SynErr (int n) { |
70 | ········if (errDist >= minErrDist) errors.SynErr(la.line, la.col, n); |
71 | ········errDist = 0; |
72 | ····} |
73 | |
74 | ····public void SemErr (string msg) { |
75 | ········if (errDist >= minErrDist) errors.SemErr(t.line, t.col, msg); |
76 | ········errDist = 0; |
77 | ····} |
78 | ···· |
79 | ····void Get () { |
80 | ········for (;;) { |
81 | ············t = la; |
82 | ············la = scanner.Scan(); |
83 | ············if (la.kind <= maxT) { ++errDist; break; } |
84 | |
85 | ············la = t; |
86 | ········} |
87 | ····} |
88 | ···· |
89 | ····void Expect (int n) { |
90 | ········if (la.kind==n) Get(); else { SynErr(n); } |
91 | ····} |
92 | ···· |
93 | ····bool StartOf (int s) { |
94 | ········return set[s, la.kind]; |
95 | ····} |
96 | ···· |
97 | ····void ExpectWeak (int n, int follow) { |
98 | ········if (la.kind == n) Get(); |
99 | ········else { |
100 | ············SynErr(n); |
101 | ············while (!StartOf(follow)) Get(); |
102 | ········} |
103 | ····} |
104 | |
105 | |
106 | ····bool WeakSeparator(int n, int syFol, int repFol) { |
107 | ········int kind = la.kind; |
108 | ········if (kind == n) {Get(); return true;} |
109 | ········else if (StartOf(repFol)) {return false;} |
110 | ········else { |
111 | ············SynErr(n); |
112 | ············while (!(set[syFol, kind] || set[repFol, kind] || set[0, kind])) { |
113 | ················Get(); |
114 | ················kind = la.kind; |
115 | ············} |
116 | ············return StartOf(syFol); |
117 | ········} |
118 | ····} |
119 | |
120 | ····bool IsOidIdentifier(OqlExpression iexp) { |
121 | ········return ((string)iexp.Value).EndsWith("oid"); |
122 | ····} |
123 | |
124 | ···· |
125 | ····void NDOQL() { |
126 | ········RootExpr(out this.rootExpression); |
127 | ····} |
128 | |
129 | ····void RootExpr(out OqlExpression expression) { |
130 | ········OqlExpression child; |
131 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
132 | ········bool negated = false; |
133 | ········ |
134 | ········if (la.kind == 7) { |
135 | ············Get(); |
136 | ············negated = true; |
137 | ········} |
138 | ········OrExpr(out child); |
139 | ········if (negated) result.UnaryOp = "NOT"; |
140 | ········result.Add(child); |
141 | ········expression = result.Simplify(); |
142 | ········ |
143 | ····} |
144 | |
145 | ····void OrExpr(out OqlExpression expression) { |
146 | ········OqlExpression child; |
147 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
148 | ········ |
149 | ········AndExpr(out child); |
150 | ········result.Add(child); |
151 | ········while (la.kind == 6) { |
152 | ············Get(); |
153 | ············bool negated = false; |
154 | ············if (la.kind == 7) { |
155 | ················Get(); |
156 | ················negated = true; |
157 | ············} |
158 | ············AndExpr(out child); |
159 | ············if (negated) child.UnaryOp = "NOT"; result.Add(child, "OR"); |
160 | ········} |
161 | ········expression = result.Simplify(); |
162 | ····} |
163 | |
164 | ····void AndExpr(out OqlExpression expression) { |
165 | ········OqlExpression child; |
166 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
167 | ········ |
168 | ········EqlExpr(out child); |
169 | ········result.Add(child); |
170 | ········while (la.kind == 5) { |
171 | ············Get(); |
172 | ············bool negated = false; |
173 | ············if (la.kind == 7) { |
174 | ················Get(); |
175 | ················negated = true; |
176 | ············} |
177 | ············EqlExpr(out child); |
178 | ············if (negated) child.UnaryOp = "NOT"; result.Add(child, "AND"); |
179 | ········} |
180 | ········expression = result.Simplify(); |
181 | ····} |
182 | |
183 | ····void EqlExpr(out OqlExpression expression) { |
184 | ········OqlExpression child; |
185 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
186 | ········string newOp = null; |
187 | ········bool negated = false; |
188 | ········ |
189 | ········if (!(scanner.Peek().kind==_IN)) { |
190 | ············RelExpr(out child); |
191 | ············result.Add(child); |
192 | ············while (StartOf(1)) { |
193 | ················if (la.kind == 17) { |
194 | ····················Get(); |
195 | ····················newOp = "<>"; |
196 | ················} else if (la.kind == 18) { |
197 | ····················Get(); |
198 | ····················newOp = "<>"; |
199 | ················} else if (la.kind == 19) { |
200 | ····················Get(); |
201 | ····················newOp = "="; |
202 | ····················if (la.kind == 7) { |
203 | ························Get(); |
204 | ························negated = true; |
205 | ····················} |
206 | ················} else { |
207 | ····················Get(); |
208 | ····················newOp = "LIKE"; |
209 | ················} |
210 | ················RelExpr(out child); |
211 | ················if (negated) child.UnaryOp = "NOT"; result.Add(child, newOp); |
212 | ············} |
213 | ········} else if (la.kind == 1) { |
214 | ············Identifier(out child); |
215 | ············result.Add(child); |
216 | ············Expect(15); |
217 | ············Expect(20); |
218 | ············if (la.kind == 2 || la.kind == 3) { |
219 | ················NumList(out child); |
220 | ················child.HasBrackets = true; result.Add(child, "IN"); |
221 | ············} else if (la.kind == 4) { |
222 | ················StringList(out child); |
223 | ················child.HasBrackets = true; result.Add(child, "IN"); |
224 | ············} else SynErr(40); |
225 | ············Expect(21); |
226 | ········} else SynErr(41); |
227 | ········expression = result.Simplify(); |
228 | ····} |
229 | |
230 | ····void RelExpr(out OqlExpression expression) { |
231 | ········OqlExpression child; |
232 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
233 | ········string newOp = null; |
234 | ········bool negated = false; |
235 | ········ |
236 | ········BitOrExpr(out child); |
237 | ········result.Add(child); |
238 | ········if (StartOf(2)) { |
239 | ············if (StartOf(3)) { |
240 | ················switch (la.kind) { |
241 | ················case 22: { |
242 | ····················Get(); |
243 | ····················newOp = "<"; |
244 | ····················break; |
245 | ················} |
246 | ················case 23: { |
247 | ····················Get(); |
248 | ····················newOp = ">"; |
249 | ····················break; |
250 | ················} |
251 | ················case 24: { |
252 | ····················Get(); |
253 | ····················newOp = "<="; |
254 | ····················break; |
255 | ················} |
256 | ················case 25: { |
257 | ····················Get(); |
258 | ····················newOp = ">="; |
259 | ····················break; |
260 | ················} |
261 | ················case 26: { |
262 | ····················Get(); |
263 | ····················newOp = ">="; |
264 | ····················break; |
265 | ················} |
266 | ················case 27: { |
267 | ····················Get(); |
268 | ····················newOp = "<="; |
269 | ····················break; |
270 | ················} |
271 | ················} |
272 | ················BitOrExpr(out child); |
273 | ················result.Add(child, newOp); |
274 | ············} else if (la.kind == 11) { |
275 | ················Get(); |
276 | ················if (la.kind == 7) { |
277 | ····················Get(); |
278 | ····················negated = true; |
279 | ················} |
280 | ················Expect(12); |
281 | ················result.Add(new NamedConstantExpression("NULL", negated, t.line, t.col), "IS"); |
282 | ············} else { |
283 | ················if (la.kind == 7) { |
284 | ····················Get(); |
285 | ····················negated = true; |
286 | ················} |
287 | ················Expect(10); |
288 | ················BitOrExpr(out child); |
289 | ················result.Add(child, "BETWEEN"); |
290 | ················Expect(5); |
291 | ················BitOrExpr(out child); |
292 | ················result.Add(child, "BETWEEN"); |
293 | ············} |
294 | ········} |
295 | ········expression = result.Simplify(); |
296 | ····} |
297 | |
298 | ····void Identifier(out OqlExpression expression) { |
299 | ········OqlExpression result = null; |
300 | ········ |
301 | ········Expect(1); |
302 | ········result = new IdentifierExpression(t.val, t.line, t.col); |
303 | ········expression = result.Simplify(); |
304 | ····} |
305 | |
306 | ····void NumList(out OqlExpression expression) { |
307 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
308 | ········ |
309 | ········if (la.kind == 2) { |
310 | ············Get(); |
311 | ············result.Add(new NumberExpression(double.Parse(t.val, CultureInfo.InvariantCulture ), t.line, t.col)); |
312 | ········} else if (la.kind == 3) { |
313 | ············Get(); |
314 | ············result.Add(new NumberExpression(int.Parse(t.val), t.line, t.col)); |
315 | ········} else SynErr(42); |
316 | ········while (la.kind == 37) { |
317 | ············Get(); |
318 | ············if (la.kind == 2) { |
319 | ················Get(); |
320 | ················result.Add(new NumberExpression(double.Parse(t.val, CultureInfo.InvariantCulture ), t.line, t.col), ","); |
321 | ············} else if (la.kind == 3) { |
322 | ················Get(); |
323 | ················result.Add(new NumberExpression(int.Parse(t.val), t.line, t.col), ","); |
324 | ············} else SynErr(43); |
325 | ········} |
326 | expression = result; |
327 | ····} |
328 | |
329 | ····void StringList(out OqlExpression expression) { |
330 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
331 | ········ |
332 | ········Expect(4); |
333 | ········result.Add(new StringLiteralExpression(t.val, t.line, t.col)); |
334 | ········while (la.kind == 37) { |
335 | ············Get(); |
336 | ············Expect(4); |
337 | ············result.Add(new StringLiteralExpression(t.val, t.line, t.col), ","); |
338 | ········} |
339 | expression = result; |
340 | ····} |
341 | |
342 | ····void BitOrExpr(out OqlExpression expression) { |
343 | ········OqlExpression child; |
344 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
345 | ········ |
346 | ········BitXorExpr(out child); |
347 | ········result.Add(child); |
348 | ········while (la.kind == 28) { |
349 | ············Get(); |
350 | ············BitXorExpr(out child); |
351 | ············result.Add(child, "|"); |
352 | ········} |
353 | ········expression = result.Simplify(); |
354 | ····} |
355 | |
356 | ····void BitXorExpr(out OqlExpression expression) { |
357 | ········OqlExpression child; |
358 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
359 | ········ |
360 | ········BitAndExpr(out child); |
361 | ········result.Add(child); |
362 | ········while (la.kind == 29) { |
363 | ············Get(); |
364 | ············BitAndExpr(out child); |
365 | ············result.Add(child, "^"); |
366 | ········} |
367 | ········expression = result.Simplify(); |
368 | ····} |
369 | |
370 | ····void BitAndExpr(out OqlExpression expression) { |
371 | ········OqlExpression child; |
372 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
373 | ········ |
374 | ········AddExpr(out child); |
375 | ········result.Add(child); |
376 | ········while (la.kind == 30) { |
377 | ············Get(); |
378 | ············AddExpr(out child); |
379 | ············result.Add(child, "&"); |
380 | ········} |
381 | ········expression = result.Simplify(); |
382 | ····} |
383 | |
384 | ····void AddExpr(out OqlExpression expression) { |
385 | ········OqlExpression child; |
386 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
387 | ········string newOp = null; |
388 | ········ |
389 | ········MulExpr(out child); |
390 | ········result.Add(child); |
391 | ········while (la.kind == 31 || la.kind == 32) { |
392 | ············if (la.kind == 31) { |
393 | ················Get(); |
394 | ················newOp = "+"; |
395 | ············} else { |
396 | ················Get(); |
397 | ················newOp = "-"; |
398 | ············} |
399 | ············MulExpr(out child); |
400 | ············result.Add(child, newOp); |
401 | ········} |
402 | ········expression = result.Simplify(); |
403 | ····} |
404 | |
405 | ····void MulExpr(out OqlExpression expression) { |
406 | ········OqlExpression child; |
407 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
408 | ········string newOp = null; |
409 | ········ |
410 | ········Unary(out child); |
411 | ········result.Add(child); |
412 | ········while (StartOf(4)) { |
413 | ············if (la.kind == 33) { |
414 | ················Get(); |
415 | ················newOp = "*"; |
416 | ············} else if (la.kind == 34) { |
417 | ················Get(); |
418 | ················newOp = "/"; |
419 | ············} else if (la.kind == 35) { |
420 | ················Get(); |
421 | ················newOp = "%"; |
422 | ············} else { |
423 | ················Get(); |
424 | ················newOp = "MOD"; |
425 | ············} |
426 | ············Unary(out child); |
427 | ············result.Add(child, newOp); |
428 | ········} |
429 | ········expression = result.Simplify(); |
430 | ····} |
431 | |
432 | ····void Unary(out OqlExpression expression) { |
433 | ········OqlExpression child; |
434 | ········OqlExpression result = new OqlExpression(la.line, la.col); |
435 | ········string newOp = null; |
436 | ········ |
437 | ········if (la.kind == 31 || la.kind == 32 || la.kind == 36) { |
438 | ············if (la.kind == 31) { |
439 | ················Get(); |
440 | ················newOp = "+"; |
441 | ············} else if (la.kind == 32) { |
442 | ················Get(); |
443 | ················newOp = "-"; |
444 | ············} else { |
445 | ················Get(); |
446 | ················newOp = "~"; |
447 | ············} |
448 | ········} |
449 | ········Primary(out child); |
450 | ········result.Add(child); child.UnaryOp = newOp; |
451 | ········expression = result.Simplify(); |
452 | ····} |
453 | |
454 | ····void Primary(out OqlExpression expression) { |
455 | ········OqlExpression result = null; |
456 | ········OqlExpression child; |
457 | ········ |
458 | ········if (la.kind == 1) { |
459 | ············Get(); |
460 | ············result = new IdentifierExpression(t.val, t.line, t.col); |
461 | ············if (la.kind == 20) { |
462 | ················if (IsOidIdentifier(result)) { |
463 | ····················Expect(20); |
464 | ····················Expect(3); |
465 | ····················result.UnaryOp=""; |
466 | ····················result.Add(new IndexExpression(int.Parse(t.val), t.line, t.col)); |
467 | ···················· |
468 | ····················Expect(21); |
469 | ················} else { |
470 | ····················Get(); |
471 | ····················ParameterList(out child); |
472 | ····················result = new FunctionExpression(result.Value, t.line, t.col); |
473 | ····················result.UnaryOp="";························ |
474 | ····················result.Add(child); |
475 | ···················· |
476 | ····················Expect(21); |
477 | ················} |
478 | ············} |
479 | ········} else if (StartOf(5)) { |
480 | ············Literal(out result); |
481 | ········} else if (la.kind == 16) { |
482 | ············Get(); |
483 | ············result = new ParameterExpression(t.val, t.line, t.col); |
484 | ········} else if (la.kind == 20) { |
485 | ············Get(); |
486 | ············RootExpr(out result); |
487 | ············result.HasBrackets = true; |
488 | ············Expect(21); |
489 | ········} else SynErr(44); |
490 | ········expression = result.Simplify(); |
491 | ····} |
492 | |
493 | ····void ParameterList(out OqlExpression expression) { |
494 | ········OqlExpression result = new ParameterListExpression(la.line, la.col); |
495 | ········OqlExpression child; |
496 | ········ |
497 | ········if (StartOf(6)) { |
498 | ············Primary(out child); |
499 | ············result.Add(child); |
500 | ············while (la.kind == 37) { |
501 | ················Get(); |
502 | ················Primary(out child); |
503 | ················result.Add(child, ","); |
504 | ············} |
505 | ········} |
506 | ········expression = result; /* Do not simplify here, because otherwise the brackets are missing */ |
507 | ····} |
508 | |
509 | ····void Literal(out OqlExpression expression) { |
510 | ········OqlExpression result = null; |
511 | ········ |
512 | ········switch (la.kind) { |
513 | ········case 2: { |
514 | ············Get(); |
515 | ············result = new NumberExpression(double.Parse(t.val, CultureInfo.InvariantCulture ), t.line, t.col); |
516 | ············break; |
517 | ········} |
518 | ········case 3: { |
519 | ············Get(); |
520 | ············result = new NumberExpression(int.Parse(t.val), t.line, t.col); |
521 | ············break; |
522 | ········} |
523 | ········case 4: { |
524 | ············Get(); |
525 | ············result = new StringLiteralExpression(t.val, t.line, t.col); |
526 | ············break; |
527 | ········} |
528 | ········case 13: { |
529 | ············Get(); |
530 | ············result = new NamedConstantExpression("TRUE", t.line, t.col); |
531 | ············break; |
532 | ········} |
533 | ········case 38: { |
534 | ············Get(); |
535 | ············result = new NamedConstantExpression("FALSE", t.line, t.col); |
536 | ············break; |
537 | ········} |
538 | ········case 12: { |
539 | ············Get(); |
540 | ············result = new NamedConstantExpression("NULL", t.line, t.col); |
541 | ············break; |
542 | ········} |
543 | ········default: SynErr(45); break; |
544 | ········} |
545 | ········expression = result.Simplify(); |
546 | ····} |
547 | |
548 | |
549 | |
550 | ····public void Parse() { |
551 | ········la = new Token(); |
552 | ········la.val = "";········ |
553 | ········Get(); |
554 | ········NDOQL(); |
555 | ········Expect(0); |
556 | |
557 | ····} |
558 | ···· |
559 | ····static readonly bool[,] set = { |
560 | ········{T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x}, |
561 | ········{x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,T,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x}, |
562 | ········{x,x,x,x, x,x,x,T, x,x,T,T, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x}, |
563 | ········{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x}, |
564 | ········{x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,T,T, x,x,x,x, x}, |
565 | ········{x,x,T,T, T,x,x,x, x,x,x,x, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x}, |
566 | ········{x,T,T,T, T,x,x,x, x,x,x,x, T,T,x,x, T,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x} |
567 | |
568 | ····}; |
569 | } // end Parser |
570 | |
571 | |
572 | public class Errors { |
573 | ····public int count = 0;····································// number of errors detected |
574 | ····public System.IO.TextWriter errorStream = Console.Out;·· // error messages go to this stream |
575 | ····public string errMsgFormat = "-- line {0} col {1}: {2}"; // 0=line, 1=column, 2=text |
576 | |
577 | ····public virtual void SynErr (int line, int col, int n) { |
578 | ········string s; |
579 | ········switch (n) { |
580 | ············case 0: s = "EOF expected"; break; |
581 | ············case 1: s = "ident expected"; break; |
582 | ············case 2: s = "realCon expected"; break; |
583 | ············case 3: s = "intCon expected"; break; |
584 | ············case 4: s = "stringCon expected"; break; |
585 | ············case 5: s = "AND expected"; break; |
586 | ············case 6: s = "OR expected"; break; |
587 | ············case 7: s = "NOT expected"; break; |
588 | ············case 8: s = "LIKE expected"; break; |
589 | ············case 9: s = "ESCAPE expected"; break; |
590 | ············case 10: s = "BETWEEN expected"; break; |
591 | ············case 11: s = "IS expected"; break; |
592 | ············case 12: s = "NULL expected"; break; |
593 | ············case 13: s = "TRUE expected"; break; |
594 | ············case 14: s = "MOD expected"; break; |
595 | ············case 15: s = "IN expected"; break; |
596 | ············case 16: s = "parameter expected"; break; |
597 | ············case 17: s = "\"!=\" expected"; break; |
598 | ············case 18: s = "\"<>\" expected"; break; |
599 | ············case 19: s = "\"=\" expected"; break; |
600 | ············case 20: s = "\"(\" expected"; break; |
601 | ············case 21: s = "\")\" expected"; break; |
602 | ············case 22: s = "\"<\" expected"; break; |
603 | ············case 23: s = "\">\" expected"; break; |
604 | ············case 24: s = "\"<=\" expected"; break; |
605 | ············case 25: s = "\">=\" expected"; break; |
606 | ············case 26: s = "\"!<\" expected"; break; |
607 | ············case 27: s = "\"!>\" expected"; break; |
608 | ············case 28: s = "\"|\" expected"; break; |
609 | ············case 29: s = "\"^\" expected"; break; |
610 | ············case 30: s = "\"&\" expected"; break; |
611 | ············case 31: s = "\"+\" expected"; break; |
612 | ············case 32: s = "\"-\" expected"; break; |
613 | ············case 33: s = "\"*\" expected"; break; |
614 | ············case 34: s = "\"/\" expected"; break; |
615 | ············case 35: s = "\"%\" expected"; break; |
616 | ············case 36: s = "\"~\" expected"; break; |
617 | ············case 37: s = "\",\" expected"; break; |
618 | ············case 38: s = "\"false\" expected"; break; |
619 | ············case 39: s = "??? expected"; break; |
620 | ············case 40: s = "invalid EqlExpr"; break; |
621 | ············case 41: s = "invalid EqlExpr"; break; |
622 | ············case 42: s = "invalid NumList"; break; |
623 | ············case 43: s = "invalid NumList"; break; |
624 | ············case 44: s = "invalid Primary"; break; |
625 | ············case 45: s = "invalid Literal"; break; |
626 | |
627 | ············default: s = "error " + n; break; |
628 | ········} |
629 | ········errorStream.WriteLine(errMsgFormat, line, col, s); |
630 | ········count++; |
631 | ····} |
632 | |
633 | ····public virtual void SemErr (int line, int col, string s) { |
634 | ········errorStream.WriteLine(errMsgFormat, line, col, s); |
635 | ········count++; |
636 | ····} |
637 | ···· |
638 | ····public virtual void SemErr (string s) { |
639 | ········errorStream.WriteLine(s); |
640 | ········count++; |
641 | ····} |
642 | ···· |
643 | ····public virtual void Warning (int line, int col, string s) { |
644 | ········errorStream.WriteLine(errMsgFormat, line, col, s); |
645 | ····} |
646 | ···· |
647 | ····public virtual void Warning(string s) { |
648 | ········errorStream.WriteLine(s); |
649 | ····} |
650 | } // Errors |
651 | |
652 | |
653 | public class FatalError: Exception { |
654 | ····public FatalError(string m): base(m) {} |
655 | } |
656 | } |