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