← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/AddIns/Misc/Reports/ICSharpCode.Reports.Core/Project/Expressions/SimpleExpressionEvaluator/Parser/Parser.cs

  • Committer: sk
  • Date: 2011-09-10 05:17:57 UTC
  • Revision ID: halega@halega.com-20110910051757-qfouz1llya9m6boy
4.1.0.7915 Release Candidate 1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/AddIns/Misc/Reports/ICSharpCode.Reports.Core/Project/Expressions/SimpleExpressionEvaluator/Parser/Parser.cs
 
1
// Generated by TinyPG v1.2 available at www.codeproject.com
 
2
 
 
3
using System;
 
4
using System.Collections.Generic;
 
5
 
 
6
namespace SimpleExpressionEvaluator.Parser
 
7
{
 
8
    #region Parser
 
9
 
 
10
    public partial class Parser 
 
11
    {
 
12
        private Scanner scanner;
 
13
        private ParseTree tree;
 
14
        
 
15
        public Parser(Scanner scanner)
 
16
        {
 
17
            this.scanner = scanner;
 
18
        }
 
19
 
 
20
        public ParseTree Parse(string input)
 
21
        {
 
22
            tree = new ParseTree();
 
23
            return Parse(input, tree);
 
24
        }
 
25
 
 
26
        public ParseTree Parse(string input, ParseTree tree)
 
27
        {
 
28
            scanner.Init(input);
 
29
 
 
30
            this.tree = tree;
 
31
            ParseStart(tree);
 
32
            tree.Skipped = scanner.Skipped;
 
33
 
 
34
            return tree;
 
35
        }
 
36
 
 
37
        private void ParseStart(ParseNode parent) // NonTerminalSymbol: Start
 
38
        {
 
39
            Token tok;
 
40
            ParseNode n;
 
41
            ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Start), "Start");
 
42
            parent.Nodes.Add(node);
 
43
 
 
44
 
 
45
             // Concat Rule
 
46
            ParseBooleanExpr(node); // NonTerminal Rule: BooleanExpr
 
47
 
 
48
             // Concat Rule
 
49
            tok = scanner.Scan(TokenType.EOF); // Terminal Rule: EOF
 
50
            if (tok.Type != TokenType.EOF)
 
51
                tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.EOF.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
52
            n = node.CreateNode(tok, tok.ToString() );
 
53
            node.Token.UpdateRange(tok);
 
54
            node.Nodes.Add(n);
 
55
 
 
56
            parent.Token.UpdateRange(node.Token);
 
57
        } // NonTerminalSymbol: Start
 
58
 
 
59
        private void ParseConditional(ParseNode parent) // NonTerminalSymbol: Conditional
 
60
        {
 
61
            Token tok;
 
62
            ParseNode n;
 
63
            ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Conditional), "Conditional");
 
64
            parent.Nodes.Add(node);
 
65
 
 
66
 
 
67
             // Concat Rule
 
68
            tok = scanner.Scan(TokenType.IF); // Terminal Rule: IF
 
69
            if (tok.Type != TokenType.IF)
 
70
                tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.IF.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
71
            n = node.CreateNode(tok, tok.ToString() );
 
72
            node.Token.UpdateRange(tok);
 
73
            node.Nodes.Add(n);
 
74
 
 
75
             // Concat Rule
 
76
            tok = scanner.LookAhead(TokenType.BROPEN); // Option Rule
 
77
            if (tok.Type == TokenType.BROPEN)
 
78
            {
 
79
                tok = scanner.Scan(TokenType.BROPEN); // Terminal Rule: BROPEN
 
80
                if (tok.Type != TokenType.BROPEN)
 
81
                    tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.BROPEN.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
82
                n = node.CreateNode(tok, tok.ToString() );
 
83
                node.Token.UpdateRange(tok);
 
84
                node.Nodes.Add(n);
 
85
            }
 
86
 
 
87
             // Concat Rule
 
88
            ParseBooleanExpr(node); // NonTerminal Rule: BooleanExpr
 
89
 
 
90
             // Concat Rule
 
91
            tok = scanner.LookAhead(TokenType.BRCLOSE); // Option Rule
 
92
            if (tok.Type == TokenType.BRCLOSE)
 
