← Back to branch summary

~ubuntu-branches/debian/lenny/fpc/lenny

« back to all changes in this revision

Viewing changes to utils/tply/pyacc.pas

  • Committer: Bazaar Package Importer
  • Author(s): Mazen Neifer, Torsten Werner, Mazen Neifer
  • Date: 2008-05-17 17:12:11 UTC
  • mfrom: (3.1.9 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080517171211-9qi33xhd9evfa0kg
Tags: 2.2.0-dfsg1-9
http://bugs.debian.org/477743
[ Torsten Werner ]
* Add Mazen Neifer to Uploaders field.

[ Mazen Neifer ]
* Moved FPC sources into a version dependent directory from /usr/share/fpcsrc
  to /usr/share/fpcsrc/${FPCVERSION}. This allow installing more than on FPC
  release.
* Fixed far call issue in compiler preventing building huge binearies.
  (closes: #477743)
* Updated building dependencies, recomennded and suggested packages.
* Moved fppkg to fp-utils as it is just a helper tool and is not required by
  compiler.

Show diffs side-by-side

added added

removed removed

Lines of Context:
utils/tply/pyacc.pas
1
 
 
2
 
(* Yacc parser template (TP Yacc V3.0), V1.2 6-17-91 AG *)
3
 
 
4
 
(* global definitions: *)
5
 
 
6
 
(*
7
 
 
8
 
  TP Yacc - Yet Another Compiler Compiler for Turbo Pascal
9
 
 
10
 
  Copyright (C) 1990-92  Albert Graef <ag@muwiinfa.geschichte.uni-mainz.de>
11
 
  Copyright (C) 1996     Berend de Boer <berend@pobox.com>
12
 
 
13
 
  This program is free software; you can redistribute it and/or modify
14
 
  it under the terms of the GNU General Public License as published by
15
 
  the Free Software Foundation; either version 2 of the License, or
16
 
  (at your option) any later version.
17
 
 
18
 
  This program is distributed in the hope that it will be useful,
19
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of
20
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21
 
  GNU General Public License for more details.
22
 
 
23
 
  You should have received a copy of the GNU General Public License
24
 
  along with this program; if not, write to the Free Software
25
 
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26
 
 
27
 
 
28
 
$Revision: 1.3 $
29
 
$Modtime: 96-08-01 11:24 $
30
 
 
31
 
 
32
 
Last changes:
33
 
 
34
 
  Version 3.0 as of April 91
35
 
  Version 3.0a as of May 92 (bug fixes in precedence and type information
36
 
    updates)
37
 
 
38
 
$History: YACC.PAS $
39
 
 *
40
 
 * *****************  Version 2  *****************
41
 
 * User: Berend       Date: 96-10-10   Time: 21:16
42
 
 * Updated in $/Lex and Yacc/tply
43
 
 * Updated for protected mode, windows and Delphi 1.X and 2.X.
44
 
 
45
 
 
46
 
 
47
 
------------------------- Synopsis ------------------------
48
 
 
49
 
   Synopsis   yacc [options] yacc-file[.y] [output-file[.pas]]
50
 
 
51
 
   Options
52
 
 
53
 
   -v  "Verbose:" Yacc generates a readable description of the generated
54
 
       parser, written to yacc-file with new extension .lst.
55
 
 
56
 
   -d  "Debug:" Yacc generates parser with debugging output.
57
 
 
58
 
   Description
59
 
 
60
 
   This is a reimplementation of the popular UNIX compiler generator
61
 
   Yacc for MS-DOS and Turbo Pascal.
62
 
 
63
 
   Differences from UNIX Yacc:
64
 
 
65
 
   - Produces output code for Turbo Pascal, rather than for C.
66
 
 
67
 
   - Does not support %union definitions. Instead, a value type is declared
68
 
     by specifying the type identifier *itself* as the tag of a %token
69
 
     or %type definition. Yacc will automatically generate an appropriate
70
 
     yylval variable of a variant record type (YYSType) which is capable of
71
 
     holding values of any of the types used in %token and %type.
72
 
 
73
 
     Type checking is *very* strict. If you use type definitions, then
74
 
     any symbol referred to in an action *must* have a type introduced
75
 
     in a type definition. Either the symbol must have been assigned a
76
 
     type in the definitions section, or the $<type-identifier> notation
77
 
     must be used. The syntax of the %type definition has been changed
78
 
     slightly to allow definitions of the form
79
 
       %type <type-identifier>
80
 
     (omitting the nonterminals) which may be used to declare types which
81
 
     are not assigned to any grammar symbol, but are used with the
82
 
     $<...> construct.
83
 
 
84
 
   - The parse tables constructed by this Yacc version are slightly greater
85
 
     than those constructed by UNIX Yacc, since a reduce action will only be
86
 
     chosen as the default action if it is the *only* action in the state.
87
 
     In difference, UNIX Yacc chooses a reduce action as the default action
88
 
     whenever it is the only *reduce* action of the state (even if there are
89
 
     other shift actions).
90
 
 
91
 
     This solves a bug in UNIX Yacc that makes the generated parser start
92
 
     error recovery too late with certain types of error productions (see
93
 
     also Schreiner/Friedman, "Introduction to compiler construction with
94
 
     UNIX," 1985). Also, errors will be caught sooner in most cases where
95
 
     standard Yacc would carry out an additional (default) reduction before
96
 
     detecting the error.
97
 
 
98
 
------------------------- Synopsis ------------------------
99
 
 
100
 
*)
101
 
 
102
 
{$IFDEF MsDos}
103
 
{$M 16384,0,655360}
104
 
{$ENDIF}
105
 
{$IFDEF DPMI}
106
 
{$M 32768}
107
 
{$ENDIF}
108
 
{$IFDEF Windows}
109
 
{$M 32768,0}
110
 
{$ENDIF}
111
 
 
112
 
{$X+}
113
 
{$I-}
114
 
program Yacc;
115
 
 
116
 
uses
117
 
{$IFDEF Debug}
118
 
{$IFDEF DPMI}
119
 
  YaccChk,
120
 
{$ENDIF}
121
 
{$ENDIF}
122
 
{$IFDEF Windows}
123
 
{$IFNDEF Console}
124
 
  WinCrt,
125
 
{$ENDIF}
126
 
{$ENDIF}
127
 
  YaccLib, YaccBase, YaccMsgs, YaccSem, YaccTabl, YaccPars;
128
 
 
129
 
const ID = 257;
130
 
const C_ID = 258;
131
 
const LITERAL = 259;
132
 
const LITID = 260;
133
 
const NUMBER = 261;
134
 
const PTOKEN = 262;
135
 
const PLEFT = 263;
136
 
const PRIGHT = 264;
137
 
const PNONASSOC = 265;
138
 
const PTYPE = 266;
139
 
const PSTART = 267;
140
 
const PPREC = 268;
141
 
const PP = 269;
142
 
const LCURL = 270;
143
 
const RCURL = 271;
144
 
const ILLEGAL = 272;
145
 
 
146
 
var yylval : YYSType;
147
 
 
148
 
function yylex : Integer; forward;
149
 
 
150
 
function yyparse : Integer;
151
 
 
152
 
var yystate, yysp, yyn : Integer;
153
 
    yys : array [1..yymaxdepth] of Integer;
154
 
    yyv : array [1..yymaxdepth] of YYSType;
155
 
    yyval : YYSType;
156
 
 
157
 
procedure yyaction ( yyruleno : Integer );
158
 
  (* local definitions: *)
159
 
begin
160
 
  (* actions: *)
161
 
  case yyruleno of
162
 
   1 : begin
163
 
         yyval := yyv[yysp-0];
164
 
       end;
165
 
   2 : begin
166
 
         yyval := yyv[yysp-0];
167
 
       end;
168
 
   3 : begin
169
 
         yyval := yyv[yysp-0];
170
 
       end;
171
 
   4 : begin
172
 
         yyval := yyv[yysp-0];
173
 
       end;
174
 
   5 : begin
175
 
         yyval := yyv[yysp-0];
176
 
       end;
177
 
   6 : begin
178
 
         yyerrok;
179
 
       end;
180
 
   7 : begin
181
 
         yyerrok;
182
 
       end;
183
 
   8 : begin
184
 
         yyerrok;
185
 
       end;
186
 
   9 : begin
187
 
         yyerrok;
188
 
       end;
189
 
  10 : begin
190
 
         yyerrok;
191
 
       end;
192
 
  11 : begin
193
 
         yyerrok;
194
 
       end;
195
 
  12 : begin
196
 
         yyval := yyv[yysp-0];
197
 
       end;
198
 
  13 : begin
199
 
         yyerrok;
200
 
       end;
201
 
  14 : begin
202
 
         yyval := yyv[yysp-0];
203
 
       end;
204
 
  15 : begin
205
 
         yyval := yyv[yysp-0];
206
 
       end;
207
 
  16 : begin
208
 
         error(rcurl_expected);
209
 
       end;
210
 
  17 : begin
211
 
         yyval := yyv[yysp-0];
212
 
       end;
213
 
  18 : begin
214
 
         yyerrok;
215
 
       end;
216
 
  19 : begin
217
 
         yyerrok;
218
 
       end;
219
 
  20 : begin
220
 
         yyerrok;
221
 
       end;
222
 
  21 : begin
223
 
         yyval := yyv[yysp-0];
224
 
       end;
225
 
  22 : begin
226
 
         yyval := yyv[yysp-0];
227
 
       end;
228
 
  23 : begin
229
 
         error(rbrace_expected);
230
 
       end;
231
 
  24 : begin
232
 
         yyval := yyv[yysp-0];
233
 
       end;
234
 
  25 : begin
235
 
         yyval := yyv[yysp-0];
236
 
       end;
237
 
  26 : begin
238
 
         error(rangle_expected);
239
 
       end;
240
 
  27 : begin
241
 
         yyval := yyv[yysp-0];
242
 
       end;
243
 
  28 : begin
244
 
         sort_types;
245
 
         definitions;
246
 
         next_section;
247
 
       end;
248
 
  29 : begin
249
 
         next_section;
250
 
         generate_parser;
251
 
         next_section;
252
 
       end;
253
 
  30 : begin
254
 
         yyval := yyv[yysp-5];
255
 
       end;
256
 
  31 : begin
257
 
       end;
258
 
  32 : begin
259
 
         copy_rest_of_file;
260
 
       end;
261
 
  33 : begin
262
 
       end;
263
 
  34 : begin
264
 
         yyerrok;
265
 
       end;
266
 
  35 : begin
267
 
         error(error_in_def);
268
 
       end;
269
 
  36 : begin
270
 
         startnt := ntsym(yyv[yysp-0]);
271
 
       end;
272
 
  37 : begin
273
 
         error(ident_expected);
274
 
       end;
275
 
  38 : begin
276
 
         copy_code;
277
 
       end;
278
 
  39 : begin
279
 
         yyval := yyv[yysp-2];
280
 
       end;
281
 
  40 : begin
282
 
         act_prec := 0;
283
 
       end;
284
 
  41 : begin
285
 
         yyval := yyv[yysp-3];
286
 
       end;
287
 
  42 : begin
288
 
         act_prec := new_prec_level(left);
289
 
       end;
290
 
  43 : begin
291
 
         yyval := yyv[yysp-3];
292
 
       end;
293
 
  44 : begin
294
 
         act_prec := new_prec_level(right);
295
 
       end;
296
 
  45 : begin
297
 
         yyval := yyv[yysp-3];
298
 
       end;
299
 
  46 : begin
300
 
         act_prec := new_prec_level(nonassoc);
301
 
       end;
302
 
  47 : begin
303
 
         yyval := yyv[yysp-3];
304
 
       end;
305
 
  48 : begin
306
 
         yyval := yyv[yysp-2];
307
 
       end;
308
 
  49 : begin
309
 
         yyval := yyv[yysp-1];
310
 
       end;
311
 
  50 : begin
312
 
         act_type := 0;
313
 
       end;
314
 
  51 : begin
315
 
         act_type := yyv[yysp-1]; add_type(yyv[yysp-1]);
316
 
       end;
317
 
  52 : begin
318
 
         yyval := yyv[yysp-0];
319
 
       end;
320
 
  53 : begin
321
 
         yyerrok;
322
 
       end;
323
 
  54 : begin
324
 
         yyerrok;
325
 
       end;
326
 
  55 : begin
327
 
         error(ident_expected);
328
 
       end;
329
 
  56 : begin
330
 
         error(error_in_def);
331
 
       end;
332
 
  57 : begin
333
 
         error(ident_expected);
334
 
       end;
335
 
  58 : begin
336
 
         if act_type<>0 then
337
 
         sym_type^[yyv[yysp-0]] := act_type;
338
 
         if act_prec<>0 then
339
 
         sym_prec^[yyv[yysp-0]] := act_prec;
340
 
       end;
341
 
  59 : begin
342
 
         litsym(yyv[yysp-0], 0);
343
 
         if act_type<>0 then
344
 
         sym_type^[litsym(yyv[yysp-0], 0)] := act_type;
345
 
         if act_prec<>0 then
346
 
         sym_prec^[litsym(yyv[yysp-0], 0)] := act_prec;
347
 
       end;
348
 
  60 : begin
349
 
         litsym(yyv[yysp-0], 0);
350
 
         if act_type<>0 then
351
 
         sym_type^[litsym(yyv[yysp-0], 0)] := act_type;
352
 
         if act_prec<>0 then
353
 
         sym_prec^[litsym(yyv[yysp-0], 0)] := act_prec;
354
 
       end;
355
 
  61 : begin
356
 
         litsym(yyv[yysp-1], 0);
357
 
         if act_type<>0 then
358
 
         sym_type^[litsym(yyv[yysp-1], yyv[yysp-0])] := act_type;
359
 
         if act_prec<>0 then
360
 
         sym_prec^[litsym(yyv[yysp-1], 0)]  := act_prec;
361
 
       end;
362
 
  62 : begin
363
 
         litsym(yyv[yysp-1], 0);
364
 
         if act_type<>0 then
365
 
         sym_type^[litsym(yyv[yysp-1], yyv[yysp-0])] := act_type;
366
 
         if act_prec<>0 then
367
 
         sym_prec^[litsym(yyv[yysp-1], 0)]  := act_prec;
368
 
       end;
369
 
  63 : begin
370
 
         yyval := yyv[yysp-0];
371
 
       end;
372
 
  64 : begin
373
 
         yyerrok;
374
 
       end;
375
 
  65 : begin
376
 
         yyerrok;
377
 
       end;
378
 
  66 : begin
379
 
         error(ident_expected);
380
 
       end;
381
 
  67 : begin
382
 
         error(error_in_def);
383
 
       end;
384
 
  68 : begin
385
 
         error(ident_expected);
386
 
       end;
387
 
  69 : begin
388
 
         if act_type<>0 then
389
 
         sym_type^[ntsym(yyv[yysp-0])] := act_type;
390
 
       end;
391
 
  70 : begin
392
 
         next_section;
393
 
       end;
394
 
  71 : begin
395
 
         yyval := yyv[yysp-1];
396
 
       end;
397
 
  72 : begin
398
 
         copy_code;
399
 
       end;
400
 
  73 : begin
401
 
         next_section;
402
 
       end;
403
 
  74 : begin
404
 
         yyval := yyv[yysp-4];
405
 
       end;
406
 
  75 : begin
407
 
         yyerrok;
408
 
       end;
409
 
  76 : begin
410
 
         error(error_in_rule);
411
 
       end;
412
 
  77 : begin
413
 
         error(error_in_rule);
414
 
       end;
415
 
  78 : begin
416
 
         start_rule(ntsym(yyv[yysp-0]));
417
 
       end;
418
 
  79 : begin
419
 
         start_body;
420
 
       end;
421
 
  80 : begin
422
 
         end_body;
423
 
       end;
424
 
  81 : begin
425
 
         yyval := yyv[yysp-0];
426
 
       end;
427
 
  82 : begin
428
 
         start_body;
429
 
       end;
430
 
  83 : begin
431
 
         end_body;
432
 
       end;
433
 
  84 : begin
434
 
       end;
435
 
  85 : begin
436
 
         add_symbol(yyv[yysp-0]); yyerrok;
437
 
       end;
438
 
  86 : begin
439
 
         add_symbol(sym(yyv[yysp-0])); yyerrok;
440
 
       end;
441
 
  87 : begin
442
 
         add_symbol(sym(yyv[yysp-0])); yyerrok;
443
 
       end;
444
 
  88 : begin
445
 
         add_action; yyerrok;
446
 
       end;
447
 
  89 : begin
448
 
         error(error_in_rule);
449
 
       end;
450
 
  90 : begin
451
 
         copy_action;
452
 
       end;
453
 
  91 : begin
454
 
         yyval := yyv[yysp-2];
455
 
       end;
456
 
  92 : begin
457
 
         copy_single_action;
458
 
       end;
459
 
  93 : begin
460
 
       end;
461
 
  94 : begin
462
 
         add_rule_prec(yyv[yysp-0]);
463
 
       end;
464
 
  95 : begin
465
 
         yyval := yyv[yysp-3];
466
 
       end;
467
 
  96 : begin
468
 
         add_rule_prec(litsym(yyv[yysp-0], 0));
469
 
       end;
470
 
  97 : begin
471
 
         yyval := yyv[yysp-3];
472
 
       end;
473
 
  98 : begin
474
 
         add_rule_prec(litsym(yyv[yysp-0], 0));
475
 
       end;
476
 
  99 : begin
477
 
         yyval := yyv[yysp-3];
478
 
       end;
479
 
 100 : begin
480
 
         yyval := yyv[yysp-1];
481
 
       end;
482
 
 101 : begin
483
 
       end;
484
 
 102 : begin
485
 
         add_action;
486
 
       end;
487
 
  end;
488
 
end(*yyaction*);
489
 
 
490
 
(* parse table: *)
491
 
 
492
 
type YYARec = record
493
 
                sym, act : Integer;
494
 
              end;
495
 
     YYRRec = record
496
 
                len, sym : Integer;
497
 
              end;
498
 
 
499
 
const
500
 
 
501
 
yynacts   = 251;
502
 
yyngotos  = 146;
503
 
yynstates = 128;
504
 
yynrules  = 102;
505
 
 
506
 
yya : array [1..yynacts] of YYARec = (
507
 
{ 0: }
508
 
{ 1: }
509
 
  ( sym: 256; act: 12 ),
510
 
  ( sym: 262; act: 13 ),
511
 
  ( sym: 263; act: 14 ),
512
 
  ( sym: 264; act: 15 ),
513
 
  ( sym: 265; act: 16 ),
514
 
  ( sym: 266; act: 17 ),
515
 
  ( sym: 267; act: 18 ),
516
 
  ( sym: 269; act: 19 ),
517
 
  ( sym: 270; act: 20 ),
518
 
{ 2: }
519
 
  ( sym: 0; act: 0 ),
520
 
{ 3: }
521
 
{ 4: }
522
 
{ 5: }
523
 
{ 6: }
524
 
  ( sym: 256; act: 24 ),
525
 
  ( sym: 257; act: 25 ),
526
 
{ 7: }
527
 
  ( sym: 60; act: 28 ),
528
 
  ( sym: 256; act: -50 ),
529
 
  ( sym: 257; act: -50 ),
530
 
  ( sym: 262; act: -50 ),
531
 
  ( sym: 263; act: -50 ),
532
 
  ( sym: 264; act: -50 ),
533
 
  ( sym: 265; act: -50 ),
534
 
  ( sym: 266; act: -50 ),
535
 
  ( sym: 267; act: -50 ),
536
 
  ( sym: 269; act: -50 ),
537
 
  ( sym: 270; act: -50 ),
538
 
{ 8: }
539
 
{ 9: }
540
 
{ 10: }
541
 
{ 11: }
542
 
{ 12: }
543
 
{ 13: }
544
 
{ 14: }
545
 
{ 15: }
546
 
{ 16: }
547
 
{ 17: }
548
 
{ 18: }
549
 
{ 19: }
550
 
{ 20: }
551
 
{ 21: }
552
 
  ( sym: 256; act: 34 ),
553
 
  ( sym: 271; act: 35 ),
554
 
{ 22: }
555
 
  ( sym: 256; act: 39 ),
556
 
  ( sym: 270; act: 20 ),
557
 
  ( sym: 258; act: -70 ),
558
 
{ 23: }
559
 
{ 24: }
560
 
{ 25: }
561
 
{ 26: }
562
 
  ( sym: 256; act: 43 ),
563
 
  ( sym: 257; act: 25 ),
564
 
  ( sym: 262; act: -49 ),
565
 
  ( sym: 263; act: -49 ),
566
 
  ( sym: 264; act: -49 ),
567
 
  ( sym: 265; act: -49 ),
568
 
  ( sym: 266; act: -49 ),
569
 
  ( sym: 267; act: -49 ),
570
 
  ( sym: 269; act: -49 ),
571
 
  ( sym: 270; act: -49 ),
572
 
{ 27: }
573
 
  ( sym: 257; act: 25 ),
574
 
{ 28: }
575
 
{ 29: }
576
 
  ( sym: 60; act: 28 ),
577
 
  ( sym: 256; act: -50 ),
578
 
  ( sym: 257; act: -50 ),
579
 
  ( sym: 259; act: -50 ),
580
 
  ( sym: 260; act: -50 ),
581
 
{ 30: }
582
 
  ( sym: 60; act: 28 ),
583
 
  ( sym: 256; act: -50 ),
584
 
  ( sym: 257; act: -50 ),
585
 
  ( sym: 259; act: -50 ),
586
 
  ( sym: 260; act: -50 ),
587
 
{ 31: }
588
 
  ( sym: 60; act: 28 ),
589
 
  ( sym: 256; act: -50 ),
590
 
  ( sym: 257; act: -50 ),
591
 
  ( sym: 259; act: -50 ),
592
 
  ( sym: 260; act: -50 ),
593
 
{ 32: }
594
 
  ( sym: 60; act: 28 ),
595
 
  ( sym: 256; act: -50 ),
596
 
  ( sym: 257; act: -50 ),
597
 
  ( sym: 259; act: -50 ),
598
 
  ( sym: 260; act: -50 ),
599
 
{ 33: }
600
 
{ 34: }
601
 
{ 35: }
602
 
{ 36: }
603
 
  ( sym: 258; act: 51 ),
604
 
{ 37: }
605
 
  ( sym: 124; act: 56 ),
606
 
  ( sym: 256; act: 57 ),
607
 
  ( sym: 258; act: 51 ),
608
 
  ( sym: 0; act: -29 ),
609
 
  ( sym: 269; act: -29 ),
610
 
{ 38: }
611
 
{ 39: }
612
 
{ 40: }
613
 
{ 41: }
614
 
  ( sym: 44; act: 61 ),
615
 
  ( sym: 256; act: 62 ),
616
 
  ( sym: 257; act: 25 ),
617
 
  ( sym: 262; act: -48 ),
618
 
  ( sym: 263; act: -48 ),
619
 
  ( sym: 264; act: -48 ),
620
 
  ( sym: 265; act: -48 ),
621
 
  ( sym: 266; act: -48 ),
622
 
  ( sym: 267; act: -48 ),
623
 
  ( sym: 269; act: -48 ),
624
 
  ( sym: 270; act: -48 ),
625
 
{ 42: }
626
 
{ 43: }
627
 
{ 44: }
628
 
  ( sym: 62; act: 64 ),
629
 
  ( sym: 256; act: 65 ),
630
 
{ 45: }
631
 
  ( sym: 256; act: 71 ),
632
 
  ( sym: 257; act: 25 ),
633
 
  ( sym: 259; act: 72 ),
634
 
  ( sym: 260; act: 73 ),
635
 
{ 46: }
636
 
  ( sym: 256; act: 71 ),
637
 
  ( sym: 257; act: 25 ),
638
 
  ( sym: 259; act: 72 ),
639
 
  ( sym: 260; act: 73 ),
640
 
{ 47: }
641
 
  ( sym: 256; act: 71 ),
642
 
  ( sym: 257; act: 25 ),
643
 
  ( sym: 259; act: 72 ),
644
 
  ( sym: 260; act: 73 ),
645
 
{ 48: }
646
 
  ( sym: 256; act: 71 ),
647
 
  ( sym: 257; act: 25 ),
648
 
  ( sym: 259; act: 72 ),
649
 
  ( sym: 260; act: 73 ),
650
 
{ 49: }
651
 
{ 50: }
652
 
{ 51: }
653
 
{ 52: }
654
 
{ 53: }
655
 
{ 54: }
656
 
  ( sym: 269; act: 19 ),
657
 
  ( sym: 0; act: -31 ),
658
 
{ 55: }
659
 
{ 56: }
660
 
{ 57: }
661
 
{ 58: }
662
 
  ( sym: 256; act: 34 ),
663
 
  ( sym: 271; act: 35 ),
664
 
{ 59: }
665
 
{ 60: }
666
 
  ( sym: 256; act: 83 ),
667
 
  ( sym: 257; act: 25 ),
668
 
{ 61: }
669
 
{ 62: }
670
 
{ 63: }
671
 
{ 64: }
672
 
{ 65: }
673
 
{ 66: }
674
 
{ 67: }
675
 
  ( sym: 44; act: 61 ),
676
 
  ( sym: 256; act: 86 ),
677
 
  ( sym: 257; act: 25 ),
678
 
  ( sym: 259; act: 72 ),
679
 
  ( sym: 260; act: 73 ),
680
 
  ( sym: 262; act: -47 ),
681
 
  ( sym: 263; act: -47 ),
682
 
  ( sym: 264; act: -47 ),
683
 
  ( sym: 265; act: -47 ),
684
 
  ( sym: 266; act: -47 ),
685
 
  ( sym: 267; act: -47 ),
686
 
  ( sym: 269; act: -47 ),
687
 
  ( sym: 270; act: -47 ),
688
 
{ 68: }
689
 
  ( sym: 261; act: 88 ),
690
 
  ( sym: 44; act: -59 ),
691
 
  ( sym: 256; act: -59 ),
692
 
  ( sym: 257; act: -59 ),
693
 
  ( sym: 259; act: -59 ),
694
 
  ( sym: 260; act: -59 ),
695
 
  ( sym: 262; act: -59 ),
696
 
  ( sym: 263; act: -59 ),
697
 
  ( sym: 264; act: -59 ),
698
 
  ( sym: 265; act: -59 ),
699
 
  ( sym: 266; act: -59 ),
700
 
  ( sym: 267; act: -59 ),
701
 
  ( sym: 269; act: -59 ),
702
 
  ( sym: 270; act: -59 ),
703
 
{ 69: }
704
 
{ 70: }
705
 
  ( sym: 261; act: 88 ),
706
 
  ( sym: 44; act: -60 ),
707
 
  ( sym: 256; act: -60 ),
708
 
  ( sym: 257; act: -60 ),
709
 
  ( sym: 259; act: -60 ),
710
 
  ( sym: 260; act: -60 ),
711
 
  ( sym: 262; act: -60 ),
712
 
  ( sym: 263; act: -60 ),
713
 
  ( sym: 264; act: -60 ),
714
 
  ( sym: 265; act: -60 ),
715
 
  ( sym: 266; act: -60 ),
716
 
  ( sym: 267; act: -60 ),
717
 
  ( sym: 269; act: -60 ),
718
 
  ( sym: 270; act: -60 ),
719
 
{ 71: }
720
 
{ 72: }
721
 
{ 73: }
722
 
{ 74: }
723
 
  ( sym: 44; act: 61 ),
724
 
  ( sym: 256; act: 86 ),
725
 
  ( sym: 257; act: 25 ),
726
 
  ( sym: 259; act: 72 ),
727
 
  ( sym: 260; act: 73 ),
728
 
  ( sym: 262; act: -45 ),
729
 
  ( sym: 263; act: -45 ),
730
 
  ( sym: 264; act: -45 ),
731
 
  ( sym: 265; act: -45 ),
732
 
  ( sym: 266; act: -45 ),
733
 
  ( sym: 267; act: -45 ),
734
 
  ( sym: 269; act: -45 ),
735
 
  ( sym: 270; act: -45 ),
736
 
{ 75: }
737
 
  ( sym: 44; act: 61 ),
738
 
  ( sym: 256; act: 86 ),
739
 
  ( sym: 257; act: 25 ),
740
 
  ( sym: 259; act: 72 ),
741
 
  ( sym: 260; act: 73 ),
742
 
  ( sym: 262; act: -43 ),
743
 
  ( sym: 263; act: -43 ),
744
 
  ( sym: 264; act: -43 ),
745
 
  ( sym: 265; act: -43 ),
746
 
  ( sym: 266; act: -43 ),
747
 
  ( sym: 267; act: -43 ),
748
 
  ( sym: 269; act: -43 ),
749
 
  ( sym: 270; act: -43 ),
750
 
{ 76: }
751
 
  ( sym: 44; act: 61 ),
752
 
  ( sym: 256; act: 86 ),
753
 
  ( sym: 257; act: 25 ),
754
 
  ( sym: 259; act: 72 ),
755
 
  ( sym: 260; act: 73 ),
756
 
  ( sym: 262; act: -41 ),
757
 
  ( sym: 263; act: -41 ),
758
 
  ( sym: 264; act: -41 ),
759
 
  ( sym: 265; act: -41 ),
760
 
  ( sym: 266; act: -41 ),
761
 
  ( sym: 267; act: -41 ),
762
 
  ( sym: 269; act: -41 ),
763
 
  ( sym: 270; act: -41 ),
764
 
{ 77: }
765
 
  ( sym: 58; act: 91 ),
766
 
{ 78: }
767
 
{ 79: }
768
 
{ 80: }
769
 
{ 81: }
770
 
{ 82: }
771
 
{ 83: }
772
 
{ 84: }
773
 
{ 85: }
774
 
  ( sym: 256; act: 95 ),
775
 
  ( sym: 257; act: 25 ),
776
 
  ( sym: 259; act: 72 ),
777
 
  ( sym: 260; act: 73 ),
778
 
{ 86: }
779
 
{ 87: }
780
 
{ 88: }
781
 
{ 89: }
782
 
{ 90: }
783
 
{ 91: }
784
 
{ 92: }
785
 
  ( sym: 61; act: 105 ),
786
 
  ( sym: 123; act: 106 ),
787
 
  ( sym: 256; act: 107 ),
788
 
  ( sym: 257; act: 25 ),
789
 
  ( sym: 259; act: 72 ),
790
 
  ( sym: 260; act: 73 ),
791
 
  ( sym: 268; act: 108 ),
792
 
  ( sym: 0; act: -93 ),
793
 
  ( sym: 59; act: -93 ),
794
 
  ( sym: 124; act: -93 ),
795
 
  ( sym: 258; act: -93 ),
796
 
  ( sym: 269; act: -93 ),
797
 
{ 93: }
798
 
  ( sym: 258; act: 51 ),
799
 
{ 94: }
800
 
{ 95: }
801
 
{ 96: }
802
 
{ 97: }
803
 
{ 98: }
804
 
  ( sym: 59; act: 112 ),
805
 
  ( sym: 0; act: -83 ),
806
 
  ( sym: 124; act: -83 ),
807
 
  ( sym: 256; act: -83 ),
808
 
  ( sym: 258; act: -83 ),
809
 
  ( sym: 269; act: -83 ),
810
 
{ 99: }
811
 
{ 100: }
812
 
{ 101: }
813
 
  ( sym: 257; act: 25 ),
814
 
  ( sym: 259; act: 72 ),
815
 
  ( sym: 260; act: 73 ),
816
 
{ 102: }
817
 
{ 103: }
818
 
{ 104: }
819
 
{ 105: }
820
 
{ 106: }
821
 
{ 107: }
822
 
{ 108: }
823
 
{ 109: }
824
 
{ 110: }
825
 
  ( sym: 61; act: 105 ),
826
 
  ( sym: 123; act: 106 ),
827
 
  ( sym: 256; act: 107 ),
828
 
  ( sym: 257; act: 25 ),
829
 
  ( sym: 259; act: 72 ),
830
 
  ( sym: 260; act: 73 ),
831
 
  ( sym: 268; act: 108 ),
832
 
  ( sym: 0; act: -93 ),
833
 
  ( sym: 59; act: -93 ),
834
 
  ( sym: 124; act: -93 ),
835
 
  ( sym: 258; act: -93 ),
836
 
  ( sym: 269; act: -93 ),
837
 
{ 111: }
838
 
{ 112: }
839
 
{ 113: }
840
 
  ( sym: 125; act: 119 ),
841
 
  ( sym: 256; act: 120 ),
842
 
{ 114: }
843
 
{ 115: }
844
 
{ 116: }
845
 
{ 117: }
846
 
  ( sym: 59; act: 112 ),
847
 
  ( sym: 0; act: -80 ),
848
 
  ( sym: 124; act: -80 ),
849
 
  ( sym: 256; act: -80 ),
850
 
  ( sym: 258; act: -80 ),
851
 
  ( sym: 269; act: -80 ),
852
 
{ 118: }
853
 
{ 119: }
854
 
{ 120: }
855
 
{ 121: }
856
 
  ( sym: 61; act: 105 ),
857
 
  ( sym: 123; act: 106 ),
858
 
  ( sym: 0; act: -101 ),
859
 
  ( sym: 59; act: -101 ),
860
 
  ( sym: 124; act: -101 ),
861
 
  ( sym: 256; act: -101 ),
862
 
  ( sym: 258; act: -101 ),
863
 
  ( sym: 269; act: -101 ),
864
 
{ 122: }
865
 
  ( sym: 61; act: 105 ),
866
 
  ( sym: 123; act: 106 ),
867
 
  ( sym: 0; act: -101 ),
868
 
  ( sym: 59; act: -101 ),
869
 
  ( sym: 124; act: -101 ),
870
 
  ( sym: 256; act: -101 ),
871
 
  ( sym: 258; act: -101 ),
872
 
  ( sym: 269; act: -101 ),
873
 
{ 123: }
874
 
  ( sym: 61; act: 105 ),
875
 
  ( sym: 123; act: 106 ),
876
 
  ( sym: 0; act: -101 ),
877
 
  ( sym: 59; act: -101 ),
878
 
  ( sym: 124; act: -101 ),
879
 
  ( sym: 256; act: -101 ),
880
 
  ( sym: 258; act: -101 ),
881
 
  ( sym: 269; act: -101 )
882
 
{ 124: }
883
 
{ 125: }
884
 
{ 126: }
885
 
{ 127: }
886
 
);
887
 
 
888
 
yyg : array [1..yyngotos] of YYARec = (
889
 
{ 0: }
890
 
  ( sym: -27; act: 1 ),
891
 
  ( sym: -2; act: 2 ),
892
 
{ 1: }
893
 
  ( sym: -32; act: 3 ),
894
 
  ( sym: -16; act: 4 ),
895
 
  ( sym: -15; act: 5 ),
896
 
  ( sym: -13; act: 6 ),
897
 
  ( sym: -12; act: 7 ),
898
 
  ( sym: -11; act: 8 ),
899
 
  ( sym: -10; act: 9 ),
900
 
  ( sym: -9; act: 10 ),
901
 
  ( sym: -8; act: 11 ),
902
 
{ 2: }
903
 
{ 3: }
904
 
{ 4: }
905
 
  ( sym: -33; act: 21 ),
906
 
{ 5: }
907
 
  ( sym: -29; act: 22 ),
908
 
{ 6: }
909
 
  ( sym: -3; act: 23 ),
910
 
{ 7: }
911
 
  ( sym: -34; act: 26 ),
912
 
  ( sym: -24; act: 27 ),
913
 
{ 8: }
914
 
  ( sym: -39; act: 29 ),
915
 
{ 9: }
916
 
  ( sym: -38; act: 30 ),
917
 
{ 10: }
918
 
  ( sym: -37; act: 31 ),
919
 
{ 11: }
920
 
  ( sym: -35; act: 32 ),
921
 
{ 12: }
922
 
{ 13: }
923
 
{ 14: }
924
 
{ 15: }
925
 
{ 16: }
926
 
{ 17: }
927
 
{ 18: }
928
 
{ 19: }
929
 
{ 20: }
930
 
{ 21: }
931
 
  ( sym: -17; act: 33 ),
932
 
{ 22: }
933
 
  ( sym: -44; act: 36 ),
934
 
  ( sym: -28; act: 37 ),
935
 
  ( sym: -16; act: 38 ),
936
 
{ 23: }
937
 
{ 24: }
938
 
{ 25: }
939
 
{ 26: }
940
 
  ( sym: -42; act: 40 ),
941
 
  ( sym: -40; act: 41 ),
942
 
  ( sym: -3; act: 42 ),
943
 
{ 27: }
944
 
  ( sym: -3; act: 44 ),
945
 
{ 28: }
946
 
{ 29: }
947
 
  ( sym: -34; act: 45 ),
948
 
  ( sym: -24; act: 27 ),
949
 
{ 30: }
950
 
  ( sym: -34; act: 46 ),
951
 
  ( sym: -24; act: 27 ),
952
 
{ 31: }
953
 
  ( sym: -34; act: 47 ),
954
 
  ( sym: -24; act: 27 ),
955
 
{ 32: }
956
 
  ( sym: -34; act: 48 ),
957
 
  ( sym: -24; act: 27 ),
958
 
{ 33: }
959
 
{ 34: }
960
 
{ 35: }
961
 
{ 36: }
962
 
  ( sym: -43; act: 49 ),
963
 
  ( sym: -4; act: 50 ),
964
 
{ 37: }
965
 
  ( sym: -47; act: 52 ),
966
 
  ( sym: -43; act: 53 ),
967
 
  ( sym: -31; act: 54 ),
968
 
  ( sym: -21; act: 55 ),
969
 
  ( sym: -4; act: 50 ),
970
 
{ 38: }
971
 
  ( sym: -45; act: 58 ),
972
 
{ 39: }
973
 
{ 40: }
974
 
{ 41: }
975
 
  ( sym: -42; act: 59 ),
976
 
  ( sym: -18; act: 60 ),
977
 
  ( sym: -3; act: 42 ),
978
 
{ 42: }
979
 
{ 43: }
980
 
{ 44: }
981
 
  ( sym: -25; act: 63 ),
982
 
{ 45: }
983
 
  ( sym: -41; act: 66 ),
984
 
  ( sym: -36; act: 67 ),
985
 
  ( sym: -6; act: 68 ),
986
 
  ( sym: -5; act: 69 ),
987
 
  ( sym: -3; act: 70 ),
988
 
{ 46: }
989
 
  ( sym: -41; act: 66 ),
990
 
  ( sym: -36; act: 74 ),
991
 
  ( sym: -6; act: 68 ),
992
 
  ( sym: -5; act: 69 ),
993
 
  ( sym: -3; act: 70 ),
994
 
{ 47: }
995
 
  ( sym: -41; act: 66 ),
996
 
  ( sym: -36; act: 75 ),
997
 
  ( sym: -6; act: 68 ),
998
 
  ( sym: -5; act: 69 ),
999
 
  ( sym: -3; act: 70 ),
1000
 
{ 48: }
1001
 
  ( sym: -41; act: 66 ),
1002
 
  ( sym: -36; act: 76 ),
1003
 
  ( sym: -6; act: 68 ),
1004
 
  ( sym: -5; act: 69 ),
1005
 
  ( sym: -3; act: 70 ),
1006
 
{ 49: }
1007
 
{ 50: }
1008
 
  ( sym: -48; act: 77 ),
1009
 
{ 51: }
1010
 
{ 52: }
1011
 
{ 53: }
1012
 
{ 54: }
1013
 
  ( sym: -30; act: 78 ),
1014
 
  ( sym: -15; act: 79 ),
1015
 
{ 55: }
1016
 
  ( sym: -52; act: 80 ),
1017
 
{ 56: }
1018
 
{ 57: }
1019
 
{ 58: }
1020
 
  ( sym: -17; act: 81 ),
1021
 
{ 59: }
1022
 
{ 60: }
1023
 
  ( sym: -42; act: 82 ),
1024
 
  ( sym: -3; act: 42 ),
1025
 
{ 61: }
1026
 
{ 62: }
1027
 
{ 63: }
1028
 
{ 64: }
1029
 
{ 65: }
1030
 
{ 66: }
1031
 
{ 67: }
1032
 
  ( sym: -41; act: 84 ),
1033
 
  ( sym: -18; act: 85 ),
1034
 
  ( sym: -6; act: 68 ),
1035
 
  ( sym: -5; act: 69 ),
1036
 
  ( sym: -3; act: 70 ),
1037
 
{ 68: }
1038
 
  ( sym: -7; act: 87 ),
1039
 
{ 69: }
1040
 
{ 70: }
1041
 
  ( sym: -7; act: 89 ),
1042
 
{ 71: }
1043
 
{ 72: }
1044
 
{ 73: }
1045
 
{ 74: }
1046
 
  ( sym: -41; act: 84 ),
1047
 
  ( sym: -18; act: 85 ),
1048
 
  ( sym: -6; act: 68 ),
1049
 
  ( sym: -5; act: 69 ),
1050
 
  ( sym: -3; act: 70 ),
1051
 
{ 75: }
1052
 
  ( sym: -41; act: 84 ),
1053
 
  ( sym: -18; act: 85 ),
1054
 
  ( sym: -6; act: 68 ),
1055
 
  ( sym: -5; act: 69 ),
1056
 
  ( sym: -3; act: 70 ),
1057
 
{ 76: }
1058
 
  ( sym: -41; act: 84 ),
1059
 
  ( sym: -18; act: 85 ),
1060
 
  ( sym: -6; act: 68 ),
1061
 
  ( sym: -5; act: 69 ),
1062
 
  ( sym: -3; act: 70 ),
1063
 
{ 77: }
1064
 
  ( sym: -19; act: 90 ),
1065
 
{ 78: }
1066
 
{ 79: }
1067
 
{ 80: }
1068
 
  ( sym: -49; act: 92 ),
1069
 
{ 81: }
1070
 
  ( sym: -46; act: 93 ),
1071
 
{ 82: }
1072
 
{ 83: }
1073
 
{ 84: }
1074
 
{ 85: }
1075
 
  ( sym: -41; act: 94 ),
1076
 
  ( sym: -6; act: 68 ),
1077
 
  ( sym: -5; act: 69 ),
1078
 
  ( sym: -3; act: 70 ),
1079
 
{ 86: }
1080
 
{ 87: }
1081
 
{ 88: }
1082
 
{ 89: }
1083
 
{ 90: }
1084
 
  ( sym: -50; act: 96 ),
1085
 
{ 91: }
1086
 
{ 92: }
1087
 
  ( sym: -53; act: 97 ),
1088
 
  ( sym: -51; act: 98 ),
1089
 
  ( sym: -26; act: 99 ),
1090
 
  ( sym: -22; act: 100 ),
1091
 
  ( sym: -14; act: 101 ),
1092
 
  ( sym: -6; act: 102 ),
1093
 
  ( sym: -5; act: 103 ),
1094
 
  ( sym: -3; act: 104 ),
1095
 
{ 93: }
1096
 
  ( sym: -43; act: 109 ),
1097
 
  ( sym: -4; act: 50 ),
1098
 
{ 94: }
1099
 
{ 95: }
1100
 
{ 96: }
1101
 
  ( sym: -49; act: 110 ),
1102
 
{ 97: }
1103
 
{ 98: }
1104
 
  ( sym: -20; act: 111 ),
1105
 
{ 99: }
1106
 
{ 100: }
1107
 
  ( sym: -54; act: 113 ),
1108
 
{ 101: }
1109
 
  ( sym: -6; act: 114 ),
1110
 
  ( sym: -5; act: 115 ),
1111
 
  ( sym: -3; act: 116 ),
1112
 
{ 102: }
1113
 
{ 103: }
1114
 
{ 104: }
1115
 
{ 105: }
1116
 
{ 106: }
1117
 
{ 107: }
1118
 
{ 108: }
1119
 
{ 109: }
1120
 
{ 110: }
1121
 
  ( sym: -53; act: 97 ),
1122
 
  ( sym: -51; act: 117 ),
1123
 
  ( sym: -26; act: 99 ),
1124
 
  ( sym: -22; act: 100 ),
1125
 
  ( sym: -14; act: 101 ),
1126
 
  ( sym: -6; act: 102 ),
1127
 
  ( sym: -5; act: 103 ),
1128
 
  ( sym: -3; act: 104 ),
1129
 
{ 111: }
1130
 
{ 112: }
1131
 
{ 113: }
1132
 
  ( sym: -23; act: 118 ),
1133
 
{ 114: }
1134
 
  ( sym: -57; act: 121 ),
1135
 
{ 115: }
1136
 
  ( sym: -56; act: 122 ),
1137
 
{ 116: }
1138
 
  ( sym: -58; act: 123 ),
1139
 
{ 117: }
1140
 
  ( sym: -20; act: 111 ),
1141
 
{ 118: }
1142
 
{ 119: }
1143
 
{ 120: }
1144
 
{ 121: }
1145
 
  ( sym: -55; act: 124 ),
1146
 
  ( sym: -53; act: 125 ),
1147
 
  ( sym: -26; act: 99 ),
1148
 
  ( sym: -22; act: 100 ),
1149
 
{ 122: }
1150
 
  ( sym: -55; act: 126 ),
1151
 
  ( sym: -53; act: 125 ),
1152
 
  ( sym: -26; act: 99 ),
1153
 
  ( sym: -22; act: 100 ),
1154
 
{ 123: }
1155
 
  ( sym: -55; act: 127 ),
1156
 
  ( sym: -53; act: 125 ),
1157
 
  ( sym: -26; act: 99 ),
1158
 
  ( sym: -22; act: 100 )
1159
 
{ 124: }
1160
 
{ 125: }
1161
 
{ 126: }
1162
 
{ 127: }
1163
 
);
1164
 
 
1165
 
yyd : array [0..yynstates-1] of Integer = (
1166
 
{ 0: } -33,
1167
 
{ 1: } 0,
1168
 
{ 2: } 0,
1169
 
{ 3: } -34,
1170
 
{ 4: } -38,
1171
 
{ 5: } -28,
1172
 
{ 6: } 0,
1173
 
{ 7: } 0,
1174
 
{ 8: } -46,
1175
 
{ 9: } -44,
1176
 
{ 10: } -42,
1177
 
{ 11: } -40,
1178
 
{ 12: } -35,
1179
 
{ 13: } -6,
1180
 
{ 14: } -7,
1181
 
{ 15: } -8,
1182
 
{ 16: } -9,
1183
 
{ 17: } -10,
1184
 
{ 18: } -11,
1185
 
{ 19: } -13,
1186
 
{ 20: } -14,
1187
 
{ 21: } 0,
1188
 
{ 22: } 0,
1189
 
{ 23: } -36,
1190
 
{ 24: } -37,
1191
 
{ 25: } -1,
1192
 
{ 26: } 0,
1193
 
{ 27: } 0,
1194
 
{ 28: } -24,
1195
 
{ 29: } 0,
1196
 
{ 30: } 0,
1197
 
{ 31: } 0,
1198
 
{ 32: } 0,
1199
 
{ 33: } -39,
1200
 
{ 34: } -16,
1201
 
{ 35: } -15,
1202
 
{ 36: } 0,
1203
 
{ 37: } 0,
1204
 
{ 38: } -72,
1205
 
{ 39: } -76,
1206
 
{ 40: } -63,
1207
 
{ 41: } 0,
1208
 
{ 42: } -69,
1209
 
{ 43: } -66,
1210
 
{ 44: } 0,
1211
 
{ 45: } 0,
1212
 
{ 46: } 0,
1213
 
{ 47: } 0,
1214
 
{ 48: } 0,
1215
 
{ 49: } -71,
1216
 
{ 50: } -78,
1217
 
{ 51: } -2,
1218
 
{ 52: } -75,
1219
 
{ 53: } -81,
1220
 
{ 54: } 0,
1221
 
{ 55: } -82,
1222
 
{ 56: } -20,
1223
 
{ 57: } -77,
1224
 
{ 58: } 0,
1225
 
{ 59: } -64,
1226
 
{ 60: } 0,
1227
 
{ 61: } -17,
1228
 
{ 62: } -67,
1229
 
{ 63: } -51,
1230
 
{ 64: } -25,
1231
 
{ 65: } -26,
1232
 
{ 66: } -52,
1233
 
{ 67: } 0,
1234
 
{ 68: } 0,
1235
 
{ 69: } -58,
1236
 
{ 70: } 0,
1237
 
{ 71: } -55,
1238
 
{ 72: } -3,
1239
 
{ 73: } -4,
1240
 
{ 74: } 0,
1241
 
{ 75: } 0,
1242
 
{ 76: } 0,
1243
 
{ 77: } 0,
1244
 
{ 78: } -30,
1245
 
{ 79: } -32,
1246
 
{ 80: } -84,
1247
 
{ 81: } -73,
1248
 
{ 82: } -65,
1249
 
{ 83: } -68,
1250
 
{ 84: } -53,
1251
 
{ 85: } 0,
1252
 
{ 86: } -56,
1253
 
{ 87: } -61,
1254
 
{ 88: } -5,
1255
 
{ 89: } -62,
1256
 
{ 90: } -79,
1257
 
{ 91: } -18,
1258
 
{ 92: } 0,
1259
 
{ 93: } 0,
1260
 
{ 94: } -54,
1261
 
{ 95: } -57,
1262
 
{ 96: } -84,
1263
 
{ 97: } -88,
1264
 
{ 98: } 0,
1265
 
{ 99: } -92,
1266
 
{ 100: } -90,
1267
 
{ 101: } 0,
1268
 
{ 102: } -86,
1269
 
{ 103: } -85,
1270
 
{ 104: } -87,
1271
 
{ 105: } -27,
1272
 
{ 106: } -21,
1273
 
{ 107: } -89,
1274
 
{ 108: } -12,
1275
 
{ 109: } -74,
1276
 
{ 110: } 0,
1277
 
{ 111: } -100,
1278
 
{ 112: } -19,
1279
 
{ 113: } 0,
1280
 
{ 114: } -96,
1281
 
{ 115: } -94,
1282
 
{ 116: } -98,
1283
 
{ 117: } 0,
1284
 
{ 118: } -91,
1285
 
{ 119: } -22,
1286
 
{ 120: } -23,
1287
 
{ 121: } 0,
1288
 
{ 122: } 0,
1289
 
{ 123: } 0,
1290
 
{ 124: } -97,
1291
 
{ 125: } -102,
1292
 
{ 126: } -95,
1293
 
{ 127: } -99
1294
 
);
1295
 
 
1296
 
yyal : array [0..yynstates-1] of Integer = (
1297
 
{ 0: } 1,
1298
 
{ 1: } 1,
1299
 
{ 2: } 10,
1300
 
{ 3: } 11,
1301
 
{ 4: } 11,
1302
 
{ 5: } 11,
1303
 
{ 6: } 11,
1304
 
{ 7: } 13,
1305
 
{ 8: } 24,
1306
 
{ 9: } 24,
1307
 
{ 10: } 24,
1308
 
{ 11: } 24,
1309
 
{ 12: } 24,
1310
 
{ 13: } 24,
1311
 
{ 14: } 24,
1312
 
{ 15: } 24,
1313
 
{ 16: } 24,
1314
 
{ 17: } 24,
1315
 
{ 18: } 24,
1316
 
{ 19: } 24,
1317
 
{ 20: } 24,
1318
 
{ 21: } 24,
1319
 
{ 22: } 26,
1320
 
{ 23: } 29,
1321
 
{ 24: } 29,
1322
 
{ 25: } 29,
1323
 
{ 26: } 29,
1324
 
{ 27: } 39,
1325
 
{ 28: } 40,
1326
 
{ 29: } 40,
1327
 
{ 30: } 45,
1328
 
{ 31: } 50,
1329
 
{ 32: } 55,
1330
 
{ 33: } 60,
1331
 
{ 34: } 60,
1332
 
{ 35: } 60,
1333
 
{ 36: } 60,
1334
 
{ 37: } 61,
1335
 
{ 38: } 66,
1336
 
{ 39: } 66,
1337
 
{ 40: } 66,
1338
 
{ 41: } 66,
1339
 
{ 42: } 77,
1340
 
{ 43: } 77,
1341
 
{ 44: } 77,
1342
 
{ 45: } 79,
1343
 
{ 46: } 83,
1344
 
{ 47: } 87,
1345
 
{ 48: } 91,
1346
 
{ 49: } 95,
1347
 
{ 50: } 95,
1348
 
{ 51: } 95,
1349
 
{ 52: } 95,
1350
 
{ 53: } 95,
1351
 
{ 54: } 95,
1352
 
{ 55: } 97,
1353
 
{ 56: } 97,
1354
 
{ 57: } 97,
1355
 
{ 58: } 97,
1356
 
{ 59: } 99,
1357
 
{ 60: } 99,
1358
 
{ 61: } 101,
1359
 
{ 62: } 101,
1360
 
{ 63: } 101,
1361
 
{ 64: } 101,
1362
 
{ 65: } 101,
1363
 
{ 66: } 101,
1364
 
{ 67: } 101,
1365
 
{ 68: } 114,
1366
 
{ 69: } 128,
1367
 
{ 70: } 128,
1368
 
{ 71: } 142,
1369
 
{ 72: } 142,
1370
 
{ 73: } 142,
1371
 
{ 74: } 142,
1372
 
{ 75: } 155,
1373
 
{ 76: } 168,
1374
 
{ 77: } 181,
1375
 
{ 78: } 182,
1376
 
{ 79: } 182,
1377
 
{ 80: } 182,
1378
 
{ 81: } 182,
1379
 
{ 82: } 182,
1380
 
{ 83: } 182,
1381
 
{ 84: } 182,
1382
 
{ 85: } 182,
1383
 
{ 86: } 186,
1384
 
{ 87: } 186,
1385
 
{ 88: } 186,
1386
 
{ 89: } 186,
1387
 
{ 90: } 186,
1388
 
{ 91: } 186,
1389
 
{ 92: } 186,
1390
 
{ 93: } 198,
1391
 
{ 94: } 199,
1392
 
{ 95: } 199,
1393
 
{ 96: } 199,
1394
 
{ 97: } 199,
1395
 
{ 98: } 199,
1396
 
{ 99: } 205,
1397
 
{ 100: } 205,
1398
 
{ 101: } 205,
1399
 
{ 102: } 208,
1400
 
{ 103: } 208,
1401
 
{ 104: } 208,
1402
 
{ 105: } 208,
1403
 
{ 106: } 208,
1404
 
{ 107: } 208,
1405
 
{ 108: } 208,
1406
 
{ 109: } 208,
1407
 
{ 110: } 208,
1408
 
{ 111: } 220,
1409
 
{ 112: } 220,
1410
 
{ 113: } 220,
1411
 
{ 114: } 222,
1412
 
{ 115: } 222,
1413
 
{ 116: } 222,
1414
 
{ 117: } 222,
1415
 
{ 118: } 228,
1416
 
{ 119: } 228,
1417
 
{ 120: } 228,
1418
 
{ 121: } 228,
1419
 
{ 122: } 236,
1420
 
{ 123: } 244,
1421
 
{ 124: } 252,
1422
 
{ 125: } 252,
1423
 
{ 126: } 252,
1424
 
{ 127: } 252
1425
 
);
1426
 
 
1427
 
yyah : array [0..yynstates-1] of Integer = (
1428
 
{ 0: } 0,
1429
 
{ 1: } 9,
1430
 
{ 2: } 10,
1431
 
{ 3: } 10,
1432
 
{ 4: } 10,
1433
 
{ 5: } 10,
1434
 
{ 6: } 12,
1435
 
{ 7: } 23,
1436
 
{ 8: } 23,
1437
 
{ 9: } 23,
1438
 
{ 10: } 23,
1439
 
{ 11: } 23,
1440
 
{ 12: } 23,
1441
 
{ 13: } 23,
1442
 
{ 14: } 23,
1443
 
{ 15: } 23,
1444
 
{ 16: } 23,
1445
 
{ 17: } 23,
1446
 
{ 18: } 23,
1447
 
{ 19: } 23,
1448
 
{ 20: } 23,
1449
 
{ 21: } 25,
1450
 
{ 22: } 28,
1451
 
{ 23: } 28,
1452
 
{ 24: } 28,
1453
 
{ 25: } 28,
1454
 
{ 26: } 38,
1455
 
{ 27: } 39,
1456
 
{ 28: } 39,
1457
 
{ 29: } 44,
1458
 
{ 30: } 49,
1459
 
{ 31: } 54,
1460
 
{ 32: } 59,
1461
 
{ 33: } 59,
1462
 
{ 34: } 59,
1463
 
{ 35: } 59,
1464
 
{ 36: } 60,
1465
 
{ 37: } 65,
1466
 
{ 38: } 65,
1467
 
{ 39: } 65,
1468
 
{ 40: } 65,
1469
 
{ 41: } 76,
1470
 
{ 42: } 76,
1471
 
{ 43: } 76,
1472
 
{ 44: } 78,
1473
 
{ 45: } 82,
1474
 
{ 46: } 86,
1475
 
{ 47: } 90,
1476
 
{ 48: } 94,
1477
 
{ 49: } 94,
1478
 
{ 50: } 94,
1479
 
{ 51: } 94,
1480
 
{ 52: } 94,
1481
 
{ 53: } 94,
1482
 
{ 54: } 96,
1483
 
{ 55: } 96,
1484
 
{ 56: } 96,
1485
 
{ 57: } 96,
1486
 
{ 58: } 98,
1487
 
{ 59: } 98,
1488
 
{ 60: } 100,
1489
 
{ 61: } 100,
1490
 
{ 62: } 100,
1491
 
{ 63: } 100,
1492
 
{ 64: } 100,
1493
 
{ 65: } 100,
1494
 
{ 66: } 100,
1495
 
{ 67: } 113,
1496
 
{ 68: } 127,
1497
 
{ 69: } 127,
1498
 
{ 70: } 141,
1499
 
{ 71: } 141,
1500
 
{ 72: } 141,
1501
 
{ 73: } 141,
1502
 
{ 74: } 154,
1503
 
{ 75: } 167,
1504
 
{ 76: } 180,
1505
 
{ 77: } 181,
1506
 
{ 78: } 181,
1507
 
{ 79: } 181,
1508
 
{ 80: } 181,
1509
 
{ 81: } 181,
1510
 
{ 82: } 181,
1511
 
{ 83: } 181,
1512
 
{ 84: } 181,
1513
 
{ 85: } 185,
1514
 
{ 86: } 185,
1515
 
{ 87: } 185,
1516
 
{ 88: } 185,
1517
 
{ 89: } 185,
1518
 
{ 90: } 185,
1519
 
{ 91: } 185,
1520
 
{ 92: } 197,
1521
 
{ 93: } 198,
1522
 
{ 94: } 198,
1523
 
{ 95: } 198,
1524
 
{ 96: } 198,
1525
 
{ 97: } 198,
1526
 
{ 98: } 204,
1527
 
{ 99: } 204,
1528
 
{ 100: } 204,
1529
 
{ 101: } 207,
1530
 
{ 102: } 207,
1531
 
{ 103: } 207,
1532
 
{ 104: } 207,
1533
 
{ 105: } 207,
1534
 
{ 106: } 207,
1535
 
{ 107: } 207,
1536
 
{ 108: } 207,
1537
 
{ 109: } 207,
1538
 
{ 110: } 219,
1539
 
{ 111: } 219,
1540
 
{ 112: } 219,
1541
 
{ 113: } 221,
1542
 
{ 114: } 221,
1543
 
{ 115: } 221,
1544
 
{ 116: } 221,
1545
 
{ 117: } 227,
1546
 
{ 118: } 227,
1547
 
{ 119: } 227,
1548
 
{ 120: } 227,
1549
 
{ 121: } 235,
1550
 
{ 122: } 243,
1551
 
{ 123: } 251,
1552
 
{ 124: } 251,
1553
 
{ 125: } 251,
1554
 
{ 126: } 251,
1555
 
{ 127: } 251
1556
 
);
1557
 
 
1558
 
yygl : array [0..yynstates-1] of Integer = (
1559
 
{ 0: } 1,
1560
 
{ 1: } 3,
1561
 
{ 2: } 12,
1562
 
{ 3: } 12,
1563
 
{ 4: } 12,
1564
 
{ 5: } 13,
1565
 
{ 6: } 14,
1566
 
{ 7: } 15,
1567
 
{ 8: } 17,
1568
 
{ 9: } 18,
1569
 
{ 10: } 19,
1570
 
{ 11: } 20,
1571
 
{ 12: } 21,
1572
 
{ 13: } 21,
1573
 
{ 14: } 21,
1574
 
{ 15: } 21,
1575
 
{ 16: } 21,
1576
 
{ 17: } 21,
1577
 
{ 18: } 21,
1578
 
{ 19: } 21,
1579
 
{ 20: } 21,
1580
 
{ 21: } 21,
1581
 
{ 22: } 22,
1582
 
{ 23: } 25,
1583
 
{ 24: } 25,
1584
 
{ 25: } 25,
1585
 
{ 26: } 25,
1586
 
{ 27: } 28,
1587
 
{ 28: } 29,
1588
 
{ 29: } 29,
1589
 
{ 30: } 31,
1590
 
{ 31: } 33,
1591
 
{ 32: } 35,
1592
 
{ 33: } 37,
1593
 
{ 34: } 37,
1594
 
{ 35: } 37,
1595
 
{ 36: } 37,
1596
 
{ 37: } 39,
1597
 
{ 38: } 44,
1598
 
{ 39: } 45,
1599
 
{ 40: } 45,
1600
 
{ 41: } 45,
1601
 
{ 42: } 48,
1602
 
{ 43: } 48,
1603
 
{ 44: } 48,
1604
 
{ 45: } 49,
1605
 
{ 46: } 54,
1606
 
{ 47: } 59,
1607
 
{ 48: } 64,
1608
 
{ 49: } 69,
1609
 
{ 50: } 69,
1610
 
{ 51: } 70,
1611
 
{ 52: } 70,
1612
 
{ 53: } 70,
1613
 
{ 54: } 70,
1614
 
{ 55: } 72,
1615
 
{ 56: } 73,
1616
 
{ 57: } 73,
1617
 
{ 58: } 73,
1618
 
{ 59: } 74,
1619
 
{ 60: } 74,
1620
 
{ 61: } 76,
1621
 
{ 62: } 76,
1622
 
{ 63: } 76,
1623
 
{ 64: } 76,
1624
 
{ 65: } 76,
1625
 
{ 66: } 76,
1626
 
{ 67: } 76,
1627
 
{ 68: } 81,
1628
 
{ 69: } 82,
1629
 
{ 70: } 82,
1630
 
{ 71: } 83,
1631
 
{ 72: } 83,
1632
 
{ 73: } 83,
1633
 
{ 74: } 83,
1634
 
{ 75: } 88,
1635
 
{ 76: } 93,
1636
 
{ 77: } 98,
1637
 
{ 78: } 99,
1638
 
{ 79: } 99,
1639
 
{ 80: } 99,
1640
 
{ 81: } 100,
1641
 
{ 82: } 101,
1642
 
{ 83: } 101,
1643
 
{ 84: } 101,
1644
 
{ 85: } 101,
1645
 
{ 86: } 105,
1646
 
{ 87: } 105,
1647
 
{ 88: } 105,
1648
 
{ 89: } 105,
1649
 
{ 90: } 105,
1650
 
{ 91: } 106,
1651
 
{ 92: } 106,
1652
 
{ 93: } 114,
1653
 
{ 94: } 116,
1654
 
{ 95: } 116,
1655
 
{ 96: } 116,
1656
 
{ 97: } 117,
1657
 
{ 98: } 117,
1658
 
{ 99: } 118,
1659
 
{ 100: } 118,
1660
 
{ 101: } 119,
1661
 
{ 102: } 122,
1662
 
{ 103: } 122,
1663
 
{ 104: } 122,
1664
 
{ 105: } 122,
1665
 
{ 106: } 122,
1666
 
{ 107: } 122,
1667
 
{ 108: } 122,
1668
 
{ 109: } 122,
1669
 
{ 110: } 122,
1670
 
{ 111: } 130,
1671
 
{ 112: } 130,
1672
 
{ 113: } 130,
1673
 
{ 114: } 131,
1674
 
{ 115: } 132,
1675
 
{ 116: } 133,
1676
 
{ 117: } 134,
1677
 
{ 118: } 135,
1678
 
{ 119: } 135,
1679
 
{ 120: } 135,
1680
 
{ 121: } 135,
1681
 
{ 122: } 139,
1682
 
{ 123: } 143,
1683
 
{ 124: } 147,
1684
 
{ 125: } 147,
1685
 
{ 126: } 147,
1686
 
{ 127: } 147
1687
 
);
1688
 
 
1689
 
yygh : array [0..yynstates-1] of Integer = (
1690
 
{ 0: } 2,
1691
 
{ 1: } 11,
1692
 
{ 2: } 11,
1693
 
{ 3: } 11,
1694
 
{ 4: } 12,
1695
 
{ 5: } 13,
1696
 
{ 6: } 14,
1697
 
{ 7: } 16,
1698
 
{ 8: } 17,
1699
 
{ 9: } 18,
1700
 
{ 10: } 19,
1701
 
{ 11: } 20,
1702
 
{ 12: } 20,
1703
 
{ 13: } 20,
1704
 
{ 14: } 20,
1705
 
{ 15: } 20,
1706
 
{ 16: } 20,
1707
 
{ 17: } 20,
1708
 
{ 18: } 20,
1709
 
{ 19: } 20,
1710
 
{ 20: } 20,
1711
 
{ 21: } 21,
1712
 
{ 22: } 24,
1713
 
{ 23: } 24,
1714
 
{ 24: } 24,
1715
 
{ 25: } 24,
1716
 
{ 26: } 27,
1717
 
{ 27: } 28,
1718
 
{ 28: } 28,
1719
 
{ 29: } 30,
1720
 
{ 30: } 32,
1721
 
{ 31: } 34,
1722
 
{ 32: } 36,
1723
 
{ 33: } 36,
1724
 
{ 34: } 36,
1725
 
{ 35: } 36,
1726
 
{ 36: } 38,
1727
 
{ 37: } 43,
1728
 
{ 38: } 44,
1729
 
{ 39: } 44,
1730
 
{ 40: } 44,
1731
 
{ 41: } 47,
1732
 
{ 42: } 47,
1733
 
{ 43: } 47,
1734
 
{ 44: } 48,
1735
 
{ 45: } 53,
1736
 
{ 46: } 58,
1737
 
{ 47: } 63,
1738
 
{ 48: } 68,
1739
 
{ 49: } 68,
1740
 
{ 50: } 69,
1741
 
{ 51: } 69,
1742
 
{ 52: } 69,
1743
 
{ 53: } 69,
1744
 
{ 54: } 71,
1745
 
{ 55: } 72,
1746
 
{ 56: } 72,
1747
 
{ 57: } 72,
1748
 
{ 58: } 73,
1749
 
{ 59: } 73,
1750
 
{ 60: } 75,
1751
 
{ 61: } 75,
1752
 
{ 62: } 75,
1753
 
{ 63: } 75,
1754
 
{ 64: } 75,
1755
 
{ 65: } 75,
1756
 
{ 66: } 75,
1757
 
{ 67: } 80,
1758
 
{ 68: } 81,
1759
 
{ 69: } 81,
1760
 
{ 70: } 82,
1761
 
{ 71: } 82,
1762
 
{ 72: } 82,
1763
 
{ 73: } 82,
1764
 
{ 74: } 87,
1765
 
{ 75: } 92,
1766
 
{ 76: } 97,
1767
 
{ 77: } 98,
1768
 
{ 78: } 98,
1769
 
{ 79: } 98,
1770
 
{ 80: } 99,
1771
 
{ 81: } 100,
1772
 
{ 82: } 100,
1773
 
{ 83: } 100,
1774
 
{ 84: } 100,
1775
 
{ 85: } 104,
1776
 
{ 86: } 104,
1777
 
{ 87: } 104,
1778
 
{ 88: } 104,
1779
 
{ 89: } 104,
1780
 
{ 90: } 105,
1781
 
{ 91: } 105,
1782
 
{ 92: } 113,
1783
 
{ 93: } 115,
1784
 
{ 94: } 115,
1785
 
{ 95: } 115,
1786
 
{ 96: } 116,
1787
 
{ 97: } 116,
1788
 
{ 98: } 117,
1789
 
{ 99: } 117,
1790
 
{ 100: } 118,
1791
 
{ 101: } 121,
1792
 
{ 102: } 121,
1793
 
{ 103: } 121,
1794
 
{ 104: } 121,
1795
 
{ 105: } 121,
1796
 
{ 106: } 121,
1797
 
{ 107: } 121,
1798
 
{ 108: } 121,
1799
 
{ 109: } 121,
1800
 
{ 110: } 129,
1801
 
{ 111: } 129,
1802
 
{ 112: } 129,
1803
 
{ 113: } 130,
1804
 
{ 114: } 131,
1805
 
{ 115: } 132,
1806
 
{ 116: } 133,
1807
 
{ 117: } 134,
1808
 
{ 118: } 134,
1809
 
{ 119: } 134,
1810
 
{ 120: } 134,
1811
 
{ 121: } 138,
1812
 
{ 122: } 142,
1813
 
{ 123: } 146,
1814
 
{ 124: } 146,
1815
 
{ 125: } 146,
1816
 
{ 126: } 146,
1817
 
{ 127: } 146
1818
 
);
1819
 
 
1820
 
yyr : array [1..yynrules] of YYRRec = (
1821
 
{ 1: } ( len: 1; sym: -3 ),
1822
 
{ 2: } ( len: 1; sym: -4 ),
1823
 
{ 3: } ( len: 1; sym: -5 ),
1824
 
{ 4: } ( len: 1; sym: -6 ),
1825
 
{ 5: } ( len: 1; sym: -7 ),
1826
 
{ 6: } ( len: 1; sym: -8 ),
1827
 
{ 7: } ( len: 1; sym: -9 ),
1828
 
{ 8: } ( len: 1; sym: -10 ),
1829
 
{ 9: } ( len: 1; sym: -11 ),
1830
 
{ 10: } ( len: 1; sym: -12 ),
1831
 
{ 11: } ( len: 1; sym: -13 ),
1832
 
{ 12: } ( len: 1; sym: -14 ),
1833
 
{ 13: } ( len: 1; sym: -15 ),
1834
 
{ 14: } ( len: 1; sym: -16 ),
1835
 
{ 15: } ( len: 1; sym: -17 ),
1836
 
{ 16: } ( len: 1; sym: -17 ),
1837
 
{ 17: } ( len: 1; sym: -18 ),
1838
 
{ 18: } ( len: 1; sym: -19 ),
1839
 
{ 19: } ( len: 1; sym: -20 ),
1840
 
{ 20: } ( len: 1; sym: -21 ),
1841
 
{ 21: } ( len: 1; sym: -22 ),
1842
 
{ 22: } ( len: 1; sym: -23 ),
1843
 
{ 23: } ( len: 1; sym: -23 ),
1844
 
{ 24: } ( len: 1; sym: -24 ),
1845
 
{ 25: } ( len: 1; sym: -25 ),
1846
 
{ 26: } ( len: 1; sym: -25 ),
1847
 
{ 27: } ( len: 1; sym: -26 ),
1848
 
{ 28: } ( len: 0; sym: -29 ),
1849
 
{ 29: } ( len: 0; sym: -31 ),
1850
 
{ 30: } ( len: 6; sym: -2 ),
1851
 
{ 31: } ( len: 0; sym: -30 ),
1852
 
{ 32: } ( len: 1; sym: -30 ),
1853
 
{ 33: } ( len: 0; sym: -27 ),
1854
 
{ 34: } ( len: 2; sym: -27 ),
1855
 
{ 35: } ( len: 2; sym: -27 ),
1856
 
{ 36: } ( len: 2; sym: -32 ),
1857
 
{ 37: } ( len: 2; sym: -32 ),
1858
 
{ 38: } ( len: 0; sym: -33 ),
1859
 
{ 39: } ( len: 3; sym: -32 ),
1860
 
{ 40: } ( len: 0; sym: -35 ),
1861
 
{ 41: } ( len: 4; sym: -32 ),
1862
 
{ 42: } ( len: 0; sym: -37 ),
1863
 
{ 43: } ( len: 4; sym: -32 ),
1864
 
{ 44: } ( len: 0; sym: -38 ),
1865
 
{ 45: } ( len: 4; sym: -32 ),
1866
 
{ 46: } ( len: 0; sym: -39 ),
1867
 
{ 47: } ( len: 4; sym: -32 ),
1868
 
{ 48: } ( len: 3; sym: -32 ),
1869
 
{ 49: } ( len: 2; sym: -32 ),
1870
 
{ 50: } ( len: 0; sym: -34 ),
1871
 
{ 51: } ( len: 3; sym: -34 ),
1872
 
{ 52: } ( len: 1; sym: -36 ),
1873
 
{ 53: } ( len: 2; sym: -36 ),
1874
 
{ 54: } ( len: 3; sym: -36 ),
1875
 
{ 55: } ( len: 1; sym: -36 ),
1876
 
{ 56: } ( len: 2; sym: -36 ),
1877
 
{ 57: } ( len: 3; sym: -36 ),
1878
 
{ 58: } ( len: 1; sym: -41 ),
1879
 
{ 59: } ( len: 1; sym: -41 ),
1880
 
{ 60: } ( len: 1; sym: -41 ),
1881
 
{ 61: } ( len: 2; sym: -41 ),
1882
 
{ 62: } ( len: 2; sym: -41 ),
1883
 
{ 63: } ( len: 1; sym: -40 ),
1884
 
{ 64: } ( len: 2; sym: -40 ),
1885
 
{ 65: } ( len: 3; sym: -40 ),
1886
 
{ 66: } ( len: 1; sym: -40 ),
1887
 
{ 67: } ( len: 2; sym: -40 ),
1888
 
{ 68: } ( len: 3; sym: -40 ),
1889
 
{ 69: } ( len: 1; sym: -42 ),
1890
 
{ 70: } ( len: 0; sym: -44 ),
1891
 
{ 71: } ( len: 2; sym: -28 ),
1892
 
{ 72: } ( len: 0; sym: -45 ),
1893
 
{ 73: } ( len: 0; sym: -46 ),
1894
 
{ 74: } ( len: 5; sym: -28 ),
1895
 
{ 75: } ( len: 2; sym: -28 ),
1896
 
{ 76: } ( len: 1; sym: -28 ),
1897
 
{ 77: } ( len: 2; sym: -28 ),
1898
 
{ 78: } ( len: 0; sym: -48 ),
1899
 
{ 79: } ( len: 0; sym: -50 ),
1900
 
{ 80: } ( len: 6; sym: -43 ),
1901
 
{ 81: } ( len: 1; sym: -47 ),
1902
 
{ 82: } ( len: 0; sym: -52 ),
1903
 
{ 83: } ( len: 4; sym: -47 ),
1904
 
{ 84: } ( len: 0; sym: -49 ),
1905
 
{ 85: } ( len: 2; sym: -49 ),
1906
 
{ 86: } ( len: 2; sym: -49 ),
1907
 
{ 87: } ( len: 2; sym: -49 ),
1908
 
{ 88: } ( len: 2; sym: -49 ),
1909
 
{ 89: } ( len: 2; sym: -49 ),
1910
 
{ 90: } ( len: 0; sym: -54 ),
1911
 
{ 91: } ( len: 3; sym: -53 ),
1912
 
{ 92: } ( len: 1; sym: -53 ),
1913
 
{ 93: } ( len: 0; sym: -51 ),
1914
 
{ 94: } ( len: 0; sym: -56 ),
1915
 
{ 95: } ( len: 4; sym: -51 ),
1916
 
{ 96: } ( len: 0; sym: -57 ),
1917
 
{ 97: } ( len: 4; sym: -51 ),
1918
 
{ 98: } ( len: 0; sym: -58 ),
1919
 
{ 99: } ( len: 4; sym: -51 ),
1920
 
{ 100: } ( len: 2; sym: -51 ),
1921
 
{ 101: } ( len: 0; sym: -55 ),
1922
 
{ 102: } ( len: 1; sym: -55 )
1923
 
);
1924
 
 
1925
 
 
1926
 
const _error = 256; (* error token *)
1927
 
 
1928
 
function yyact(state, sym : Integer; var act : Integer) : Boolean;
1929
 
  (* search action table *)
1930
 
  var k : Integer;
1931
 
  begin
1932
 
    k := yyal[state];
1933
 
    while (k<=yyah[state]) and (yya[k].sym<>sym) do inc(k);
1934
 
    if k>yyah[state] then
1935
 
      yyact := false
1936
 
    else
1937
 
      begin
1938
 
        act := yya[k].act;
1939
 
        yyact := true;
1940
 
      end;
1941
 
  end(*yyact*);
1942
 
 
1943
 
function yygoto(state, sym : Integer; var nstate : Integer) : Boolean;
1944
 
  (* search goto table *)
1945
 
  var k : Integer;
1946
 
  begin
1947
 
    k := yygl[state];
1948
 
    while (k<=yygh[state]) and (yyg[k].sym<>sym) do inc(k);
1949
 
    if k>yygh[state] then
1950
 
      yygoto := false
1951
 
    else
1952
 
      begin
1953
 
        nstate := yyg[k].act;
1954
 
        yygoto := true;
1955
 
      end;
1956
 
  end(*yygoto*);
1957
 
 
1958
 
label parse, next, error, errlab, shift, reduce, accept, abort;
1959
 
 
1960
 
begin(*yyparse*)
1961
 
 
1962
 
  (* initialize: *)
1963
 
 
1964
 
  yystate := 0; yychar := -1; yynerrs := 0; yyerrflag := 0; yysp := 0;
1965
 
 
1966
 
{$ifdef yydebug}
1967
 
  yydebug := true;
1968
 
{$else}
1969
 
  yydebug := false;
1970
 
{$endif}
1971
 
 
1972
 
parse:
1973
 
 
1974
 
  (* push state and value: *)
1975
 
 
1976
 
  inc(yysp);
1977
 
  if yysp>yymaxdepth then
1978
 
    begin
1979
 
      yyerror('yyparse stack overflow');
1980
 
      goto abort;
1981
 
    end;
1982
 
  yys[yysp] := yystate; yyv[yysp] := yyval;
1983
 
 
1984
 
next:
1985
 
 
1986
 
  if (yyd[yystate]=0) and (yychar=-1) then
1987
 
    (* get next symbol *)
1988
 
    begin
1989
 
      yychar := yylex; if yychar<0 then yychar := 0;
1990
 
    end;
1991
 
 
1992
 
  if yydebug then writeln('state ', yystate, ', char ', yychar);
1993
 
 
1994
 
  (* determine parse action: *)
1995
 
 
1996
 
  yyn := yyd[yystate];
1997
 
  if yyn<>0 then goto reduce; (* simple state *)
1998
 
 
1999
 
  (* no default action; search parse table *)
2000
 
 
2001
 
  if not yyact(yystate, yychar, yyn) then goto error
2002
 
  else if yyn>0 then                      goto shift
2003
 
  else if yyn<0 then                      goto reduce
2004
 
  else                                    goto accept;
2005
 
 
2006
 
error:
2007
 
 
2008
 
  (* error; start error recovery: *)
2009
 
 
2010
 
  if yyerrflag=0 then yyerror('syntax error');
2011
 
 
2012
 
errlab:
2013
 
 
2014
 
  if yyerrflag=0 then inc(yynerrs);     (* new error *)
2015
 
 
2016
 
  if yyerrflag<=2 then                  (* incomplete recovery; try again *)
2017
 
    begin
2018
 
      yyerrflag := 3;
2019
 
      (* uncover a state with shift action on error token *)
2020
 
      while (yysp>0) and not ( yyact(yys[yysp], _error, yyn) and
2021
 
                               (yyn>0) ) do
2022
 
        begin
2023
 
          if yydebug then
2024
 
            if yysp>1 then
2025
 
              writeln('error recovery pops state ', yys[yysp], ', uncovers ',
2026
 
                      yys[yysp-1])
2027
 
            else
2028
 
              writeln('error recovery fails ... abort');
2029
 
          dec(yysp);
2030
 
        end;
2031
 
      if yysp=0 then goto abort; (* parser has fallen from stack; abort *)
2032
 
      yystate := yyn;            (* simulate shift on error *)
2033
 
      goto parse;
2034
 
    end
2035
 
  else                                  (* no shift yet; discard symbol *)
2036
 
    begin
2037
 
      if yydebug then writeln('error recovery discards char ', yychar);
2038
 
      if yychar=0 then goto abort; (* end of input; abort *)
2039
 
      yychar := -1; goto next;     (* clear lookahead char and try again *)
2040
 
    end;
2041
 
 
2042
 
shift:
2043
 
 
2044
 
  (* go to new state, clear lookahead character: *)
2045
 
 
2046
 
  yystate := yyn; yychar := -1; yyval := yylval;
2047
 
  if yyerrflag>0 then dec(yyerrflag);
2048
 
 
2049
 
  goto parse;
2050
 
 
2051
 
reduce:
2052
 
 
2053
 
  (* execute action, pop rule from stack, and go to next state: *)
2054
 
 
2055
 
  if yydebug then writeln('reduce ', -yyn);
2056
 
 
2057
 
  yyflag := yyfnone; yyaction(-yyn);
2058
 
  dec(yysp, yyr[-yyn].len);
2059
 
  if yygoto(yys[yysp], yyr[-yyn].sym, yyn) then yystate := yyn;
2060
 
 
2061
 
  (* handle action calls to yyaccept, yyabort and yyerror: *)
2062
 
 
2063
 
  case yyflag of
2064
 
    yyfaccept : goto accept;
2065
 
    yyfabort  : goto abort;
2066
 
    yyferror  : goto errlab;
2067
 
  end;
2068
 
 
2069
 
  goto parse;
2070
 
 
2071
 
accept:
2072
 
 
2073
 
  yyparse := 0; exit;
2074
 
 
2075
 
abort:
2076
 
 
2077
 
  yyparse := 1; exit;
2078
 
 
2079
 
end(*yyparse*);
2080
 
 
2081
 
 
2082
 
(* Lexical analyzer (implemented in Turbo Pascal for maximum efficiency): *)
2083
 
 
2084
 
function yylex : integer;
2085
 
  function end_of_input : boolean;
2086
 
    begin
2087
 
      end_of_input := (cno>length(line)) and eof(yyin)
2088
 
    end(*end_of_input*);
2089
 
  procedure scan;
2090
 
    (* scan for nonempty character, skip comments *)
2091
 
    procedure scan_comment;
2092
 
      var p : integer;
2093
 
      begin
2094
 
        p := pos('*/', copy(line, cno, length(line)));
2095
 
        if p>0 then
2096
 
          cno := cno+succ(p)
2097
 
        else
2098
 
          begin
2099
 
            while (p=0) and not eof(yyin) do
2100
 
              begin
2101
 
                readln(yyin, line);
2102
 
                inc(lno);
2103
 
                p := pos('*/', line)
2104
 
              end;
2105
 
            if p=0 then
2106
 
              begin
2107
 
                cno := succ(length(line));
2108
 
                error(open_comment_at_eof);
2109
 
              end
2110
 
            else
2111
 
              cno := succ(succ(p))
2112
 
          end
2113
 
      end(*scan_comment*);
2114
 
    begin
2115
 
      while not end_of_input do
2116
 
        if cno<=length(line) then
2117
 
          case line[cno] of
2118
 
            ' ', tab : inc(cno);
2119
 
            '/' :
2120
 
              if (cno<length(line)) and (line[succ(cno)]='*') then
2121
 
                begin
2122
 
                  inc(cno, 2);
2123
 
                  scan_comment
2124
 
                end
2125
 
              else
2126
 
                exit
2127
 
            else
2128
 
              exit
2129
 
          end
2130
 
        else
2131
 
          begin
2132
 
            readln(yyin, line);
2133
 
            inc(lno); cno := 1;
2134
 
          end
2135
 
    end(*scan*);
2136
 
  function scan_ident : integer;
2137
 
    (* scan an identifier *)
2138
 
    var
2139
 
      idstr : String;
2140
 
    begin
2141
 
      idstr := line[cno];
2142
 
      inc(cno);
2143
 
      while (cno<=length(line)) and (
2144
 
            ('A'<=upCase(line[cno])) and (upCase(line[cno])<='Z') or
2145
 
            ('0'<=line[cno]) and (line[cno]<='9') or
2146
 
            (line[cno]='_') or
2147
 
            (line[cno]='.') ) do
2148
 
        begin
2149
 
          idstr := idstr+line[cno];
2150
 
          inc(cno)
2151
 
        end;
2152
 
      yylval := get_key(idstr);
2153
 
      scan;
2154
 
      if not end_of_input and (line[cno]=':') then
2155
 
        scan_ident := C_ID
2156
 
      else
2157
 
        scan_ident := ID
2158
 
    end(*scan_ident*);
2159
 
  function scan_literal: integer;
2160
 
    (* scan a literal, i.e. string *)
2161
 
    var
2162
 
      idstr : String;
2163
 
      oct_val : Byte;
2164
 
    begin
2165
 
      idstr := line[cno];
2166
 
      inc(cno);
2167
 
      while (cno<=length(line)) and (line[cno]<>idstr[1]) do
2168
 
        if line[cno]='\' then
2169
 
          if cno<length(line) then
2170
 
            begin
2171
 
              inc(cno);
2172
 
              case line[cno] of
2173
 
                'n' :
2174
 
                  begin
2175
 
                    idstr := idstr+nl;
2176
 
                    inc(cno)
2177
 
                  end;
2178
 
                'r' :
2179
 
                  begin
2180
 
                    idstr := idstr+cr;
2181
 
                    inc(cno)
2182
 
                  end;
2183
 
                't' :
2184
 
                  begin
2185
 
                    idstr := idstr+tab;
2186
 
                    inc(cno)
2187
 
                  end;
2188
 
                'b' :
2189
 
                  begin
2190
 
                    idstr := idstr+bs;
2191
 
                    inc(cno)
2192
 
                  end;
2193
 
                'f' :
2194
 
                  begin
2195
 
                    idstr := idstr+ff;
2196
 
                    inc(cno)
2197
 
                  end;
2198
 
                '0'..'7' :
2199
 
                  begin
2200
 
                    oct_val := ord(line[cno])-ord('0');
2201
 
                    inc(cno);
2202
 
                    while (cno<=length(line)) and
2203
 
                          ('0'<=line[cno]) and
2204
 
                          (line[cno]<='7') do
2205
 
                      begin
2206
 
                        oct_val := oct_val*8+ord(line[cno])-ord('0');
2207
 
                        inc(cno)
2208
 
                      end;
2209
 
                    idstr := idstr+chr(oct_val)
2210
 
                  end
2211
 
                else
2212
 
                  begin
2213
 
                    idstr := idstr+line[cno];
2214
 
                    inc(cno)
2215
 
                  end
2216
 
              end
2217
 
            end
2218
 
          else
2219
 
            inc(cno)
2220
 
        else
2221
 
          begin
2222
 
            idstr := idstr+line[cno];
2223
 
            inc(cno)
2224
 
          end;
2225
 
      if cno>length(line) then
2226
 
        error(missing_string_terminator)
2227
 
      else
2228
 
        inc(cno);
2229
 
      if length(idstr)=2 then
2230
 
        begin
2231
 
          yylval := ord(idstr[2]);
2232
 
          scan_literal := LITERAL;
2233
 
        end
2234
 
      else if length(idstr)>1 then
2235
 
        begin
2236
 
          yylval := get_key(''''+copy(idstr, 2, pred(length(idstr)))+'''');
2237
 
          scan_literal := LITID;
2238
 
        end
2239
 
      else
2240
 
        scan_literal := ILLEGAL;
2241
 
    end(*scan_literal*);
2242
 
  function scan_num : integer;
2243
 
    (* scan an unsigned integer *)
2244
 
    var
2245
 
      numstr : String;
2246
 
      code : integer;
2247
 
    begin
2248
 
      numstr := line[cno];
2249
 
      inc(cno);
2250
 
      while (cno<=length(line)) and
2251
 
            ('0'<=line[cno]) and (line[cno]<='9') do
2252
 
        begin
2253
 
          numstr := numstr+line[cno];
2254
 
          inc(cno)
2255
 
        end;
2256
 
      val(numstr, yylval, code);
2257
 
      if code=0 then
2258
 
        scan_num := NUMBER
2259
 
      else
2260
 
        scan_num := ILLEGAL;
2261
 
    end(*scan_num*);
2262
 
  function scan_keyword : integer;
2263
 
    (* scan %xy *)
2264
 
    function lookup(key : String; var tok : integer) : boolean;
2265
 
      (* table of Yacc keywords (unstropped): *)
2266
 
      const
2267
 
        no_of_entries = 11;
2268
 
        max_entry_length = 8;
2269
 
        keys : array [1..no_of_entries] of String[max_entry_length] = (
2270
 
          '0', '2', 'binary', 'left', 'nonassoc', 'prec', 'right',
2271
 
          'start', 'term', 'token', 'type');
2272
 
        toks : array [1..no_of_entries] of integer = (
2273
 
          PTOKEN, PNONASSOC, PNONASSOC, PLEFT, PNONASSOC, PPREC, PRIGHT,
2274
 
          PSTART, PTOKEN, PTOKEN, PTYPE);
2275
 
      var m, n, k : integer;
2276
 
      begin
2277
 
        (* binary search: *)
2278
 
        m := 1; n := no_of_entries;
2279
 
        lookup := true;
2280
 
        while m<=n do
2281
 
          begin
2282
 
            k := m+(n-m) div 2;
2283
 
            if key=keys[k] then
2284
 
              begin
2285
 
                tok := toks[k];
2286
 
                exit
2287
 
              end
2288
 
            else if key>keys[k] then
2289
 
              m := k+1
2290
 
            else
2291
 
              n := k-1
2292
 
          end;
2293
 
        lookup := false
2294
 
      end(*lookup*);
2295
 
    var
2296
 
      keywstr : String;
2297
 
      tok : integer;
2298
 
    begin
2299
 
      inc(cno);
2300
 
      if cno<=length(line) then
2301
 
        case line[cno] of
2302
 
          '<' :
2303
 
            begin
2304
 
              scan_keyword := PLEFT;
2305
 
              inc(cno)
2306
 
            end;
2307
 
          '>' :
2308
 
            begin
2309
 
              scan_keyword := PRIGHT;
2310
 
              inc(cno)
2311
 
            end;
2312
 
          '=' :
2313
 
            begin
2314
 
              scan_keyword := PPREC;
2315
 
              inc(cno)
2316
 
            end;
2317
 
          '%', '\' :
2318
 
            begin
2319
 
              scan_keyword := PP;
2320
 
              inc(cno)
2321
 
            end;
2322
 
          '{' :
2323
 
            begin
2324
 
              scan_keyword := LCURL;
2325
 
              inc(cno)
2326
 
            end;
2327
 
          '}' :
2328
 
            begin
2329
 
              scan_keyword := RCURL;
2330
 
              inc(cno)
2331
 
            end;
2332
 
          'A'..'Z', 'a'..'z', '0'..'9' :
2333
 
            begin
2334
 
              keywstr := line[cno];
2335
 
              inc(cno);
2336
 
              while (cno<=length(line)) and (
2337
 
                    ('A'<=upCase(line[cno])) and (upCase(line[cno])<='Z') or
2338
 
                    ('0'<=line[cno]) and (line[cno]<='Z') ) do
2339
 
                begin
2340
 
                  keywstr := keywstr+line[cno];
2341
 
                  inc(cno)
2342
 
                end;
2343
 
              if lookup(keywstr, tok) then
2344
 
                scan_keyword := tok
2345
 
              else
2346
 
                scan_keyword := ILLEGAL
2347
 
            end;
2348
 
          else scan_keyword := ILLEGAL
2349
 
        end
2350
 
      else
2351
 
        scan_keyword := ILLEGAL;
2352
 
    end(*scan_keyword*);
2353
 
  function scan_char : integer;
2354
 
    (* scan any single character *)
2355
 
    begin
2356
 
      scan_char := ord(line[cno]);
2357
 
      inc(cno)
2358
 
    end(*scan_char*);
2359
 
  var lno0, cno0 : integer;
2360
 
  begin
2361
 
    tokleng := 0;
2362
 
    scan;
2363
 
    lno0 := lno; cno0 := cno;
2364
 
    if end_of_input then
2365
 
      yylex := 0
2366
 
    else
2367
 
      case line[cno] of
2368
 
        'A'..'Z', 'a'..'z', '_' : yylex := scan_ident;
2369
 
        '''', '"' : yylex := scan_literal;
2370
 
        '0'..'9' : yylex := scan_num;
2371
 
        '%', '\' : yylex := scan_keyword;
2372
 
        '=' :
2373
 
          if (cno<length(line)) and (line[succ(cno)]='{') then
2374
 
            begin
2375
 
              inc(cno);
2376
 
              yylex := scan_char
2377
 
            end
2378
 
          else
2379
 
            yylex := scan_char;
2380
 
        else yylex := scan_char;
2381
 
      end;
2382
 
    if lno=lno0 then
2383
 
      tokleng := cno-cno0
2384
 
  end(*yylex*);
2385
 
 
2386
 
(* Main program: *)
2387
 
 
2388
 
var i : Integer;
2389
 
 
2390
 
begin
2391
 
{$ifdef Unix}
2392
 
 {$ifdef BSD}
2393
 
  codfilepath:='/usr/local/lib/fpc/lexyacc/';
2394
 
 {$else}
2395
 
  codfilepath:='/usr/lib/fpc/lexyacc/';
2396
 
 {$endif}
2397
 
{$else}
2398
 
  codfilepath:=path(paramstr(0));
2399
 
{$endif}
2400
 
 
2401
 
  (* sign-on: *)
2402
 
 
2403
 
  writeln(sign_on);
2404
 
 
2405
 
  (* parse command line: *)
2406
 
 
2407
 
  if paramCount=0 then
2408
 
    begin
2409
 
      writeln(usage);
2410
 
      writeln(options);
2411
 
      halt(0);
2412
 
    end;
2413
 
 
2414
 
  yfilename := '';
2415
 
  pasfilename := '';
2416
 
 
2417
 
  for i := 1 to paramCount do
2418
 
    if copy(paramStr(i), 1, 1)='-' then
2419
 
      if upper(paramStr(i))='-V' then
2420
 
        verbose := true
2421
 
      else if upper(paramStr(i))='-D' then
2422
 
        debug := true
2423
 
      else
2424
 
        begin
2425
 
          writeln(invalid_option, paramStr(i));
2426
 
          halt(1);
2427
 
        end
2428
 
    else if yfilename='' then
2429
 
      yfilename := addExt(paramStr(i), 'y')
2430
 
    else if pasfilename='' then
2431
 
      pasfilename := addExt(paramStr(i), 'pas')
2432
 
    else
2433
 
      begin
2434
 
        writeln(illegal_no_args);
2435
 
        halt(1);
2436
 
      end;
2437
 
 
2438
 
  if yfilename='' then
2439
 
    begin
2440
 
      writeln(illegal_no_args);
2441
 
      halt(1);
2442
 
    end;
2443
 
 
2444
 
  if pasfilename='' then pasfilename := root(yfilename)+'.pas';
2445
 
  lstfilename := root(yfilename)+'.lst';
2446
 
 
2447
 
  (* open files: *)
2448
 
 
2449
 
  assign(yyin, yfilename);
2450
 
  assign(yyout, pasfilename);
2451
 
  assign(yylst, lstfilename);
2452
 
 
2453
 
  reset(yyin);    if ioresult<>0 then fatal(cannot_open_file+yfilename);
2454
 
  rewrite(yyout); if ioresult<>0 then fatal(cannot_open_file+pasfilename);
2455
 
  rewrite(yylst); if ioresult<>0 then fatal(cannot_open_file+lstfilename);
2456
 
 
2457
 
  (* search code template in current directory, then on path where Yacc
2458
 
     was executed from: *)
2459
 
  codfilename := 'yyparse.cod';
2460
 
  assign(yycod, codfilename);
2461
 
  reset(yycod);
2462
 
  if ioresult<>0 then
2463
 
    begin
2464
 
      codfilename := codfilepath+'yyparse.cod';
2465
 
      assign(yycod, codfilename);
2466
 
      reset(yycod);
2467
 
      if ioresult<>0 then fatal(cannot_open_file+codfilename);
2468
 
    end;
2469
 
 
2470
 
  (* parse source grammar: *)
2471
 
 
2472
 
  write('parse ... ');
2473
 
 
2474
 
  lno := 0; cno := 1; line := '';
2475
 
 
2476
 
  next_section;
2477
 
  if debug then writeln(yyout, '{$define yydebug}');
2478
 
 
2479
 
  if yyparse=0 then
2480
 
    { done }
2481
 
  else if yychar=0 then
2482
 
    error(unexpected_eof)
2483
 
  else
2484
 
    error(syntax_error);
2485
 
 
2486
 
  if errors=0 then writeln('DONE');
2487
 
 
2488
 
  (* close files: *)
2489
 
 
2490
 
  close(yyin); close(yyout); close(yylst); close(yycod);
2491
 
 
2492
 
  (* print statistics: *)
2493
 
 
2494
 
  if errors>0 then
2495
 
    writeln( lno, ' lines, ',
2496
 
             errors, ' errors found.' )
2497
 
  else
2498
 
    begin
2499
 
      writeln( lno, ' lines, ',
2500
 
               n_rules-1, '/', max_rules-1, ' rules, ',
2501
 
               n_states, '/', max_states, ' s, ',
2502
 
               n_items, '/', max_items, ' i, ',
2503
 
               n_trans, '/', max_trans, ' t, ',
2504
 
               n_redns, '/', max_redns, ' r.');
2505
 
      if shift_reduce>0 then
2506
 
        writeln(shift_reduce, ' shift/reduce conflicts.');
2507
 
      if reduce_reduce>0 then
2508
 
        writeln(reduce_reduce, ' reduce/reduce conflicts.');
2509
 
      if never_reduced>0 then
2510
 
        writeln(never_reduced, ' rules never reduced.');
2511
 
    end;
2512
 
 
2513
 
  if warnings>0 then writeln(warnings, ' warnings.');
2514
 
 
2515
 
{$ifndef fpc}
2516
 
{$IFNDEF Win32}
2517
 
  writeln( n_bytes, '/', max_bytes, ' bytes of memory used.');
2518
 
{$ENDIF}
2519
 
{$endif}
2520
 
 
2521
 
  (* terminate: *)
2522
 
 
2523
 
  if errors>0 then
2524
 
    begin
2525
 
      erase(yyout);
2526
 
      if ioresult<>0 then ;
2527
 
    end;
2528
 
 
2529
 
  if file_size(lstfilename)=0 then
2530
 
    erase(yylst)
2531
 
  else
2532
 
    writeln('(see ', lstfilename, ' for more information)');
2533
 
 
2534
 
  halt(errors);
2535
 
 
2536
 
end(*Yacc*).