![[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] / 43BSD / ingres / source / equel|
Return to grammar.y CVS log | Up to [CSRG BSD Unix] / 43BSD / 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 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"
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.