93
            {
 
94
                tok = scanner.Scan(TokenType.BRCLOSE); // Terminal Rule: BRCLOSE
 
95
                if (tok.Type != TokenType.BRCLOSE)
 
96
                    tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.BRCLOSE.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
97
                n = node.CreateNode(tok, tok.ToString() );
 
98
                node.Token.UpdateRange(tok);
 
99
                node.Nodes.Add(n);
 
100
            }
 
101
 
 
102
             // Concat Rule
 
103
            tok = scanner.Scan(TokenType.THEN); // Terminal Rule: THEN
 
104
            if (tok.Type != TokenType.THEN)
 
105
                tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.THEN.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
106
            n = node.CreateNode(tok, tok.ToString() );
 
107
            node.Token.UpdateRange(tok);
 
108
            node.Nodes.Add(n);
 
109
 
 
110
             // Concat Rule
 
111
            ParseBooleanExpr(node); // NonTerminal Rule: BooleanExpr
 
112
 
 
113
             // Concat Rule
 
114
            tok = scanner.LookAhead(TokenType.ELSE); // Option Rule
 
115
            if (tok.Type == TokenType.ELSE)
 
116
            {
 
117
 
 
118
                 // Concat Rule
 
119
                tok = scanner.Scan(TokenType.ELSE); // Terminal Rule: ELSE
 
120
                if (tok.Type != TokenType.ELSE)
 
121
                    tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.ELSE.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
122
                n = node.CreateNode(tok, tok.ToString() );
 
123
                node.Token.UpdateRange(tok);
 
124
                node.Nodes.Add(n);
 
125
 
 
126
                 // Concat Rule
 
127
                ParseBooleanExpr(node); // NonTerminal Rule: BooleanExpr
 
128
            }
 
129
 
 
130
            parent.Token.UpdateRange(node.Token);
 
131
        } // NonTerminalSymbol: Conditional
 
132
 
 
133
        private void ParseIdentifier(ParseNode parent) // NonTerminalSymbol: Identifier
 
134
        {
 
135
            Token tok;
 
136
            ParseNode n;
 
137
            ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Identifier), "Identifier");
 
138
            parent.Nodes.Add(node);
 
139
 
 
140
            tok = scanner.LookAhead(TokenType.IDENTIFIER, TokenType.ARRAYNAME, TokenType.METHODNAME); // Choice Rule
 
141
            switch (tok.Type)
 
142
            { // Choice Rule
 
143
                case TokenType.IDENTIFIER:
 
144
                    tok = scanner.Scan(TokenType.IDENTIFIER); // Terminal Rule: IDENTIFIER
 
145
                    if (tok.Type != TokenType.IDENTIFIER)
 
146
                        tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.IDENTIFIER.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
147
                    n = node.CreateNode(tok, tok.ToString() );
 
148
                    node.Token.UpdateRange(tok);
 
149
                    node.Nodes.Add(n);
 
150
                    break;
 
151
                case TokenType.ARRAYNAME:
 
152
                    ParseArray(node); // NonTerminal Rule: Array
 
153
                    break;
 
154
                case TokenType.METHODNAME:
 
155
                    ParseMethod(node); // NonTerminal Rule: Method
 
156
                    break;
 
157
                default:
 
158
                    tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, 0, tok.StartPos, tok.StartPos, tok.Length));
 
159
                    break;
 
160
            } // Choice Rule
 
161
 
 
162
            parent.Token.UpdateRange(node.Token);
 
163
        } // NonTerminalSymbol: Identifier
 
164
 
 
165
        private void ParseBooleanExpr(ParseNode parent) // NonTerminalSymbol: BooleanExpr
 
166
        {
 
167
            Token tok;
 
168
            ParseNode n;
 
169
            ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.BooleanExpr), "BooleanExpr");
 
170
            parent.Nodes.Add(node);
 
171
 
 
172
 
 
173
             // Concat Rule
 
174
            ParseCompareExpr(node); // NonTerminal Rule: CompareExpr
 
175
 
 
176
             // Concat Rule
 
177
            tok = scanner.LookAhead(TokenType.BOOLEAN); // ZeroOrMore Rule
 
178
            while (tok.Type == TokenType.BOOLEAN)
 
