![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pas.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / pascal / src|
Return to pas.y CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / pascal / src |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: *
6: * @(#)pas.y 5.4 (Berkeley) 1/3/88
7: */
8:
9: /*
10: * Yacc grammar for UNIX Pascal
11: *
12: * This grammar is processed by the commands in the shell script
13: * "gram" to yield parse tables and semantic routines in the file
14: * "y.tab.c" and a header defining the lexical tokens in "yy.h".
15: *
16: * In order for the syntactic error recovery possible with this
17: * grammar to work, the grammar must be processed by a yacc which
18: * has been modified to fully enumerate possibilities in states
19: * which involve the symbol "error".
20: * The parser used for Pascal also uses a different encoding of
21: * the test entries in the action table which speeds the parse.
22: * A version of yacc which will work for Pascal is included on
23: * the distribution table as "eyacc".
24: *
25: * The "gram" script also makes the following changes to the "y.tab.c"
26: * file:
27: *
28: * 1) Causes yyval to be declared int *.
29: *
30: * 2) Loads the variable yypv into a register as yyYpv so that
31: * the arguments $1, ... are available as yyYpv[1] etc.
32: * This produces much smaller code in the semantic actions.
33: *
34: * 3) Deletes the unused array yysterm.
35: *
36: * 4) Moves the declarations up to the flag line containing
37: * '##' to the file yy.h so that the routines which use
38: * these "magic numbers" don't have to all be compiled at
39: * the same time.
40: *
41: * 5) Creates the semantic restriction checking routine yyEactr
42: * by processing action lines containing `@@'.
43: *
44: * This compiler uses a different version of the yacc parser, a
45: * different yyerror which is called yerror, and requires more
46: * lookahead sets than normally provided by yacc.
47: *
48: * Source for the yacc used with this grammar is included on
49: * distribution tapes.
50: */
51:
52: /*
53: * TERMINAL DECLARATIONS
54: *
55: * Some of the terminal declarations are out of the most natural
56: * alphabetic order because the error recovery
57: * will guess the first of equal cost non-terminals.
58: * This makes, e.g. YTO preferable to YDOWNTO.
59: */
60:
61: %term
62: YAND YARRAY YBEGIN YCASE
63: YCONST YDIV YDO YDOTDOT
64: YTO YELSE YEND YFILE
65: YFOR YFORWARD YPROCEDURE YGOTO
66: YID YIF YIN YINT
67: YLABEL YMOD YNOT YNUMB
68: YOF YOR YPACKED YNIL
69: YFUNCTION YPROG YRECORD YREPEAT
70: YSET YSTRING YTHEN YDOWNTO
71: YTYPE YUNTIL YVAR YWHILE
72: YWITH YBINT YOCT YHEX
73: YCASELAB YILLCH YEXTERN YLAST
74:
75: /*
76: * PRECEDENCE DECLARATIONS
77: *
78: * Highest precedence is the unary logical NOT.
79: * Next are the multiplying operators, signified by '*'.
80: * Lower still are the binary adding operators, signified by '+'.
81: * Finally, at lowest precedence and non-associative are the relationals.
82: */
83:
84: %binary '<' '=' '>' YIN
85: %left '+' '-' YOR '|'
86: %left UNARYSIGN
87: %left '*' '/' YDIV YMOD YAND '&'
88: %left YNOT
89:
90: %{
91: /*
92: * GLOBALS FOR ACTIONS
93: */
94:
95: /* Copyright (c) 1979 Regents of the University of California */
96:
97: /* static char sccsid[] = "@(#)pas.y 5.4 1/3/88"; */
98:
99: /*
100: * The following line marks the end of the yacc
101: * Constant definitions which are removed from
102: * y.tab.c and placed in the file y.tab.h.
103: */
104: ##
105: /* Copyright (c) 1979 Regents of the University of California */
106:
107: static char sccsid[] = "@(#)pas.y 5.4 1/3/88";
108:
109: #include "whoami.h"
110: #include "0.h"
111: #include "tree_ty.h" /* must be included for yy.h */
112: #include "yy.h"
113: #include "tree.h"
114:
115: #ifdef PI
116: #define lineof(l) l
117: #define line2of(l) l
118: #endif
119:
120: %}
121:
122: %%
123:
124: /*
125: * PRODUCTIONS
126: */
127:
128: goal:
129: prog_hedr decls block '.'
130: = funcend($1.nl_entry, $3.tr_entry, lineof($4.i_entry));
131: |
132: decls
133: = segend();
134: ;
135:
136:
137: prog_hedr:
138: YPROG YID '(' id_list ')' ';'
139: = $$.nl_entry = funcbody(funchdr(tree5(T_PROG, lineof($1.i_entry), $2.tr_entry, fixlist($4.tr_entry), TR_NIL)));
140: |
141: YPROG YID ';'
142: = $$.nl_entry = funcbody(funchdr(tree5(T_PROG, lineof($1.i_entry), $2.tr_entry, TR_NIL, TR_NIL)));
143: |
144: YPROG error
145: = {
146: yyPerror("Malformed program statement", PPROG);
147: /*
148: * Should make a program statement
149: * with "input" and "output" here.
150: */
151: $$.nl_entry = funcbody(funchdr(tree5(T_PROG, lineof($1.i_entry), TR_NIL, TR_NIL, TR_NIL)));
152: }
153: ;
154: block:
155: YBEGIN stat_list YEND
156: = {
157: $$.tr_entry = tree3(T_BSTL, lineof($1.i_entry), fixlist($2.tr_entry));
158: if ($3.i_entry < 0)
159: brerror($1.i_entry, "begin");
160: }
161: ;
162:
163:
164: /*
165: * DECLARATION PART
166: */
167: decls:
168: decls decl
169: = trfree();
170: |
171: decls error
172: = {
173: constend(), typeend(), varend(), trfree();
174: yyPerror("Malformed declaration", PDECL);
175: }
176: |
177: /* lambda */
178: = trfree();
179: ;
180:
181: decl:
182: labels
183: |
184: const_decl
185: = constend();
186: |
187: type_decl
188: = typeend();
189: |
190: var_decl
191: = varend();
192: |
193: proc_decl
194: ;
195:
196: /*
197: * LABEL PART
198: */
199:
200: labels:
201: YLABEL label_decl ';'
202: = label(fixlist($2.tr_entry), lineof($1.i_entry));
203: ;
204: label_decl:
205: YINT
206: = $$.tr_entry = newlist($1.i_entry == NIL ? TR_NIL :
207: (struct tnode *) *hash($1.cptr, 1));
208: |
209: label_decl ',' YINT
210: = $$.tr_entry = addlist($1.tr_entry, $3.i_entry == NIL ?
211: TR_NIL : (struct tnode *) *hash($3.cptr, 1));
212: ;
213:
214: /*
215: * CONST PART
216: */
217:
218: const_decl:
219: YCONST YID '=' const ';'
220: = constbeg($1.i_entry, lineof($1.i_entry)),
221: constant(lineof($3.i_entry), $2.cptr, $4.tr_entry);
222: |
223: const_decl YID '=' const ';'
224: = constant(lineof($3.i_entry), $2.cptr, $4.tr_entry);
225: |
226: YCONST error
227: = {
228: constbeg($1.i_entry);
229: Cerror:
230: yyPerror("Malformed const declaration", PDECL);
231: }
232: |
233: const_decl error
234: = goto Cerror;
235: ;
236:
237: /*
238: * TYPE PART
239: */
240:
241: type_decl:
242: YTYPE YID '=' type ';'
243: = typebeg($1.i_entry, line2of($2.i_entry)), type(lineof($3.i_entry), $2.cptr, $4.tr_entry);
244: |
245: type_decl YID '=' type ';'
246: = type(lineof($3.i_entry), $2.cptr, $4.tr_entry);
247: |
248: YTYPE error
249: = {
250: typebeg($1.i_entry, line2of($1.i_entry));
251: Terror:
252: yyPerror("Malformed type declaration", PDECL);
253: }
254: |
255: type_decl error
256: = goto Terror;
257: ;
258:
259: /*
260: * VAR PART
261: */
262:
263: var_decl:
264: YVAR id_list ':' type ';'
265: = varbeg($1.i_entry, line2of($3.i_entry)), var(lineof($3.i_entry), fixlist($2.tr_entry), $4.tr_entry);
266: |
267: var_decl id_list ':' type ';'
268: = var(lineof($3.i_entry), fixlist($2.tr_entry), $4.tr_entry);
269: |
270: YVAR error
271: = {
272: varbeg($1.i_entry, line2of($1.i_entry));
273: Verror:
274: yyPerror("Malformed var declaration", PDECL);
275: }
276: |
277: var_decl error
278: = goto Verror;
279: ;
280:
281: /*
282: * PROCEDURE AND FUNCTION DECLARATION PART
283: */
284:
285: proc_decl:
286: phead YFORWARD ';'
287: = funcfwd($1.nl_entry);
288: |
289: phead YEXTERN ';'
290: = (void) funcext($1.nl_entry);
291: |
292: pheadres decls block ';'
293: = funcend($1.nl_entry, $3.tr_entry, lineof($4.i_entry));
294: |
295: phead error
296: ;
297: pheadres:
298: phead
299: = (void) funcbody($1.nl_entry);
300: ;
301: phead:
302: porf YID params ftype ';'
303: = $$.nl_entry = funchdr(tree5($1.i_entry, lineof($5.i_entry),
304: $2.tr_entry, $3.tr_entry, $4.tr_entry));
305: ;
306: porf:
307: YPROCEDURE
308: = $$.i_entry = T_PDEC;
309: |
310: YFUNCTION
311: = $$.i_entry = T_FDEC;
312: ;
313: params:
314: '(' param_list ')'
315: = $$.tr_entry = fixlist($2.tr_entry);
316: |
317: /* lambda */
318: = $$.tr_entry = TR_NIL;
319: ;
320:
321: /*
322: * PARAMETERS
323: */
324:
325: param:
326: id_list ':' type
327: = $$.tr_entry = tree3(T_PVAL, (int) fixlist($1.tr_entry), $3.tr_entry);
328: |
329: YVAR id_list ':' type
330: = $$.tr_entry = tree3(T_PVAR, (int) fixlist($2.tr_entry), $4.tr_entry);
331: |
332: YFUNCTION id_list params ftype
333: = $$.tr_entry = tree5(T_PFUNC, (int) fixlist($2.tr_entry),
334: $4.tr_entry, $3.tr_entry,
335: (struct tnode *) lineof($1.i_entry));
336: |
337: YPROCEDURE id_list params ftype
338: = $$.tr_entry = tree5(T_PPROC, (int) fixlist($2.tr_entry),
339: $4.tr_entry, $3.tr_entry,
340: (struct tnode *) lineof($1.i_entry));
341: ;
342: ftype:
343: ':' type
344: = $$ = $2;
345: |
346: /* lambda */
347: = $$.tr_entry = TR_NIL;
348: ;
349: param_list:
350: param
351: = $$.tr_entry = newlist($1.tr_entry);
352: |
353: param_list ';' param
354: = $$.tr_entry = addlist($1.tr_entry, $3.tr_entry);
355: ;
356:
357: /*
358: * CONSTANTS
359: */
360:
361: const:
362: YSTRING
363: = $$.tr_entry = tree2(T_CSTRNG, $1.i_entry);
364: |
365: number
366: |
367: '+' number
368: = $$.tr_entry = tree2(T_PLUSC, $2.i_entry);
369: |
370: '-' number
371: = $$.tr_entry = tree2(T_MINUSC, $2.i_entry);
372: ;
373: number:
374: const_id
375: = $$.tr_entry = tree2(T_ID, $1.i_entry);
376: |
377: YINT
378: = $$.tr_entry = tree2(T_CINT, $1.i_entry);
379: |
380: YBINT
381: = $$.tr_entry = tree2(T_CBINT, $1.i_entry);
382: |
383: YNUMB
384: = $$.tr_entry = tree2(T_CFINT, $1.i_entry);
385: ;
386: const_list:
387: const
388: = $$.tr_entry = newlist($1.tr_entry);
389: |
390: const_list ',' const
391: = $$.tr_entry = addlist($1.tr_entry, $3.tr_entry);
392: ;
393:
394: /*
395: * TYPES
396: */
397:
398: type:
399: simple_type
400: |
401: '^' YID
402: = $$.tr_entry = tree3(T_TYPTR, lineof($1.i_entry), tree2(T_ID,
403: $2.i_entry));
404: |
405: struct_type
406: |
407: YPACKED struct_type
408: = $$.tr_entry = tree3(T_TYPACK, lineof($1.i_entry), $2.tr_entry);
409: ;
410: simple_type:
411: type_id
412: |
413: '(' id_list ')'
414: = $$.tr_entry = tree3(T_TYSCAL, lineof($1.i_entry), fixlist($2.tr_entry));
415: |
416: const YDOTDOT const
417: = $$.tr_entry = tree4(T_TYRANG, lineof($2.i_entry), $1.tr_entry,
418: $3.tr_entry);
419: ;
420: struct_type:
421: YARRAY '[' simple_type_list ']' YOF type
422: = $$.tr_entry = tree4(T_TYARY, lineof($1.i_entry),
423: fixlist($3.tr_entry), $6.tr_entry);
424: |
425: YFILE YOF type
426: = $$.tr_entry = tree3(T_TYFILE, lineof($1.i_entry), $3.tr_entry);
427: |
428: YSET YOF simple_type
429: = $$.tr_entry = tree3(T_TYSET, lineof($1.i_entry), $3.tr_entry);
430: |
431: YRECORD field_list YEND
432: = {
433: $$.tr_entry = setuptyrec( lineof( $1.i_entry ) , $2.tr_entry);
434: if ($3.i_entry < 0)
435: brerror($1.i_entry, "record");
436: }
437: ;
438: simple_type_list:
439: simple_type
440: = $$.tr_entry = newlist($1.tr_entry);
441: |
442: simple_type_list ',' simple_type
443: = $$.tr_entry = addlist($1.tr_entry, $3.tr_entry);
444: ;
445:
446: /*
447: * RECORD TYPE
448: */
449: field_list:
450: fixed_part variant_part
451: = $$.tr_entry = tree4(T_FLDLST, lineof(NIL),
452: fixlist($1.tr_entry), $2.tr_entry);
453: ;
454: fixed_part:
455: field
456: = $$.tr_entry = newlist($1.tr_entry);
457: |
458: fixed_part ';' field
459: = $$.tr_entry = addlist($1.tr_entry, $3.tr_entry);
460: |
461: fixed_part error
462: = yyPerror("Malformed record declaration", PDECL);
463: ;
464: field:
465: /* lambda */
466: = $$.tr_entry = TR_NIL;
467: |
468: id_list ':' type
469: = $$.tr_entry = tree4(T_RFIELD, lineof($2.i_entry),
470: fixlist($1.tr_entry), $3.tr_entry);
471: ;
472:
473: variant_part:
474: /* lambda */
475: = $$.tr_entry = TR_NIL;
476: |
477: YCASE type_id YOF variant_list
478: = $$.tr_entry = tree5(T_TYVARPT, lineof($1.i_entry), TR_NIL,
479: $2.tr_entry, fixlist($4.tr_entry));
480: |
481: YCASE YID ':' type_id YOF variant_list
482: = $$.tr_entry = tree5(T_TYVARPT, lineof($1.i_entry),
483: $2.tr_entry, $4.tr_entry,
484: fixlist($6.tr_entry));
485: ;
486: variant_list:
487: variant
488: = $$.tr_entry = newlist($1.tr_entry);
489: |
490: variant_list ';' variant
491: = $$.tr_entry = addlist($1.tr_entry, $3.tr_entry);
492: |
493: variant_list error
494: = yyPerror("Malformed record declaration", PDECL);
495: ;
496: variant:
497: /* lambda */
498: = $$.tr_entry = TR_NIL;
499: |
500: const_list ':' '(' field_list ')'
501: = $$.tr_entry = tree4(T_TYVARNT,lineof($2.i_entry), fixlist($1.tr_entry),
502: $4.tr_entry);
503: ;
504:
505: /*
506: * STATEMENT LIST
507: */
508:
509: stat_list:
510: stat
511: = $$.tr_entry = newlist($1.tr_entry);
512: |
513: stat_lsth stat
514: = {
515: if ((p = $1.tr_entry) != TR_NIL && (q = p->list_node.list)->tag == T_IFX) {
516: q->tag = T_IFEL;
517: q->if_node.else_stmnt = $2.tr_entry;
518: } else
519: $$.tr_entry= addlist($1.tr_entry, $2.tr_entry);
520: }
521: ;
522:
523: stat_lsth:
524: stat_list ';'
525: = if ((q = $1.tr_entry) != TR_NIL && (p = q->list_node.list) != TR_NIL && p->tag == T_IF) {
526: if (yychar < 0)
527: yychar = yylex();
528: if (yyshifts >= 2 && yychar == YELSE) {
529: recovered();
530: copy((char *) (&Y), (char *) (&OY), sizeof Y);
531: yerror("Deleted ';' before keyword else");
532: yychar = yylex();
533: p->tag = T_IFX;
534: }
535: }
536: ;
537:
538: /*
539: * CASE STATEMENT LIST
540: */
541:
542: cstat_list:
543: cstat
544: = $$.tr_entry = newlist($1.tr_entry);
545: |
546: cstat_list ';' cstat
547: = $$.tr_entry = addlist($1.tr_entry, $3.tr_entry);
548: |
549: error
550: = {
551: $$.tr_entry = TR_NIL;
552: Kerror:
553: yyPerror("Malformed statement in case", PSTAT);
554: }
555: |
556: cstat_list error
557: = goto Kerror;
558: ;
559:
560: cstat:
561: const_list ':' stat
562: = $$.tr_entry = tree4(T_CSTAT, lineof($2.i_entry),
563: fixlist($1.tr_entry), $3.tr_entry);
564: |
565: YCASELAB stat
566: = $$.tr_entry = tree4(T_CSTAT, lineof($1.i_entry), TR_NIL,
567: $2.tr_entry);
568: |
569: /* lambda */
570: = $$.tr_entry = TR_NIL;
571: ;
572:
573: /*
574: * STATEMENT
575: */
576:
577: stat:
578: /* lambda */
579: = $$.tr_entry = TR_NIL;
580: |
581: YINT ':' stat
582: = $$.tr_entry = tree4(T_LABEL, lineof($2.i_entry),
583: $1.tr_entry == TR_NIL ? TR_NIL :
584: (struct tnode *) *hash($1.cptr, 1), $3.tr_entry);
585: |
586: proc_id
587: = $$.tr_entry = tree4(T_PCALL, lineof(yyline), $1.tr_entry,
588: TR_NIL);
589: |
590: proc_id '(' wexpr_list ')'
591: = $$.tr_entry = tree4(T_PCALL, lineof($2.i_entry), $1.tr_entry,
592: fixlist($3.tr_entry));
593: |
594: YID error
595: = goto NSerror;
596: |
597: assign
598: |
599: YBEGIN stat_list YEND
600: = {
601: $$.tr_entry = tree3(T_BLOCK, lineof($1.i_entry),
602: fixlist($2.tr_entry));
603: if ($3.i_entry < 0)
604: brerror($1.i_entry, "begin");
605: }
606: |
607: YCASE expr YOF cstat_list YEND
608: = {
609: $$.tr_entry = tree4(T_CASE, lineof($1.i_entry),
610: $2.tr_entry, fixlist($4.tr_entry));
611: if ($5.i_entry < 0)
612: brerror($1.i_entry, "case");
613: }
614: |
615: YWITH var_list YDO stat
616: = $$.tr_entry = tree4(T_WITH, lineof($1.i_entry),
617: fixlist($2.tr_entry), $4.tr_entry);
618: |
619: YWHILE expr YDO stat
620: = $$.tr_entry = tree4(T_WHILE, lineof($1.i_entry), $2.tr_entry,
621: $4.tr_entry);
622: |
623: YREPEAT stat_list YUNTIL expr
624: = $$.tr_entry = tree4(T_REPEAT, lineof($3.i_entry),
625: fixlist($2.tr_entry), $4.tr_entry);
626: |
627: YFOR assign YTO expr YDO stat
628: = $$.tr_entry = tree5(T_FORU, lineof($1.i_entry), $2.tr_entry,
629: $4.tr_entry, $6.tr_entry);
630: |
631: YFOR assign YDOWNTO expr YDO stat
632: = $$.tr_entry = tree5(T_FORD, lineof($1.i_entry), $2.tr_entry,
633: $4.tr_entry, $6.tr_entry);
634: |
635: YGOTO YINT
636: = $$.tr_entry = tree3(T_GOTO, lineof($1.i_entry),
637: (struct tnode *) *hash($2.cptr, 1));
638: |
639: YIF expr YTHEN stat
640: = $$.tr_entry = tree5(T_IF, lineof($1.i_entry), $2.tr_entry,
641: $4.tr_entry, TR_NIL);
642: |
643: YIF expr YTHEN stat YELSE stat
644: = $$.tr_entry = tree5(T_IFEL, lineof($1.i_entry), $2.tr_entry,
645: $4.tr_entry, $6.tr_entry);
646: |
647: error
648: = {
649: NSerror:
650: $$.tr_entry = TR_NIL;
651: yyPerror("Malformed statement", PSTAT);
652: }
653: ;
654: assign:
655: variable ':' '=' expr
656: = $$.tr_entry = tree4(T_ASGN, lineof($2.i_entry), $1.tr_entry,
657: $4.tr_entry);
658: ;
659:
660: /*
661: * EXPRESSION
662: */
663:
664: expr:
665: error
666: = {
667: NEerror:
668: $$.tr_entry = TR_NIL;
669: yyPerror("Missing/malformed expression", PEXPR);
670: }
671: |
672: expr relop expr %prec '<'
673: = $$.tr_entry = tree4($2.i_entry,
674: $1.tr_entry->expr_node.const_tag == SAWCON ?
675: $3.tr_entry->expr_node.const_tag :
676: $1.tr_entry->expr_node.const_tag,
677: $1.tr_entry, $3.tr_entry);
678: |
679: '+' expr %prec UNARYSIGN
680: = $$.tr_entry = tree3(T_PLUS, $2.tr_entry->expr_node.const_tag,
681: $2.tr_entry);
682: |
683: '-' expr %prec UNARYSIGN
684: = $$.tr_entry = tree3(T_MINUS, $2.tr_entry->expr_node.const_tag,
685: $2.tr_entry);
686: |
687: expr addop expr %prec '+'
688: = $$.tr_entry = tree4($2.i_entry,
689: $1.tr_entry->expr_node.const_tag == SAWCON ?
690: $3.tr_entry->expr_node.const_tag :
691: $1.tr_entry->expr_node.const_tag, $1.tr_entry,
692: $3.tr_entry);
693: |
694: expr divop expr %prec '*'
695: = $$.tr_entry = tree4($2.i_entry,
696: $1.tr_entry->expr_node.const_tag == SAWCON ?
697: $3.tr_entry->expr_node.const_tag :
698: $1.tr_entry->expr_node.const_tag, $1.tr_entry,
699: $3.tr_entry);
700: |
701: YNIL
702: = $$.tr_entry = tree2(T_NIL, NOCON);
703: |
704: YSTRING
705: = $$.tr_entry = tree3(T_STRNG, SAWCON, $1.tr_entry);
706: |
707: YINT
708: = $$.tr_entry = tree3(T_INT, NOCON, $1.tr_entry);
709: |
710: YBINT
711: = $$.tr_entry = tree3(T_BINT, NOCON, $1.tr_entry);
712: |
713: YNUMB
714: = $$.tr_entry = tree3(T_FINT, NOCON, $1.tr_entry);
715: |
716: variable
717: |
718: YID error
719: = goto NEerror;
720: |
721: func_id '(' wexpr_list ')'
722: = $$.tr_entry = tree4(T_FCALL, NOCON, $1.tr_entry,
723: fixlist($3.tr_entry));
724: |
725: '(' expr ')'
726: = $$.tr_entry = $2.tr_entry;
727: |
728: negop expr %prec YNOT
729: = $$.tr_entry = tree3(T_NOT, NOCON, $2.tr_entry);
730: |
731: '[' element_list ']'
732: = $$.tr_entry = tree3(T_CSET, SAWCON, fixlist($2.tr_entry));
733: |
734: '[' ']'
735: = $$.tr_entry = tree3(T_CSET, SAWCON, TR_NIL);
736: ;
737:
738: element_list:
739: element
740: = $$.tr_entry = newlist($1.tr_entry);
741: |
742: element_list ',' element
743: = $$.tr_entry = addlist($1.tr_entry, $3.tr_entry);
744: ;
745: element:
746: expr
747: |
748: expr YDOTDOT expr
749: = $$.tr_entry = tree3(T_RANG, $1.i_entry, $3.tr_entry);
750: ;
751:
752: /*
753: * QUALIFIED VARIABLES
754: */
755:
756: variable:
757: YID
758: = {
759: @@ return (identis(var, VAR));
760: $$.tr_entry = setupvar($1.cptr, TR_NIL);
761: }
762: |
763: qual_var
764: = $1.tr_entry->var_node.qual =
765: fixlist($1.tr_entry->var_node.qual);
766: ;
767: qual_var:
768: array_id '[' expr_list ']'
769: = $$.tr_entry = setupvar($1.cptr, tree2(T_ARY,
770: (int) fixlist($3.tr_entry)));
771: |
772: qual_var '[' expr_list ']'
773: = $1.tr_entry->var_node.qual =
774: addlist($1.tr_entry->var_node.qual,
775: tree2(T_ARY, (int) fixlist($3.tr_entry)));
776: |
777: record_id '.' field_id
778: = $$.tr_entry = setupvar($1.cptr, setupfield($3.tr_entry,
779: TR_NIL));
780: |
781: qual_var '.' field_id
782: = $1.tr_entry->var_node.qual =
783: addlist($1.tr_entry->var_node.qual,
784: setupfield($3.tr_entry, TR_NIL));
785: |
786: ptr_id '^'
787: = $$.tr_entry = setupvar($1.cptr, tree1(T_PTR));
788: |
789: qual_var '^'
790: = $1.tr_entry->var_node.qual =
791: addlist($1.tr_entry->var_node.qual, tree1(T_PTR));
792: ;
793:
794: /*
795: * Expression with write widths
796: */
797: wexpr:
798: expr
799: |
800: expr ':' expr
801: = $$.tr_entry = tree4(T_WEXP, $1.i_entry, $3.tr_entry, TR_NIL);
802: |
803: expr ':' expr ':' expr
804: = $$.tr_entry = tree4(T_WEXP, $1.i_entry, $3.tr_entry,
805: $5.tr_entry);
806: |
807: expr octhex
808: = $$.tr_entry = tree4(T_WEXP, $1.i_entry, TR_NIL, $2.tr_entry);
809: |
810: expr ':' expr octhex
811: = $$.tr_entry = tree4(T_WEXP, $1.i_entry, $3.tr_entry,
812: $4.tr_entry);
813: ;
814: octhex:
815: YOCT
816: = $$.i_entry = OCT;
817: |
818: YHEX
819: = $$.i_entry = HEX;
820: ;
821:
822: expr_list:
823: expr
824: = $$.tr_entry = newlist($1.tr_entry);
825: |
826: expr_list ',' expr
827: = $$.tr_entry = addlist($1.tr_entry, $3.tr_entry);
828: ;
829:
830: wexpr_list:
831: wexpr
832: = $$.tr_entry = newlist($1.tr_entry);
833: |
834: wexpr_list ',' wexpr
835: = $$.tr_entry = addlist($1.tr_entry, $3.tr_entry);
836: ;
837:
838: /*
839: * OPERATORS
840: */
841:
842: relop:
843: '=' = $$.i_entry = T_EQ;
844: |
845: '<' = $$.i_entry = T_LT;
846: |
847: '>' = $$.i_entry = T_GT;
848: |
849: '<' '>' = $$.i_entry = T_NE;
850: |
851: '<' '=' = $$.i_entry = T_LE;
852: |
853: '>' '=' = $$.i_entry = T_GE;
854: |
855: YIN = $$.i_entry = T_IN;
856: ;
857: addop:
858: '+' = $$.i_entry = T_ADD;
859: |
860: '-' = $$.i_entry = T_SUB;
861: |
862: YOR = $$.i_entry = T_OR;
863: |
864: '|' = $$.i_entry = T_OR;
865: ;
866: divop:
867: '*' = $$.i_entry = T_MULT;
868: |
869: '/' = $$.i_entry = T_DIVD;
870: |
871: YDIV = $$.i_entry = T_DIV;
872: |
873: YMOD = $$.i_entry = T_MOD;
874: |
875: YAND = $$.i_entry = T_AND;
876: |
877: '&' = $$.i_entry = T_AND;
878: ;
879:
880: negop:
881: YNOT
882: |
883: '~'
884: ;
885:
886: /*
887: * LISTS
888: */
889:
890: var_list:
891: variable
892: = $$.tr_entry = newlist($1.tr_entry);
893: |
894: var_list ',' variable
895: = $$.tr_entry = addlist($1.tr_entry, $3.tr_entry);
896: ;
897:
898: id_list:
899: YID
900: = $$.tr_entry = newlist($1.tr_entry);
901: |
902: id_list ',' YID
903: = $$.tr_entry = addlist($1.tr_entry, $3.tr_entry);
904: ;
905:
906: /*
907: * Identifier productions with semantic restrictions
908: *
909: * For these productions, the characters @@ signify
910: * that the associated C statement is to provide
911: * the semantic restriction for this reduction.
912: * These lines are made into a procedure yyEactr, similar to
913: * yyactr, which determines whether the corresponding reduction
914: * is permitted, or whether an error is to be signaled.
915: * A zero return from yyEactr is considered an error.
916: * YyEactr is called with an argument "var" giving the string
917: * name of the variable in question, essentially $1, although
918: * $1 will not work because yyEactr is called from loccor in
919: * the recovery routines.
920: */
921:
922: const_id:
923: YID
924: = @@ return (identis(var, CONST));
925: ;
926: type_id:
927: YID
928: = {
929: @@ return (identis(var, TYPE));
930: $$.tr_entry = tree3(T_TYID, lineof(yyline), $1.tr_entry);
931: }
932: ;
933: var_id:
934: YID
935: = @@ return (identis(var, VAR));
936: ;
937: array_id:
938: YID
939: = @@ return (identis(var, ARRAY));
940: ;
941: ptr_id:
942: YID
943: = @@ return (identis(var, PTRFILE));
944: ;
945: record_id:
946: YID
947: = @@ return (identis(var, RECORD));
948: ;
949: field_id:
950: YID
951: = @@ return (identis(var, FIELD));
952: ;
953: proc_id:
954: YID
955: = @@ return (identis(var, PROC));
956: ;
957: func_id:
958: YID
959: = @@ return (identis(var, FUNC));
960: ;
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.