Datei: NDODLL/NDOql/Parser.cs

Last Commit (28c8c45)

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	····
121	····void NDOQL() {
122	········RootExpr(out this.rootExpression);
123	····}
124
125	····void RootExpr(out OqlExpression expression) {
126	········OqlExpression child;
127	········OqlExpression result = new OqlExpression(la.line, la.col);
128	········bool negated = false;
129	········
130	········if (la.kind == 7) {
131	············Get();
132	············negated = true;
133	········}
134	········OrExpr(out child);
135	········if (negated) result.UnaryOp = "NOT";
136	········result.Add(child);
137	········expression = result.Simplify();
138	········
139	····}
140
141	····void OrExpr(out OqlExpression expression) {
142	········OqlExpression child;
143	········OqlExpression result = new OqlExpression(la.line, la.col);
144	········
145	········AndExpr(out child);
146	········result.Add(child);
147	········while (la.kind == 6) {
148	············Get();
149	············bool negated = false;
150	············if (la.kind == 7) {
151	················Get();
152	················negated = true;
153	············}
154	············AndExpr(out child);
155	············if (negated) child.UnaryOp = "NOT"; result.Add(child, "OR");
156	········}
157	········expression = result.Simplify();
158	····}
159
160	····void AndExpr(out OqlExpression expression) {
161	········OqlExpression child;
162	········OqlExpression result = new OqlExpression(la.line, la.col);
163	········
164	········EqlExpr(out child);
165	········result.Add(child);
166	········while (la.kind == 5) {
167	············Get();
168	············bool negated = false;
169	············if (la.kind == 7) {
170	················Get();
171	················negated = true;
172	············}
173	············EqlExpr(out child);
174	············if (negated) child.UnaryOp = "NOT"; result.Add(child, "AND");
175	········}
176	········expression = result.Simplify();
177	····}
178
179	····void EqlExpr(out OqlExpression expression) {
180	········OqlExpression child;
181	········OqlExpression result = new OqlExpression(la.line, la.col);
182	········string newOp = null;
183	········bool negated = false;
184	········
185	········if (!(scanner.Peek().kind==_IN)) {
186	············RelExpr(out child);
187	············result.Add(child);
188	············while (StartOf(1)) {
189	················if (la.kind == 17) {
190	····················Get();
191	····················newOp = "<>";
192	················} else if (la.kind == 18) {
193	····················Get();
194	····················newOp = "<>";
195	················} else if (la.kind == 19) {
196	····················Get();
197	····················newOp = "=";
198	····················if (la.kind == 7) {
199	························Get();
200	························negated = true;
201	····················}
202	················} else {
203	····················Get();
204	····················newOp = "LIKE";
205	················}
206	················RelExpr(out child);
207	················if (negated) child.UnaryOp = "NOT"; result.Add(child, newOp);
208	············}
209	········} else if (la.kind == 1) {
210	············Identifier(out child);
211	············result.Add(child);
212	············Expect(15);
213	············Expect(20);
214	············if (la.kind == 2 \|\| la.kind == 3) {
215	················NumList(out child);
216	················child.HasBrackets = true; result.Add(child, "IN");
217	············} else if (la.kind == 4) {
218	················StringList(out child);
219	················child.HasBrackets = true; result.Add(child, "IN");
220	············} else SynErr(40);
221	············Expect(21);
222	········} else SynErr(41);
223	········expression = result.Simplify();
224	····}
225
226	····void RelExpr(out OqlExpression expression) {
227	········OqlExpression child;
228	········OqlExpression result = new OqlExpression(la.line, la.col);
229	········string newOp = null;
230	········bool negated = false;
231	········
232	········BitOrExpr(out child);
233	········result.Add(child);
234	········if (StartOf(2)) {
235	············if (StartOf(3)) {
236	················switch (la.kind) {
237	················case 22: {
238	····················Get();
239	····················newOp = "<";
240	····················break;
241	················}
242	················case 23: {
243	····················Get();
244	····················newOp = ">";
245	····················break;
246	················}
247	················case 24: {
248	····················Get();
249	····················newOp = "<=";
250	····················break;
251	················}
252	················case 25: {
253	····················Get();
254	····················newOp = ">=";
255	····················break;
256	················}
257	················case 26: {
258	····················Get();
259	····················newOp = ">=";
260	····················break;
261	················}
262	················case 27: {
263	····················Get();
264	····················newOp = "<=";
265	····················break;
266	················}
267	················}
268	················BitOrExpr(out child);
269	················result.Add(child, newOp);
270	············} else if (la.kind == 11) {
271	················Get();
272	················if (la.kind == 7) {
273	····················Get();
274	····················negated = true;
275	················}
276	················Expect(12);
277	················result.Add(new NamedConstantExpression("NULL", negated, t.line, t.col), "IS");
278	············} else {
279	················if (la.kind == 7) {
280	····················Get();
281	····················negated = true;
282	················}
283	················Expect(10);
284	················BitOrExpr(out child);
285	················result.Add(child, "BETWEEN");
286	················Expect(5);
287	················BitOrExpr(out child);
288	················result.Add(child, "BETWEEN");
289	············}
290	········}
291	········expression = result.Simplify();
292	····}
293
294	····void Identifier(out OqlExpression expression) {
295	········OqlExpression result = null;
296	········
297	········Expect(1);
298	········result = new IdentifierExpression(t.val, t.line, t.col);
299	········expression = result.Simplify();
300	····}
301
302	····void NumList(out OqlExpression expression) {
303	········OqlExpression result = new OqlExpression(la.line, la.col);
304	········
305	········if (la.kind == 2) {
306	············Get();
307	············result.Add(new NumberExpression(double.Parse(t.val, CultureInfo.InvariantCulture ), t.line, t.col));
308	········} else if (la.kind == 3) {
309	············Get();
310	············result.Add(new NumberExpression(int.Parse(t.val), t.line, t.col));
311	········} else SynErr(42);
312	········while (la.kind == 37) {
313	············Get();
314	············if (la.kind == 2) {
315	················Get();
316	················result.Add(new NumberExpression(double.Parse(t.val, CultureInfo.InvariantCulture ), t.line, t.col), ",");
317	············} else if (la.kind == 3) {
318	················Get();
319	················result.Add(new NumberExpression(int.Parse(t.val), t.line, t.col), ",");
320	············} else SynErr(43);
321	········}
322	········expression = result.Simplify();
323	····}
324
325	····void StringList(out OqlExpression expression) {
326	········OqlExpression result = new OqlExpression(la.line, la.col);
327	········
328	········Expect(4);
329	········result.Add(new StringLiteralExpression(t.val, t.line, t.col));
330	········while (la.kind == 37) {
331	············Get();
332	············Expect(4);
333	············result.Add(new StringLiteralExpression(t.val, t.line, t.col), ",");
334	········}
335	········expression = result; /* Do not simplify here, because otherwise the brackets are missing */
336	····}
337
338	····void BitOrExpr(out OqlExpression expression) {
339	········OqlExpression child;
340	········OqlExpression result = new OqlExpression(la.line, la.col);
341	········
342	········BitXorExpr(out child);
343	········result.Add(child);
344	········while (la.kind == 28) {
345	············Get();
346	············BitXorExpr(out child);
347	············result.Add(child, "\|");
348	········}
349	········expression = result.Simplify();
350	····}
351
352	····void BitXorExpr(out OqlExpression expression) {
353	········OqlExpression child;
354	········OqlExpression result = new OqlExpression(la.line, la.col);
355	········
356	········BitAndExpr(out child);
357	········result.Add(child);
358	········while (la.kind == 29) {
359	············Get();
360	············BitAndExpr(out child);
361	············result.Add(child, "^");
362	········}
363	········expression = result.Simplify();
364	····}
365
366	····void BitAndExpr(out OqlExpression expression) {
367	········OqlExpression child;
368	········OqlExpression result = new OqlExpression(la.line, la.col);
369	········
370	········AddExpr(out child);
371	········result.Add(child);
372	········while (la.kind == 30) {
373	············Get();
374	············AddExpr(out child);
375	············result.Add(child, "&");
376	········}
377	········expression = result.Simplify();
378	····}
379
380	····void AddExpr(out OqlExpression expression) {
381	········OqlExpression child;
382	········OqlExpression result = new OqlExpression(la.line, la.col);
383	········string newOp = null;
384	········
385	········MulExpr(out child);
386	········result.Add(child);
387	········while (la.kind == 31 \|\| la.kind == 32) {
388	············if (la.kind == 31) {
389	················Get();
390	················newOp = "+";
391	············} else {
392	················Get();
393	················newOp = "-";
394	············}
395	············MulExpr(out child);
396	············result.Add(child, newOp);
397	········}
398	········expression = result.Simplify();
399	····}
400
401	····void MulExpr(out OqlExpression expression) {
402	········OqlExpression child;
403	········OqlExpression result = new OqlExpression(la.line, la.col);
404	········string newOp = null;
405	········
406	········Unary(out child);
407	········result.Add(child);
408	········while (StartOf(4)) {
409	············if (la.kind == 33) {
410	················Get();
411	················newOp = "*";
412	············} else if (la.kind == 34) {
413	················Get();
414	················newOp = "/";
415	············} else if (la.kind == 35) {
416	················Get();
417	················newOp = "%";
418	············} else {
419	················Get();
420	················newOp = "MOD";
421	············}
422	············Unary(out child);
423	············result.Add(child, newOp);
424	········}
425	········expression = result.Simplify();
426	····}
427
428	····void Unary(out OqlExpression expression) {
429	········OqlExpression child;
430	········OqlExpression result = new OqlExpression(la.line, la.col);
431	········string newOp = null;
432	········
433	········if (la.kind == 31 \|\| la.kind == 32 \|\| la.kind == 36) {
434	············if (la.kind == 31) {
435	················Get();
436	················newOp = "+";
437	············} else if (la.kind == 32) {
438	················Get();
439	················newOp = "-";
440	············} else {
441	················Get();
442	················newOp = "~";
443	············}
444	········}
445	········Primary(out child);
446	········result.Add(child); child.UnaryOp = newOp;
447	········expression = result.Simplify();
448	····}
449
450	····void Primary(out OqlExpression expression) {
451	········OqlExpression result = null;

452	········
453	········if (la.kind == 1) {
454	············Get();
455	············result = new IdentifierExpression(t.val, t.line, t.col);
456	············if (la.kind == 20) {
457	Get( ) ;

458	················Expect(3);
459	result. UnaryOp=""; // Index-Expression has Brackets, so no Op String is necessary
460	················result.Add(new IndexExpression(int.Parse(t.val), t.line, t.col));
461	················
462	················Expect(21);









463	············}
464	········} else if (StartOf(5)) {
465	············Literal(out result);
466	········} else if (la.kind == 16) {
467	············Get();
468	············result = new ParameterExpression(t.val, t.line, t.col);
469	········} else if (la.kind == 20) {
470	············Get();
471	············RootExpr(out result);
472	············result.HasBrackets = true;
473	············Expect(21);
474	········} else SynErr(44);
475	········expression = result.Simplify();
















476	····}
477
478	····void Literal(out OqlExpression expression) {
479	········OqlExpression result = null;
480	········
481	········switch (la.kind) {
482	········case 2: {
483	············Get();
484	············result = new NumberExpression(double.Parse(t.val, CultureInfo.InvariantCulture ), t.line, t.col);
485	············break;
486	········}
487	········case 3: {
488	············Get();
489	············result = new NumberExpression(int.Parse(t.val), t.line, t.col);
490	············break;
491	········}
492	········case 4: {
493	············Get();
494	············result = new StringLiteralExpression(t.val, t.line, t.col);
495	············break;
496	········}
497	········case 13: {
498	············Get();
499	············result = new NamedConstantExpression("TRUE", t.line, t.col);
500	············break;
501	········}
502	········case 38: {
503	············Get();
504	············result = new NamedConstantExpression("FALSE", t.line, t.col);
505	············break;
506	········}
507	········case 12: {
508	············Get();
509	············result = new NamedConstantExpression("NULL", t.line, t.col);
510	············break;
511	········}
512	········default: SynErr(45); break;
513	········}
514	········expression = result.Simplify();
515	····}
516
517
518
519	····public void Parse() {
520	········la = new Token();
521	········la.val = "";········
522	········Get();
523	········NDOQL();
524	········Expect(0);
525
526	····}
527	····
528	····static readonly bool[,] set = {
529	········{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},
530	········{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},
531	········{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},
532	········{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},
533	········{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},
534	{ 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}

535
536	····};
537	} // end Parser
538
539
540	public class Errors {
541	····public int count = 0;····································// number of errors detected
542	····public System.IO.TextWriter errorStream = Console.Out;·· // error messages go to this stream
543	····public string errMsgFormat = "-- line {0} col {1}: {2}"; // 0=line, 1=column, 2=text
544
545	····public virtual void SynErr (int line, int col, int n) {
546	········string s;
547	········switch (n) {
548	············case 0: s = "EOF expected"; break;
549	············case 1: s = "ident expected"; break;
550	············case 2: s = "realCon expected"; break;
551	············case 3: s = "intCon expected"; break;
552	············case 4: s = "stringCon expected"; break;
553	············case 5: s = "AND expected"; break;
554	············case 6: s = "OR expected"; break;
555	············case 7: s = "NOT expected"; break;
556	············case 8: s = "LIKE expected"; break;
557	············case 9: s = "ESCAPE expected"; break;
558	············case 10: s = "BETWEEN expected"; break;
559	············case 11: s = "IS expected"; break;
560	············case 12: s = "NULL expected"; break;
561	············case 13: s = "TRUE expected"; break;
562	············case 14: s = "MOD expected"; break;
563	············case 15: s = "IN expected"; break;
564	············case 16: s = "parameter expected"; break;
565	············case 17: s = "\"!=\" expected"; break;
566	············case 18: s = "\"<>\" expected"; break;
567	············case 19: s = "\"=\" expected"; break;
568	············case 20: s = "\"(\" expected"; break;
569	············case 21: s = "\")\" expected"; break;
570	············case 22: s = "\"<\" expected"; break;
571	············case 23: s = "\">\" expected"; break;
572	············case 24: s = "\"<=\" expected"; break;
573	············case 25: s = "\">=\" expected"; break;
574	············case 26: s = "\"!<\" expected"; break;
575	············case 27: s = "\"!>\" expected"; break;
576	············case 28: s = "\"\|\" expected"; break;
577	············case 29: s = "\"^\" expected"; break;
578	············case 30: s = "\"&\" expected"; break;
579	············case 31: s = "\"+\" expected"; break;
580	············case 32: s = "\"-\" expected"; break;
581	············case 33: s = "\"*\" expected"; break;
582	············case 34: s = "\"/\" expected"; break;
583	············case 35: s = "\"%\" expected"; break;
584	············case 36: s = "\"~\" expected"; break;
585	············case 37: s = "\",\" expected"; break;
586	············case 38: s = "\"false\" expected"; break;
587	············case 39: s = "??? expected"; break;
588	············case 40: s = "invalid EqlExpr"; break;
589	············case 41: s = "invalid EqlExpr"; break;
590	············case 42: s = "invalid NumList"; break;
591	············case 43: s = "invalid NumList"; break;
592	············case 44: s = "invalid Primary"; break;
593	············case 45: s = "invalid Literal"; break;
594
595	············default: s = "error " + n; break;
596	········}
597	········errorStream.WriteLine(errMsgFormat, line, col, s);
598	········count++;
599	····}
600
601	····public virtual void SemErr (int line, int col, string s) {
602	········errorStream.WriteLine(errMsgFormat, line, col, s);
603	········count++;
604	····}
605	····
606	····public virtual void SemErr (string s) {
607	········errorStream.WriteLine(s);
608	········count++;
609	····}
610	····
611	····public virtual void Warning (int line, int col, string s) {
612	········errorStream.WriteLine(errMsgFormat, line, col, s);
613	····}
614	····
615	····public virtual void Warning(string s) {
616	········errorStream.WriteLine(s);
617	····}
618	} // Errors
619
620
621	public class FatalError: Exception {
622	····public FatalError(string m): base(m) {}
623	}
624	}

New Commit (b47b95e)

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	}

Cookie Info