179
            {
 
180
 
 
181
                 // Concat Rule
 
182
                tok = scanner.Scan(TokenType.BOOLEAN); // Terminal Rule: BOOLEAN
 
183
                if (tok.Type != TokenType.BOOLEAN)
 
184
                    tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.BOOLEAN.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
185
                n = node.CreateNode(tok, tok.ToString() );
 
186
                node.Token.UpdateRange(tok);
 
187
                node.Nodes.Add(n);
 
188
 
 
189
                 // Concat Rule
 
190
                ParseCompareExpr(node); // NonTerminal Rule: CompareExpr
 
191
            tok = scanner.LookAhead(TokenType.BOOLEAN); // ZeroOrMore Rule
 
192
            }
 
193
 
 
194
            parent.Token.UpdateRange(node.Token);
 
195
        } // NonTerminalSymbol: BooleanExpr
 
196
 
 
197
        private void ParseCompareExpr(ParseNode parent) // NonTerminalSymbol: CompareExpr
 
198
        {
 
199
            Token tok;
 
200
            ParseNode n;
 
201
            ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.CompareExpr), "CompareExpr");
 
202
            parent.Nodes.Add(node);
 
203
 
 
204
 
 
205
             // Concat Rule
 
206
            ParseAddExpr(node); // NonTerminal Rule: AddExpr
 
207
 
 
208
             // Concat Rule
 
209
            tok = scanner.LookAhead(TokenType.COMPARE); // ZeroOrMore Rule
 
210
            while (tok.Type == TokenType.COMPARE)
 
211
            {
 
212
 
 
213
                 // Concat Rule
 
214
                tok = scanner.Scan(TokenType.COMPARE); // Terminal Rule: COMPARE
 
215
                if (tok.Type != TokenType.COMPARE)
 
216
                    tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.COMPARE.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
217
                n = node.CreateNode(tok, tok.ToString() );
 
218
                node.Token.UpdateRange(tok);
 
219
                node.Nodes.Add(n);
 
220
 
 
221
                 // Concat Rule
 
222
                ParseAddExpr(node); // NonTerminal Rule: AddExpr
 
223
            tok = scanner.LookAhead(TokenType.COMPARE); // ZeroOrMore Rule
 
224
            }
 
225
 
 
226
            parent.Token.UpdateRange(node.Token);
 
227
        } // NonTerminalSymbol: CompareExpr
 
228
 
 
229
        private void ParseAddExpr(ParseNode parent) // NonTerminalSymbol: AddExpr
 
230
        {
 
231
            Token tok;
 
232
            ParseNode n;
 
233
            ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.AddExpr), "AddExpr");
 
234
            parent.Nodes.Add(node);
 
235
 
 
236
 
 
237
             // Concat Rule
 
238
            ParseMultExpr(node); // NonTerminal Rule: MultExpr
 
239
 
 
240
             // Concat Rule
 
241
            tok = scanner.LookAhead(TokenType.PLUSMINUS); // ZeroOrMore Rule
 
242
            while (tok.Type == TokenType.PLUSMINUS)
 
243
            {
 
244
 
 
245
                 // Concat Rule
 
246
                tok = scanner.Scan(TokenType.PLUSMINUS); // Terminal Rule: PLUSMINUS
 
247
                if (tok.Type != TokenType.PLUSMINUS)
 
248
                    tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.PLUSMINUS.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
249
                n = node.CreateNode(tok, tok.ToString() );
 
250
                node.Token.UpdateRange(tok);
 
251
                node.Nodes.Add(n);
 
252
 
 
253
                 // Concat Rule
 
254
                ParseMultExpr(node); // NonTerminal Rule: MultExpr
 
255
            tok = scanner.LookAhead(TokenType.PLUSMINUS); // ZeroOrMore Rule
 
256
            }
 
257
 
 
258
            parent.Token.UpdateRange(node.Token);
 
259
        } // NonTerminalSymbol: AddExpr
 
260
 
 
261
        private void ParseMultExpr(ParseNode parent) // NonTerminalSymbol: MultExpr
 
262
        {
 
263
            Token tok;
 
264
            ParseNode n;
 
265
            ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.MultExpr), "MultExpr");
 
266
            parent.Nodes.Add(node);
 
267
 
 
268
 
 
269
             // Concat Rule
 
270
            ParsePowerExpr(node); // NonTerminal Rule: PowerExpr
 
271
 
 
272
             // Concat Rule
 
273
            tok = scanner.LookAhead(TokenType.MULTDIV); // ZeroOrMore Rule
 
274
            while (tok.Type == TokenType.MULTDIV)
 
