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