![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to grammar.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ingres / source / equel|
Return to grammar.y CVS log | Up to [CSRG BSD Unix] / 42BSD / ingres / source / equel |
1.1 root 1: /*
2: ** GRAMMAR.Y -- Equel 6.2 grammar
3: **
4: ** Yacc grammar and semantic rules for Quel
5: ** embedded in C.
6: **
7: ** The grammar is organized in the following manner:
8: ** a) control structure
9: ** b) quel statments
10: ** c) equel statements
11: ** d) declaration and use of C vars
12: ** e) special objects
13: ** f) expressions
14: ** g) keywords
15: ** h) noise words and punctuation
16: ** Within a single classification, major objects are ordered
17: ** alphabetically, and minor objects under the major ones they
18: ** are in.
19: **
20: ** Side Effects:
21: ** performs the translation of an Equel program into
22: ** a C program with calls on the Equel run-time
23: ** support
24: **
25: ** NOTE:
26: ** There are two shift/reduce conflicts associated
27: ** with the non-terminals "[o_]gen_while". It is resolved
28: ** correctly by yacc.
29: */
30:
31:
32:
33: %{
34: /* STANDARD SCANNER & PARSER GLOBALS */
35:
36: # include "constants.h"
37: # include <stdio.h>
38: # include "globals.h"
39: # include <sccs.h>
40:
41: SCCSID(@(#)grammar.y 7.1 2/5/81)
42:
43:
44: %}
45: %union
46: {
47: struct disp_node *u_dn;
48: };
49:
50:
51: /* QUEL keywords */
52: %token <u_dn> APPEND COPY CREATE DEFINE
53: %token <u_dn> DELETE DESTROY HELP INDEX
54: %token <u_dn> MODIFY PRINT INTEGRITY RANGE
55: %token <u_dn> REPLACE RETRIEVE SAVE UNIQUE
56: %token <u_dn> PERMIT VIEW
57:
58: /* special embedded QUEL commands */
59: %token <u_dn> INGRES EXIT PARAM
60:
61: /* C variable usages */
62: %token <u_dn> TYPE ALLOC STRUCT STRUCT_VAR
63:
64: /* QUEL noise words */
65: %token <u_dn> ALL BY FROM IN
66: %token <u_dn> INTO IS OF ON
67: %token <u_dn> ONTO TO WHERE UNTIL
68: %token <u_dn> AT
69:
70: /* constants */
71:
72: %token <u_dn> NAME SCONST I2CONST I4CONST
73: %token <u_dn> F8CONST C_CODE
74:
75: /* punctuation */
76: %token <u_dn> COMMA LPAREN RPAREN PERIOD
77: %token <u_dn> QUOTE BGNCMNT ENDCMNT LBRACE
78: %token <u_dn> RBRACE LBRKT RBRKT NONREF
79: %token <u_dn> SEMICOL POINTER COLON
80:
81: /* operator classes */
82: %token <u_dn> UOP
83: %token <u_dn> BOP
84: %token <u_dn> BDOP
85: %token <u_dn> EOP
86: %token <u_dn> LBOP LUOP
87: %token <u_dn> FOP FBOP
88: %token <u_dn> AOP
89:
90: /* define ascending precedence for operators */
91:
92: %left LBOP
93: %left LUOP
94: %left BOP LBRKT
95: %left UOP
96: %nonassoc unaryop
97:
98: /* non-teriminal type info */
99: %type <u_dn> endblock
100: %type <u_dn> c_variable
101: %type <u_dn> cvarx
102: %type <u_dn> struct_var
103: %type <u_dn> ptr
104: %type <u_dn> selector_part
105: %type <u_dn> str_var_key
106: %type <u_dn> id
107:
108:
109:
110: %%
111: %{
112: struct cvar *cvarp;
113: %}
114:
115: /*
116: * Program Control Structure
117: */
118:
119: program: program statement =
120: {
121: /* for each "statement", free the symbol space
122: * used by that query (lookahed space must not
123: * be freed), and catch up on output lines
124: */
125: symspfree();
126: equate_lines();
127: }
128: | ;
129: ;
130: statement: startquel quel_statement =
131: {
132: w_sync();
133: /* the purpose of the actions for startquel
134: * and this action is to make each query
135: * a single compound C statement (if (x) "{query}")
136: */
137: w_op("}");
138: }
139: | startquel equel_statement =
140: {
141: end_quote();
142: w_op("}");
143: }
144: | c_code
145: | declaration
146: | error
147: ;
148: startquel: =
149: w_op("{");
150: ;
151: /*
152: * C_CODE is a token returned by the lexical analyzer
153: * when it recognizes that the following line is not
154: * equel code. On the NEXT call to the lexical analyzer,
155: * the code will be copied from the source to the output file.
156: */
157: c_code: C_CODE
158: | beginblock =
159: Block_level += 1;
160: | endblock =
161: {
162: if (Block_level == 0)
163: yyserror("extra '}'", $1);
164: else if ((Block_level -= 1) == 0)
165: {
166: freecvar(&C_locals);
167: freecvar(&F_locals);
168: }
169: }
170: ;
171:
172: /* the %prec is to resolve conflicts with the { after a
173: * "tupret".
174: */
175: beginblock: LBRACE %prec LBOP =
176: w_op($1->d_elm);
177: ;
178: endblock: RBRACE =
179: w_op($1->d_elm);
180: ;
181: quel_statement: append
182: | copy
183: | create
184: | delete
185: | destroy
186: | help
187: | index
188: | integrity
189: | modify
190: | permit
191: | print
192: | range
193: | replace
194: | retrieve
195: | save
196: | view
197: ;
198:
199: /* commands particular to Equel */
200:
201: equel_statement:append_p
202: | copy_p
203: | create_p
204: | exit
205: | ingres
206: | replace_p
207: | retrieve_p
208: | tupret
209: | view_p
210: ;
211: /*
212: * QUEL statements
213: */
214:
215: append: append_key apclause tlclause qualclause
216: ;
217: apclause: apkword id
218: ;
219:
220: copy: copy_key id lparen ctl rparen cp_kword filename
221: | copy_key id lparen rparen cp_kword filename
222: ;
223: filename: sconst
224: | id
225: ;
226:
227: create: create_key id lparen ctl rparen
228: ;
229:
230: delete: delete_key delclause qualclause
231: ;
232: delclause: delnoise id
233: ;
234:
235: destroy: destroy_key idlist
236: | destroy_key integ_permit id int_list_all
237: ;
238: integ_permit: integ_key
239: | permit_key
240: ;
241: int_list_all: int_list
242: | all
243: ;
244:
245: help: help_key
246: | help_key all
247: | help_key hlist
248: | help_key int_perm_view idlist
249: ;
250: hlist: hparam
251: | hlist comma hparam
252: ;
253: hparam: id
254: | sconst
255: ;
256: int_perm_view: integ_permit
257: | view_key
258: ;
259:
260: index: index_key id is id lparen idlist rparen
261: ;
262:
263: integrity: define_key integ_key integnoise id isnoise qual
264: ;
265:
266: modify: modify_key id to id on modkeylist density
267: | modify_key id to id
268: ;
269: modkeylist: modkey
270: | modkeylist comma modkey
271: ;
272: modkey: id
273: | id colon id
274: ;
275: density: where modfill
276: | ;
277: ;
278: modfill: id is mod_var
279: | modfill comma id is mod_var
280: ;
281: /* mod_var can be an integer constant or var, or a string var
282: * or a quel name
283: */
284: mod_var: I2CONST =
285: w_con(I2CONST, $1->d_elm);
286: | c_variable =
287: {
288: if ($1)
289: {
290: if (!Cvarp)
291: w_key($1->d_elm);
292: else if (Fieldp && Fieldp->c_type == opINT
293: || Cvarp->c_type == opINT)
294: w_var(Cv_display, opINT);
295: else if (Fieldp && Fieldp->c_type == opSTRING
296: || Cvarp->c_type == opSTRING)
297: w_var(Cv_display, opIDSTRING);
298: else
299: yyserror("in MODIFY, qual var must be in or string",
300: $1);
301: }
302: else
303: yyserror("bad modify qualification", 0);
304: free_display(Cv_display);
305: Cvarp = Fieldp = 0;
306: }
307: ;
308:
309: permit: def_perm permit_list on_of_to id perm_tl
310: perm_who perm_term perm_time perm_day qualclause
311: ;
312: def_perm: define_key permit_key
313: ;
314: permit_list: permlistelm
315: | permit_list comma permlistelm
316: ;
317: permlistelm: RETRIEVE =
318: w_key($1->d_elm);
319: | APPEND =
320: w_key($1->d_elm);
321: | DELETE =
322: w_key($1->d_elm);
323: | REPLACE =
324: w_key($1->d_elm);
325: | all
326: ;
327: on_of_to: on
328: | of
329: | to
330: ;
331: perm_tl: lparen idlist rparen
332: | ;
333: ;
334: perm_who: to id
335: | all
336: | ;
337: ;
338: perm_term: at id
339: | at all
340: | ;
341: ;
342: perm_time: from integer colon integer to
343: integer colon integer
344: | ;
345: ;
346: perm_day: on id to id
347: | ;
348: ;
349:
350: print: print_key idlist
351: ;
352:
353: range: range_of id is id
354: ;
355:
356: replace: replace_key repclause tlclause qualclause
357: ;
358: repclause: repkword id
359: ;
360:
361: retrieve: retrieve_key resclause tlclause qualclause
362: ;
363: resclause: retkword id
364: ;
365:
366: save: save_key id until date
367: ;
368: date: id integer integer
369: ;
370:
371: view: define_key view_key id tlclause qualclause
372: ;
373:
374: /*
375: * Statements Particular to Equel
376: */
377:
378: append_p: append_p_key apclause param_tl qualclause
379: ;
380:
381: copy_p: copy_p_key id param_tl fr_in_id filename
382: ;
383: fr_in_id: cp_kword
384: | c_variable =
385: {
386: if ($1 && Cvarp)
387: {
388: if (Fieldp && Fieldp->c_type != opSTRING
389: || !Fieldp && Cvarp->c_type != opSTRING)
390: yyserror("string var expected for from/into in COPY",
391: $1);
392: else
393: w_var(Cv_display, opIDSTRING);
394: }
395: else
396: yyserror("into/from expected in COPY", $1);
397: free_display(Cv_display);
398: Fieldp = Cvarp = 0;
399: }
400: ;
401:
402: create_p: create_p_key id param_tl
403: ;
404:
405: exit: EXIT =
406: {
407: Opflag = mdEXIT;
408: w_new("IIexit();");
409: }
410: ;
411:
412: ingres: ingres_key param_list =
413: w_op(");");
414: ;
415: param_list: param =
416: w_op("0");
417: | param param_list
418: ;
419: param: id =
420: w_op(",");
421: | SCONST =
422: {
423: w_string($1->d_elm, 0);
424: w_op(",");
425: }
426: ;
427:
428: replace_p: replace_p_key repclause param_tl qualclause
429: ;
430:
431: retrieve_p: retrieve_p_key resclause param_tl qualclause
432: ;
433:
434: tupret: tupret_keyw xc_code =
435: w_flush();
436: | tupret_p o_xc_code =
437: w_flush();
438: ;
439: tupret_keyw: retrieve_key unique c_tlclause qualclause =
440: {
441: w_new("IIsetup();");
442: }
443: ;
444: unique: UNIQUE =
445: {
446: Opflag = mdTUPRET;
447: w_key($1->d_elm);
448: }
449: | =
450: Opflag = mdTUPRET;
451: ;
452: c_tlclause: lparen c_tlist rparen
453: ;
454: c_tlist: c_tlelm
455: | c_tlelm comma c_tlist
456: ;
457: c_tlelm: reduc cvar is_key afcn
458: ;
459: reduc: =
460: Opflag = mdCTLELM;
461: ;
462: xc_code: LBRACE gen_while c_code RBRACE %prec LBRACE =
463: w_op("}");
464: | gen_while %prec LBOP =
465: w_op("}");
466: ;
467: gen_while: =
468: {
469: w_new("while(IIn_get(");
470: w_file();
471: w_op(")){");
472: w_ret();
473: free_ret();
474: w_op("if(IIerrtest())continue;");
475: equate_lines();
476: }
477: ;
478: o_xc_code: LBRACE o_gen_while c_code RBRACE %prec LBRACE =
479: w_op("}");
480: | o_gen_while %prec LBOP =
481: w_op("}");
482: ;
483: o_gen_while: =
484: {
485: w_new("while(IIgettup(");
486: w_file();
487: w_op(")){");
488: equate_lines();
489: }
490: ;
491: tupret_p: tupret_p_key unique param_tl qualclause =
492: {
493: w_new("IIsetup();");
494: }
495: ;
496:
497: view_p: PARAM define_key view_key id param_tl qualclause
498: ;
499:
500: /*
501: * Declarations and use of C variables
502: */
503:
504: declaration: decl_specifer declarator_list SEMICOL =
505: {
506: w_op($3->d_elm);
507: Type_spec = 0;
508: }
509: | decl_specifer SEMICOL =
510: {
511: w_op($2->d_elm);
512: Type_spec = 0;
513: }
514: ;
515: decl_specifer: type_specifier
516: | sc_specifier
517: | type_specifier sc_specifier
518: | sc_specifier type_specifier
519: | struct_dec =
520: {
521: Struct_flag = 0;
522: Type_spec = opSTRUCT;
523: }
524: | sc_specifier struct_dec =
525: {
526: Struct_flag = 0;
527: Type_spec = opSTRUCT;
528: }
529: ;
530: sc_specifier: ALLOC =
531: {
532: Opflag = mdDECL;
533: w_key($1->d_elm);
534: /* in case the default "int" should be assumed,
535: * the Type_spec is set up for it, if a previous
536: * type hasn't been given
537: */
538: if (!Type_spec)
539: Type_spec = opINT;
540: }
541: ;
542: type_specifier: TYPE =
543: {
544: Opflag = mdDECL;
545: w_key($1->d_elm);
546: Type_spec = Opcode;
547: }
548: ;
549: struct_dec: struct_name field_declaration
550: | struct_name
551: | struct_key field_declaration
552: ;
553: struct_name: struct_key NAME =
554: w_key($2->d_elm);
555: ;
556: field_declaration: lbrace field_seq RBRACE =
557: {
558: w_op($3->d_elm);
559: Type_spec = 0;
560: }
561: ;
562: field_seq: field_seq field
563: | ;
564: ;
565: field: type_specifier declarator_list SEMICOL =
566: {
567: w_op($3->d_elm);
568: Type_spec = 0;
569: }
570: | C_CODE
571: ;
572: declarator_list: cvar_dec
573: | declarator_list comma cvar_dec
574: ;
575: cvar_dec: cvarx =
576: {
577: if (Type_spec == opSTRING)
578: Indir_level -= 1;
579: if (Struct_flag)
580: decl_field($1->d_elm, Type_spec,
581: Indir_level, Block_level);
582: else
583: decl_cvar($1->d_elm, Type_spec,
584: Indir_level, Block_level);
585: free_display(Cv_display);
586: Indir_level = Field_indir = 0;
587: Fieldp = Cvarp = 0;
588: }
589: ;
590: c_variable: cvarx =
591: {
592: $$ = $1;
593: if (Cvarp && Cvarp->c_indir != Indir_level)
594: {
595: yyserror("bad indirection on a C variable", $1);
596: $$ = 0;
597: }
598: Indir_level = Field_indir = 0;
599: }
600: | NONREF NAME =
601: {
602: enter_display(Cv_display, salloc($1->d_elm));
603: Cvarp = Fieldp = 0;
604: $$ = $2;
605: }
606: | NONREF STRUCT_VAR =
607: {
608: enter_display(Cv_display, salloc($1->d_elm));
609: Cvarp = Fieldp = 0;
610: $$ = $2;
611: }
612: | struct_var =
613: {
614: if (!Fieldp)
615: {
616: yyserror("undeclared field", $1);
617: $$ = $<u_dn>0;
618: }
619: else if (Fieldp->c_indir != Field_indir)
620: {
621: yyserror("bad indirection on a structure's field",
622: $1);
623: $$ = 0;
624: }
625: if (Cvarp->c_indir != Indir_level)
626: {
627: yysemerr("bad indirection a structure variable",
628: Cvarp->c_indir);
629: $$ = 0;
630: }
631: Indir_level = Field_indir = 0;
632: }
633: ;
634: struct_var: ptr struct_var %prec unaryop =
635: {
636: if ($1->d_elm[1] == '*')
637: Field_indir += 1;
638: Field_indir += 1;
639: $$ = $2;
640: }
641: | struct_var arraysub %prec LBRKT =
642: Field_indir += 1;
643: | str_var_key selector_part
644: ;
645: str_var_key: STRUCT_VAR =
646: {
647: Cvarp = getcvar($1->d_elm);
648: enter_display(Cv_display, $1->d_elm);
649: }
650: ;
651: selector_part: arraysub selector_part =
652: {
653: Indir_level += 1;
654: $$ = $2;
655: }
656: | select_op NAME =
657: {
658: enter_display(Cv_display, $2->d_elm);
659: Fieldp = getfield($2->d_elm);
660: $$ = $2;
661: }
662: ;
663: select_op: PERIOD =
664: enter_display(Cv_display, $1->d_elm);
665: | POINTER =
666: {
667: enter_display(Cv_display, $1->d_elm);
668: Indir_level += 1;
669: }
670: ;
671:
672: /* use of a C variable */
673: cvar: c_variable =
674: {
675: if ($1)
676: {
677: if (!Fieldp && ! Cvarp)
678: {
679: if (!Field_indir && !Indir_level
680: && (sequal($1->d_elm, "dba")
681: || sequal($1->d_elm, "usercode")))
682: /* constant operator COP */
683: w_key($1->d_elm);
684: else
685: yyserror("C var expected", $1);
686: }
687: else if (Opflag == mdCTLELM)
688: {
689: w_con(NAME,
690: Fieldp ? Fieldp->c_id: Cvarp->c_id);
691: enter_ret(Cv_display,
692: Fieldp ? Fieldp->c_type: Cvarp->c_type);
693: }
694: else
695: w_var(Cv_display,
696: Fieldp ? Fieldp->c_type: Cvarp->c_type);
697: }
698: free_display(Cv_display);
699: Fieldp = Cvarp = 0;
700: Indir_level = Field_indir = 0;
701: }
702: cvarx: NAME =
703: {
704: if (Opflag == mdDECL)
705: w_con(NAME, $1->d_elm);
706: else
707: {
708: Cvarp = getcvar($1->d_elm);
709: enter_display(Cv_display, salloc($1->d_elm));
710: }
711: }
712: | ptr cvarx %prec unaryop =
713: {
714: if ($1->d_elm [1] == '*')
715: Indir_level += 1;
716: Indir_level += 1;
717: $$ = $2;
718: }
719: | cvarx arraysub %prec LBRKT =
720: {
721: Indir_level += 1;
722: }
723: ;
724: ptr: BOP =
725: {
726: if (!sequal($1->d_elm, "*") && !sequal((struct disp_node *)($1)->d_elm, "**"))
727: yyserror(Opflag == mdDECL ?
728: "invalid operator in declaration":
729: "invalid operator in C variable",
730: $1);
731: if (Opflag == mdDECL)
732: w_op($1->d_elm);
733: else
734: enter_display(Cv_display, salloc($1->d_elm));
735: }
736: ;
737: arraysub: LBRKT =
738: {
739: if (Opflag == mdDECL)
740: eat_display(0, '[', ']');
741: else
742: eat_display(Cv_display, '[', ']');
743: }
744: ;
745:
746: /*
747: * Special Objects used throughout grammar
748: */
749:
750: id: c_variable =
751: {
752: if ($1)
753: {
754: if (Cvarp)
755: {
756: if (Fieldp && Fieldp->c_type != opSTRING
757: || !Fieldp && Cvarp->c_type != opSTRING)
758: yyserror("string var expected", $1);
759: else if (Opflag == mdFILENAME)
760: w_var(Cv_display, opSTRING);
761: else if (Opflag == mdINGRES)
762: w_display(Cv_display);
763: else
764: w_var(Cv_display, opIDSTRING);
765: }
766: else if (Opflag == mdINGRES)
767: w_string($1->d_elm, 0);
768: else if (Opflag == mdFILENAME)
769: yyserror("file for a COPY must be a string or string variable",
770: $1);
771: else
772: w_key($1->d_elm);
773: }
774: free_display(Cv_display);
775: Fieldp = Cvarp = 0;
776: }
777: ;
778:
779: idlist: id
780: | idlist comma id
781: ;
782:
783: integer: I2CONST =
784: w_con(I2CONST, $1->d_elm);
785: | c_variable =
786: {
787: if ($1)
788: {
789: if (Cvarp)
790: if (Fieldp && Fieldp->c_type == opINT
791: || Cvarp->c_type == opINT)
792: w_var(Cv_display, opINT);
793: else
794: yyserror("integer variable required",
795: $1);
796: else
797: yyserror("integer variable required", $1);
798: }
799: free_display(Cv_display);
800: }
801: ;
802:
803: int_list: integer
804: | int_list comma integer
805: ;
806:
807: param_tl: LPAREN =
808: {
809: w_op("(");
810: end_quote();
811: if (Opflag == mdTUPRET)
812: w_key("IIw_left");
813: else
814: w_key("IIw_right");
815: eat_display(0, '(', ')');
816: w_op(";");
817: begin_quote();
818: w_op(")");
819:
820: }
821: ;
822:
823: qualclause: where qual
824: | where c_variable =
825: {
826: if (!$2 || !Cvarp)
827: yyserror("C var (string) expected", $2);
828: else if (Fieldp && Fieldp->c_type == opSTRING
829: || Cvarp->c_type == opSTRING)
830: {
831: end_quote();
832: w_op("IIwrite(");
833: w_display(Cv_display);
834: w_op(");");
835: }
836: else
837: yyserror("var must be string valued for qualification",
838: $2);
839: free_display(Cv_display);
840: Cvarp = Fieldp = 0;
841: }
842: | ;
843: ;
844: qual: lparen qual rparen
845: | luop qual %prec LUOP
846: | qual lbop qual %prec LBOP
847: | clause
848: | ;
849: ;
850: clause: afcn rop afcn
851: | afcn rop afcn bdop afcn
852: ;
853: ctl: id is id
854: | ctl comma id is id
855: ;
856:
857: sconst: SCONST =
858: w_con(SCONST, $1->d_elm);
859: ;
860:
861: tlclause: lparen tlist rparen
862: ;
863: tlist: tlelm
864: | tlelm comma tlist
865: ;
866: tlelm: id is_key afcn
867: | attrib
868: ;
869:
870: /*
871: * Expressions
872: */
873:
874: afcn: aggrfcn
875: | aggr
876: | attribfcn
877: | afcn bop afcn %prec BOP
878: | lparen afcn rparen
879: | uop afcn %prec unaryop
880: | fop lparen afcn rparen
881: | fbop lparen afcn comma afcn rparen
882: ;
883: aggr: aop lparen afcn qualclause rparen
884: ;
885: aggrfcn: aop lparen afcn by aseq qualclause rparen
886: ;
887: attribfcn: I2CONST =
888: w_con(I2CONST, $1->d_elm);
889: | I4CONST =
890: w_con(I4CONST, $1->d_elm);
891: | F8CONST =
892: w_con(F8CONST, $1->d_elm);
893: | SCONST =
894: w_con(SCONST, $1->d_elm);
895: | cvar
896: | attrib
897: ;
898: aseq: aseq comma afcn
899: | afcn
900: ;
901: attrib: id period id
902: | id period all=
903: {
904: if (Opflag != mdVIEW && Opflag != mdRETRIEVE
905: && Opflag != mdAPPEND)
906: yyserror(
907: "'all' applied to this range variable illegal in this kind of statement",
908: $1);
909: }
910: ;
911: lbop: LBOP =
912: w_key($1->d_elm);
913: ;
914: luop: LUOP =
915: w_key($1->d_elm);
916: ;
917: bdop: BDOP =
918: w_op($1->d_elm);
919: ;
920: rop: EOP =
921: w_op($1->d_elm);
922: | BDOP =
923: w_op($1->d_elm);
924: | IS =
925: w_op("=");
926: ;
927: uop: UOP =
928: w_op($1->d_elm);
929: ;
930: fop: FOP =
931: w_key($1->d_elm);
932: ;
933: fbop: FBOP =
934: w_key($1->d_elm);
935: ;
936: bop: BOP =
937: w_op($1->d_elm);
938: | UOP =
939: w_op($1->d_elm);
940: ;
941: by: BY =
942: w_key($1->d_elm);
943: ;
944: aop: AOP =
945: w_key($1->d_elm);
946: ;
947:
948: /*
949: * Keywords
950: */
951:
952: append_p_key: PARAM APPEND =
953: {
954: begin_quote();
955: w_key($2->d_elm);
956: Opflag = mdAPPEND;
957: }
958: ;
959: append_key: APPEND =
960: {
961: Opflag = mdAPPEND;
962: begin_quote();
963: w_key($1->d_elm);
964: }
965: ;
966: copy_key: COPY =
967: {
968: Opflag = mdCOPY;
969: begin_quote();
970: w_key($1->d_elm);
971: }
972: ;
973: copy_p_key: PARAM COPY =
974: {
975: Opflag = mdCOPY;
976: begin_quote();
977: w_key($2->d_elm);
978: }
979: ;
980: cp_kword: INTO =
981: {
982: w_key($1->d_elm);
983: Opflag = mdFILENAME;
984: }
985: | FROM =
986: {
987: w_key($1->d_elm);
988: Opflag = mdFILENAME;
989: }
990: ;
991: create_key: CREATE =
992: {
993: Opflag = mdCREATE;
994: begin_quote();
995: w_key($1->d_elm);
996: }
997: ;
998: create_p_key: PARAM CREATE =
999: {
1000: Opflag = mdCREATE;
1001: begin_quote();
1002: w_key($2->d_elm);
1003: }
1004: ;
1005: define_key: DEFINE =
1006: {
1007: Opflag = mdDEFINE;
1008: begin_quote();
1009: w_key($1->d_elm);
1010: }
1011: ;
1012: delete_key: DELETE =
1013: {
1014: Opflag = mdDELETE;
1015: begin_quote();
1016: w_key($1->d_elm);
1017: }
1018: ;
1019: destroy_key: DESTROY =
1020: {
1021: Opflag = mdDESTROY;
1022: begin_quote();
1023: w_key($1->d_elm);
1024: }
1025: ;
1026: help_key: HELP =
1027: {
1028: Opflag = mdHELP;
1029: begin_quote();
1030: w_key($1->d_elm);
1031: }
1032: ;
1033: index_key: INDEX ON =
1034: {
1035: Opflag = mdINDEX;
1036: begin_quote();
1037: w_key($1->d_elm);
1038: w_key($2->d_elm);
1039: }
1040: ;
1041: ingres_key: INGRES =
1042: {
1043: Opflag = mdINGRES;
1044: w_new("IIingres(");
1045: }
1046: ;
1047: integ_key: INTEGRITY=
1048: {
1049: if (Opflag == mdDEFINE)
1050: Opflag = mdINTEGRITY;
1051: w_key($1->d_elm);
1052: }
1053: ;
1054: is_key: IS =
1055: {
1056: if (Opflag == mdCTLELM)
1057: Opflag = mdTUPRET;
1058: w_op("=");
1059: }
1060: | BY =
1061: w_key($1->d_elm);
1062: ;
1063: modify_key: MODIFY =
1064: {
1065: Opflag = mdMODIFY;
1066: begin_quote();
1067: w_key($1->d_elm);
1068: }
1069: ;
1070: permit_key: PERMIT=
1071: {
1072: if (Opflag == mdDEFINE)
1073: Opflag = mdINTEGRITY;
1074: w_key($1->d_elm);
1075: }
1076: ;
1077: print_key: PRINT =
1078: {
1079: Opflag = mdPRINT;
1080: begin_quote();
1081: w_key($1->d_elm);
1082: }
1083: ;
1084: range_of: RANGE OF =
1085: {
1086: Opflag = mdRANGE;
1087: begin_quote();
1088: w_key($1->d_elm);
1089: w_key($2->d_elm);
1090: }
1091: ;
1092: replace_key: REPLACE =
1093: {
1094: Opflag = mdREPLACE;
1095: begin_quote();
1096: w_key($1->d_elm);
1097: }
1098: ;
1099: replace_p_key: PARAM REPLACE =
1100: {
1101: begin_quote();
1102: Opflag = mdREPLACE;
1103: w_key($2->d_elm);
1104: }
1105: ;
1106: retrieve_key: RETRIEVE =
1107: {
1108: Opflag = mdRETRIEVE;
1109: begin_quote();
1110: w_key($1->d_elm);
1111: }
1112: ;
1113: retrieve_p_key: PARAM RETRIEVE =
1114: {
1115: Opflag = mdRETRIEVE;
1116: begin_quote();
1117: w_key($2->d_elm);
1118: }
1119: ;
1120: save_key: SAVE =
1121: {
1122: Opflag = mdSAVE;
1123: begin_quote();
1124: w_key($1->d_elm);
1125: }
1126: ;
1127: struct_key: STRUCT =
1128: {
1129: Opflag = mdDECL;
1130: Struct_flag = 1;
1131: w_key($1->d_elm);
1132: }
1133: ;
1134: tupret_p_key: PARAM RETRIEVE =
1135: {
1136: begin_quote();
1137: w_key($2->d_elm);
1138: Opflag = mdTUPRET;
1139: }
1140: ;
1141: view_key: VIEW =
1142: {
1143: if (Opflag == mdDEFINE)
1144: Opflag = mdVIEW;
1145: w_key($1->d_elm);
1146: }
1147: ;
1148:
1149: /*
1150: * Noise words and punctuation
1151: */
1152:
1153: all: ALL=
1154: w_key($1->d_elm);
1155: ;
1156: apkword: INTO
1157: | ONTO
1158: | TO
1159: | ON
1160: | ;
1161: ;
1162: at: AT =
1163: w_key($1->d_elm);
1164: ;
1165: colon: COLON =
1166: w_op($1->d_elm);
1167: ;
1168: comma: COMMA =
1169: w_op($1->d_elm);
1170: ;
1171: delnoise: IN
1172: | ON
1173: | FROM
1174: | ;
1175: ;
1176: from: FROM =
1177: w_key($1->d_elm);
1178: ;
1179: integnoise: ON
1180: | ONTO
1181: | IN
1182: | OF
1183: ;
1184: is: IS =
1185: w_op("=");
1186: ;
1187: isnoise: IS
1188: | ;
1189: ;
1190: lbrace: LBRACE =
1191: w_op($1->d_elm);
1192: ;
1193: lparen: LPAREN =
1194: w_op($1->d_elm);
1195: ;
1196: of: OF=
1197: w_key($1->d_elm);
1198: ;
1199: on: ON =
1200: w_key($1->d_elm);
1201: ;
1202: period: PERIOD =
1203: w_op($1->d_elm);
1204: ;
1205: repkword: INTO
1206: | IN
1207: | ON
1208: | ;
1209: ;
1210: rparen: RPAREN =
1211: w_op($1->d_elm);
1212: ;
1213: to: TO =
1214: w_key($1->d_elm);
1215: ;
1216: retkword: INTO
1217: | TO
1218: | ;
1219: ;
1220: until: UNTIL =
1221: w_key($1->d_elm);
1222: ;
1223: where: WHERE =
1224: w_key($1->d_elm);
1225: ;
1226: %%
1227:
1228: # include "tokens.y"
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.