275
            {
 
276
 
 
277
                 // Concat Rule
 
278
                tok = scanner.Scan(TokenType.MULTDIV); // Terminal Rule: MULTDIV
 
279
                if (tok.Type != TokenType.MULTDIV)
 
280
                    tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.MULTDIV.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
281
                n = node.CreateNode(tok, tok.ToString() );
 
282
                node.Token.UpdateRange(tok);
 
283
                node.Nodes.Add(n);
 
284
 
 
285
                 // Concat Rule
 
286
                ParsePowerExpr(node); // NonTerminal Rule: PowerExpr
 
287
            tok = scanner.LookAhead(TokenType.MULTDIV); // ZeroOrMore Rule
 
288
            }
 
289
 
 
290
            parent.Token.UpdateRange(node.Token);
 
291
        } // NonTerminalSymbol: MultExpr
 
292
 
 
293
        private void ParsePowerExpr(ParseNode parent) // NonTerminalSymbol: PowerExpr
 
294
        {
 
295
            Token tok;
 
296
            ParseNode n;
 
297
            ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.PowerExpr), "PowerExpr");
 
298
            parent.Nodes.Add(node);
 
299
 
 
300
 
 
301
             // Concat Rule
 
302
            ParseAtom(node); // NonTerminal Rule: Atom
 
303
 
 
304
             // Concat Rule
 
305
            tok = scanner.LookAhead(TokenType.POWER); // ZeroOrMore Rule
 
306
            while (tok.Type == TokenType.POWER)
 
307
            {
 
308
 
 
309
                 // Concat Rule
 
310
                tok = scanner.Scan(TokenType.POWER); // Terminal Rule: POWER
 
311
                if (tok.Type != TokenType.POWER)
 
312
                    tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.POWER.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
313
                n = node.CreateNode(tok, tok.ToString() );
 
314
                node.Token.UpdateRange(tok);
 
315
                node.Nodes.Add(n);
 
316
 
 
317
                 // Concat Rule
 
318
                ParseAtom(node); // NonTerminal Rule: Atom
 
319
            tok = scanner.LookAhead(TokenType.POWER); // ZeroOrMore Rule
 
320
            }
 
321
 
 
322
            parent.Token.UpdateRange(node.Token);
 
323
        } // NonTerminalSymbol: PowerExpr
 
324
 
 
325
        private void ParseParams(ParseNode parent) // NonTerminalSymbol: Params
 
326
        {
 
327
            Token tok;
 
328
            ParseNode n;
 
329
            ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Params), "Params");
 
330
            parent.Nodes.Add(node);
 
331
 
 
332
 
 
333
             // Concat Rule
 
334
            tok = scanner.LookAhead(TokenType.TRUE, TokenType.FALSE, TokenType.NULL, TokenType.INTEGER, TokenType.NUMBER, TokenType.STRING, TokenType.BROPEN, TokenType.IDENTIFIER, TokenType.ARRAYNAME, TokenType.METHODNAME, TokenType.IF, TokenType.UNARY); // Option Rule
 
335
            if (tok.Type == TokenType.TRUE
 
336
                || tok.Type == TokenType.FALSE
 
337
                || tok.Type == TokenType.NULL
 
338
                || tok.Type == TokenType.INTEGER
 
339
                || tok.Type == TokenType.NUMBER
 
340
                || tok.Type == TokenType.STRING
 
341
                || tok.Type == TokenType.BROPEN
 
342
                || tok.Type == TokenType.IDENTIFIER
 
343
                || tok.Type == TokenType.ARRAYNAME
 
344
                || tok.Type == TokenType.METHODNAME
 
345
                || tok.Type == TokenType.IF
 
346
                || tok.Type == TokenType.UNARY)
 
347
            {
 
348
                ParseBooleanExpr(node); // NonTerminal Rule: BooleanExpr
 
349
            }
 
350
 
 
351
             // Concat Rule
 
352
            tok = scanner.LookAhead(TokenType.COMMA); // ZeroOrMore Rule
 
353
            while (tok.Type == TokenType.COMMA)
 
354
            {
 
355
 
 
356
                 // Concat Rule
 
357
                tok = scanner.Scan(TokenType.COMMA); // Terminal Rule: COMMA
 
358
                if (tok.Type != TokenType.COMMA)
 
359
                    tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.COMMA.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
360
                n = node.CreateNode(tok, tok.ToString() );
 
361
                node.Token.UpdateRange(tok);
 
362
                node.Nodes.Add(n);
 
363
 
 
364
                 // Concat Rule
 
365
                ParseBooleanExpr(node); // NonTerminal Rule: BooleanExpr
 
366
            tok = scanner.LookAhead(TokenType.COMMA); // ZeroOrMore Rule
 
367
            }
 
368
 
 
369
            parent.Token.UpdateRange(node.Token);
 
370
        } // NonTerminalSymbol: Params
 
371
 
 
372
        private void ParseMethod(ParseNode parent) // NonTerminalSymbol: Method
 
373
        {
 
374
            Token tok;
 
375
            ParseNode n;
 
376
            ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Method), "Method");
 
377
            parent.Nodes.Add(node);
 
378
 
 
379
 
 
380
             // Concat Rule
 
381
            tok = scanner.Scan(TokenType.METHODNAME); // Terminal Rule: METHODNAME
 
382
            if (tok.Type != TokenType.METHODNAME)
 
383
                tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.METHODNAME.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
384
            n = node.CreateNode(tok, tok.ToString() );
 
385
            node.Token.UpdateRange(tok);
 
386
            node.Nodes.Add(n);
 
387
 
 
388
             // Concat Rule
 
389
            tok = scanner.Scan(TokenType.BROPEN); // Terminal Rule: BROPEN
 
390
            if (tok.Type != TokenType.BROPEN)
 
391
                tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.BROPEN.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
392
            n = node.CreateNode(tok, tok.ToString() );
 
393
            node.Token.UpdateRange(tok);
 
394
            node.Nodes.Add(n);
 
395
 
 
396
             // Concat Rule
 
397
            tok = scanner.LookAhead(TokenType.TRUE, TokenType.FALSE, TokenType.NULL, TokenType.INTEGER, TokenType.NUMBER, TokenType.STRING, TokenType.BROPEN, TokenType.IDENTIFIER, TokenType.ARRAYNAME, TokenType.METHODNAME, TokenType.IF, TokenType.UNARY, TokenType.COMMA); // Option Rule
 
398
            if (tok.Type == TokenType.TRUE
 
399
                || tok.Type == TokenType.FALSE
 
400
                || tok.Type == TokenType.NULL
 
401
                || tok.Type == TokenType.INTEGER
 
402
                || tok.Type == TokenType.NUMBER
 
403
                || tok.Type == TokenType.STRING
 
404
                || tok.Type == TokenType.BROPEN
 
405
                || tok.Type == TokenType.IDENTIFIER
 
406
                || tok.Type == TokenType.ARRAYNAME
 
407
                || tok.Type == TokenType.METHODNAME
 
408
                || tok.Type == TokenType.IF
 
409
                || tok.Type == TokenType.UNARY
 
410
                || tok.Type == TokenType.COMMA)
 
411
            {
 
412
                ParseParams(node); // NonTerminal Rule: Params
 
413
            }
 
414
 
 
415
             // Concat Rule
 
416
            tok = scanner.Scan(TokenType.BRCLOSE); // Terminal Rule: BRCLOSE
 
417
            if (tok.Type != TokenType.BRCLOSE)
 
418
                tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.BRCLOSE.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
419
            n = node.CreateNode(tok, tok.ToString() );
 
420
            node.Token.UpdateRange(tok);
 
421
            node.Nodes.Add(n);
 
422
 
 
423
            parent.Token.UpdateRange(node.Token);
 
424
        } // NonTerminalSymbol: Method
 
425
 
 
426
        private void ParseArray(ParseNode parent) // NonTerminalSymbol: Array
 
427
        {
 
428
            Token tok;
 
429
            ParseNode n;
 
430
            ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Array), "Array");
 
431
            parent.Nodes.Add(node);
 
432
 
 
433
 
 
434
             // Concat Rule
 
435
            tok = scanner.Scan(TokenType.ARRAYNAME); // Terminal Rule: ARRAYNAME
 
436
            if (tok.Type != TokenType.ARRAYNAME)
 
437
                tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.ARRAYNAME.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
438
            n = node.CreateNode(tok, tok.ToString() );
 
439
            node.Token.UpdateRange(tok);
 
440
            node.Nodes.Add(n);
 
441
 
 
442
             // Concat Rule
 
443
            tok = scanner.Scan(TokenType.SBOPEN); // Terminal Rule: SBOPEN
 
444
            if (tok.Type != TokenType.SBOPEN)
 
445
                tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.SBOPEN.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
446
            n = node.CreateNode(tok, tok.ToString() );
 
447
            node.Token.UpdateRange(tok);
 
448
            node.Nodes.Add(n);
 
449
 
 
450
             // Concat Rule
 
451
            ParseBooleanExpr(node); // NonTerminal Rule: BooleanExpr
 
452
 
 
453
             // Concat Rule
 
454
            tok = scanner.Scan(TokenType.SBCLOSE); // Terminal Rule: SBCLOSE
 
455
            if (tok.Type != TokenType.SBCLOSE)
 
456
                tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.SBCLOSE.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
457
            n = node.CreateNode(tok, tok.ToString() );
 
458
            node.Token.UpdateRange(tok);
 
459
            node.Nodes.Add(n);
 
460
 
 
461
            parent.Token.UpdateRange(node.Token);
 
462
        } // NonTerminalSymbol: Array
 
463
 
 
464
        private void ParseQualifiedName(ParseNode parent) // NonTerminalSymbol: QualifiedName
 
465
        {
 
466
            Token tok;
 
467
            ParseNode n;
 
468
            ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.QualifiedName), "QualifiedName");
 
469
            parent.Nodes.Add(node);
 
470
 
 
471
 
 
472
             // Concat Rule
 
473
            ParseIdentifier(node); // NonTerminal Rule: Identifier
 
474
 
 
475
             // Concat Rule
 
476
            tok = scanner.LookAhead(TokenType.DOT); // ZeroOrMore Rule
 
477
            while (tok.Type == TokenType.DOT)
 
478
            {
 
479
 
 
480
                 // Concat Rule
 
481
                tok = scanner.Scan(TokenType.DOT); // Terminal Rule: DOT
 
482
                if (tok.Type != TokenType.DOT)
 
483
                    tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.DOT.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
484
                n = node.CreateNode(tok, tok.ToString() );
 
485
                node.Token.UpdateRange(tok);
 
486
                node.Nodes.Add(n);
 
487
 
 
488
                 // Concat Rule
 
489
                ParseIdentifier(node); // NonTerminal Rule: Identifier
 
490
            tok = scanner.LookAhead(TokenType.DOT); // ZeroOrMore Rule
 
491
            }
 
492
 
 
493
            parent.Token.UpdateRange(node.Token);
 
494
        } // NonTerminalSymbol: QualifiedName
 
495
 
 
496
        private void ParseUnaryExpr(ParseNode parent) // NonTerminalSymbol: UnaryExpr
 
497
        {
 
498
            Token tok;
 
499
            ParseNode n;
 
500
            ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.UnaryExpr), "UnaryExpr");
 
501
            parent.Nodes.Add(node);
 
502
 
 
503
 
 
504
             // Concat Rule
 
505
            tok = scanner.Scan(TokenType.UNARY); // Terminal Rule: UNARY
 
506
            if (tok.Type != TokenType.UNARY)
 
507
                tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.UNARY.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
508
            n = node.CreateNode(tok, tok.ToString() );
 
509
            node.Token.UpdateRange(tok);
 
510
            node.Nodes.Add(n);
 
511
 
 
512
             // Concat Rule
 
513
            ParseAtom(node); // NonTerminal Rule: Atom
 
514
 
 
515
            parent.Token.UpdateRange(node.Token);
 
516
        } // NonTerminalSymbol: UnaryExpr
 
517
 
 
518
        private void ParseAtom(ParseNode parent) // NonTerminalSymbol: Atom
 
519
        {
 
520
            Token tok;
 
521
            ParseNode n;
 
522
            ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Atom), "Atom");
 
523
            parent.Nodes.Add(node);
 
524
 
 
525
            tok = scanner.LookAhead(TokenType.TRUE, TokenType.FALSE, TokenType.NULL, TokenType.INTEGER, TokenType.NUMBER, TokenType.STRING, TokenType.BROPEN, TokenType.IDENTIFIER, TokenType.ARRAYNAME, TokenType.METHODNAME, TokenType.IF, TokenType.UNARY); // Choice Rule
 
526
            switch (tok.Type)
 
527
            { // Choice Rule
 
528
                case TokenType.TRUE:
 
529
                    tok = scanner.Scan(TokenType.TRUE); // Terminal Rule: TRUE
 
530
                    if (tok.Type != TokenType.TRUE)
 
531
                        tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.TRUE.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
532
                    n = node.CreateNode(tok, tok.ToString() );
 
533
                    node.Token.UpdateRange(tok);
 
534
                    node.Nodes.Add(n);
 
535
                    break;
 
536
                case TokenType.FALSE:
 
537
                    tok = scanner.Scan(TokenType.FALSE); // Terminal Rule: FALSE
 
538
                    if (tok.Type != TokenType.FALSE)
 
539
                        tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.FALSE.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
540
                    n = node.CreateNode(tok, tok.ToString() );
 
541
                    node.Token.UpdateRange(tok);
 
542
                    node.Nodes.Add(n);
 
543
                    break;
 
544
                case TokenType.NULL:
 
545
                    tok = scanner.Scan(TokenType.NULL); // Terminal Rule: NULL
 
546
                    if (tok.Type != TokenType.NULL)
 
547
                        tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.NULL.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
548
                    n = node.CreateNode(tok, tok.ToString() );
 
549
                    node.Token.UpdateRange(tok);
 
550
                    node.Nodes.Add(n);
 
551
                    break;
 
552
                case TokenType.INTEGER:
 
553
                    tok = scanner.Scan(TokenType.INTEGER); // Terminal Rule: INTEGER
 
554
                    if (tok.Type != TokenType.INTEGER)
 
555
                        tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.INTEGER.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
556
                    n = node.CreateNode(tok, tok.ToString() );
 
557
                    node.Token.UpdateRange(tok);
 
558
                    node.Nodes.Add(n);
 
559
                    break;
 
560
                case TokenType.NUMBER:
 
561
                    tok = scanner.Scan(TokenType.NUMBER); // Terminal Rule: NUMBER
 
562
                    if (tok.Type != TokenType.NUMBER)
 
563
                        tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.NUMBER.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
564
                    n = node.CreateNode(tok, tok.ToString() );
 
565
                    node.Token.UpdateRange(tok);
 
566
                    node.Nodes.Add(n);
 
567
                    break;
 
568
                case TokenType.STRING:
 
569
                    tok = scanner.Scan(TokenType.STRING); // Terminal Rule: STRING
 
570
                    if (tok.Type != TokenType.STRING)
 
571
                        tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.STRING.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
572
                    n = node.CreateNode(tok, tok.ToString() );
 
573
                    node.Token.UpdateRange(tok);
 
574
                    node.Nodes.Add(n);
 
575
                    break;
 
576
                case TokenType.BROPEN:
 
577
 
 
578
                     // Concat Rule
 
579
                    tok = scanner.Scan(TokenType.BROPEN); // Terminal Rule: BROPEN
 
580
                    if (tok.Type != TokenType.BROPEN)
 
581
                        tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.BROPEN.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
582
                    n = node.CreateNode(tok, tok.ToString() );
 
583
                    node.Token.UpdateRange(tok);
 
584
                    node.Nodes.Add(n);
 
585
 
 
586
                     // Concat Rule
 
587
                    ParseBooleanExpr(node); // NonTerminal Rule: BooleanExpr
 
588
 
 
589
                     // Concat Rule
 
590
                    tok = scanner.Scan(TokenType.BRCLOSE); // Terminal Rule: BRCLOSE
 
591
                    if (tok.Type != TokenType.BRCLOSE)
 
592
                        tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.BRCLOSE.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
 
593
                    n = node.CreateNode(tok, tok.ToString() );
 
594
                    node.Token.UpdateRange(tok);
 
595
                    node.Nodes.Add(n);
 
596
                    break;
 
597
                case TokenType.IDENTIFIER:
 
598
                case TokenType.ARRAYNAME:
 
599
                case TokenType.METHODNAME:
 
600
                    ParseQualifiedName(node); // NonTerminal Rule: QualifiedName
 
601
                    break;
 
602
                case TokenType.IF:
 
603
                    ParseConditional(node); // NonTerminal Rule: Conditional
 
604
                    break;
 
605
                case TokenType.UNARY:
 
606
                    ParseUnaryExpr(node); // NonTerminal Rule: UnaryExpr
 
607
                    break;
 
608
                default:
 
609
                    tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, 0, tok.StartPos, tok.StartPos, tok.Length));
 
610
                    break;
 
611
            } // Choice Rule
 
612
 
 
613
            parent.Token.UpdateRange(node.Token);
 
614
        } // NonTerminalSymbol: Atom
 
615
 
 
616
 
 
617
    }
 
618
 
 
619
    #endregion Parser
 
620
}