1 /* YACC grammar for Modula-2 expressions, for GDB. 2 Copyright (C) 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 3 2000, 2007, 2008, 2009 Free Software Foundation, Inc. 4 Generated from expread.y (now c-exp.y) and contributed by the Department 5 of Computer Science at the State University of New York at Buffalo, 1991. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 /* Parse a Modula-2 expression from text in a string, 23 and return the result as a struct expression pointer. 24 That structure contains arithmetic operations in reverse polish, 25 with constants represented by operations that are followed by special data. 26 See expression.h for the details of the format. 27 What is important here is that it can be built up sequentially 28 during the process of parsing; the lower levels of the tree always 29 come first in the result. 30 31 Note that malloc's and realloc's in this file are transformed to 32 xmalloc and xrealloc respectively by the same sed command in the 33 makefile that remaps any other malloc/realloc inserted by the parser 34 generator. Doing this with #defines and trying to control the interaction 35 with include files (<malloc.h> and <stdlib.h> for example) just became 36 too messy, particularly when such includes can be inserted at random 37 times by the parser generator. */ 38 39 %{ 40 41 #include "defs.h" 42 #include "gdb_string.h" 43 #include "expression.h" 44 #include "language.h" 45 #include "value.h" 46 #include "parser-defs.h" 47 #include "m2-lang.h" 48 #include "bfd.h" /* Required by objfiles.h. */ 49 #include "symfile.h" /* Required by objfiles.h. */ 50 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */ 51 #include "block.h" 52 53 #define parse_type builtin_type (parse_gdbarch) 54 #define parse_m2_type builtin_m2_type (parse_gdbarch) 55 56 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc), 57 as well as gratuitiously global symbol names, so we can have multiple 58 yacc generated parsers in gdb. Note that these are only the variables 59 produced by yacc. If other parser generators (bison, byacc, etc) produce 60 additional global names that conflict at link time, then those parser 61 generators need to be fixed instead of adding those names to this list. */ 62 63 #define yymaxdepth m2_maxdepth 64 #define yyparse m2_parse 65 #define yylex m2_lex 66 #define yyerror m2_error 67 #define yylval m2_lval 68 #define yychar m2_char 69 #define yydebug m2_debug 70 #define yypact m2_pact 71 #define yyr1 m2_r1 72 #define yyr2 m2_r2 73 #define yydef m2_def 74 #define yychk m2_chk 75 #define yypgo m2_pgo 76 #define yyact m2_act 77 #define yyexca m2_exca 78 #define yyerrflag m2_errflag 79 #define yynerrs m2_nerrs 80 #define yyps m2_ps 81 #define yypv m2_pv 82 #define yys m2_s 83 #define yy_yys m2_yys 84 #define yystate m2_state 85 #define yytmp m2_tmp 86 #define yyv m2_v 87 #define yy_yyv m2_yyv 88 #define yyval m2_val 89 #define yylloc m2_lloc 90 #define yyreds m2_reds /* With YYDEBUG defined */ 91 #define yytoks m2_toks /* With YYDEBUG defined */ 92 #define yyname m2_name /* With YYDEBUG defined */ 93 #define yyrule m2_rule /* With YYDEBUG defined */ 94 #define yylhs m2_yylhs 95 #define yylen m2_yylen 96 #define yydefred m2_yydefred 97 #define yydgoto m2_yydgoto 98 #define yysindex m2_yysindex 99 #define yyrindex m2_yyrindex 100 #define yygindex m2_yygindex 101 #define yytable m2_yytable 102 #define yycheck m2_yycheck 103 104 #ifndef YYDEBUG 105 #define YYDEBUG 1 /* Default to yydebug support */ 106 #endif 107 108 #define YYFPRINTF parser_fprintf 109 110 int yyparse (void); 111 112 static int yylex (void); 113 114 void yyerror (char *); 115 116 #if 0 117 static char *make_qualname (char *, char *); 118 #endif 119 120 static int parse_number (int); 121 122 /* The sign of the number being parsed. */ 123 static int number_sign = 1; 124 125 /* The block that the module specified by the qualifer on an identifer is 126 contained in, */ 127 #if 0 128 static struct block *modblock=0; 129 #endif 130 131 %} 132 133 /* Although the yacc "value" of an expression is not used, 134 since the result is stored in the structure being created, 135 other node types do have values. */ 136 137 %union 138 { 139 LONGEST lval; 140 ULONGEST ulval; 141 DOUBLEST dval; 142 struct symbol *sym; 143 struct type *tval; 144 struct stoken sval; 145 int voidval; 146 struct block *bval; 147 enum exp_opcode opcode; 148 struct internalvar *ivar; 149 150 struct type **tvec; 151 int *ivec; 152 } 153 154 %type <voidval> exp type_exp start set 155 %type <voidval> variable 156 %type <tval> type 157 %type <bval> block 158 %type <sym> fblock 159 160 %token <lval> INT HEX ERROR 161 %token <ulval> UINT M2_TRUE M2_FALSE CHAR 162 %token <dval> FLOAT 163 164 /* Both NAME and TYPENAME tokens represent symbols in the input, 165 and both convey their data as strings. 166 But a TYPENAME is a string that happens to be defined as a typedef 167 or builtin type name (such as int or char) 168 and a NAME is any other symbol. 169 170 Contexts where this distinction is not important can use the 171 nonterminal "name", which matches either NAME or TYPENAME. */ 172 173 %token <sval> STRING 174 %token <sval> NAME BLOCKNAME IDENT VARNAME 175 %token <sval> TYPENAME 176 177 %token SIZE CAP ORD HIGH ABS MIN_FUNC MAX_FUNC FLOAT_FUNC VAL CHR ODD TRUNC 178 %token TSIZE 179 %token INC DEC INCL EXCL 180 181 /* The GDB scope operator */ 182 %token COLONCOLON 183 184 %token <voidval> INTERNAL_VAR 185 186 /* M2 tokens */ 187 %left ',' 188 %left ABOVE_COMMA 189 %nonassoc ASSIGN 190 %left '<' '>' LEQ GEQ '=' NOTEQUAL '#' IN 191 %left OROR 192 %left LOGICAL_AND '&' 193 %left '@' 194 %left '+' '-' 195 %left '*' '/' DIV MOD 196 %right UNARY 197 %right '^' DOT '[' '(' 198 %right NOT '~' 199 %left COLONCOLON QID 200 /* This is not an actual token ; it is used for precedence. 201 %right QID 202 */ 203 204 205 %% 206 207 start : exp 208 | type_exp 209 ; 210 211 type_exp: type 212 { write_exp_elt_opcode(OP_TYPE); 213 write_exp_elt_type($1); 214 write_exp_elt_opcode(OP_TYPE); 215 } 216 ; 217 218 /* Expressions */ 219 220 exp : exp '^' %prec UNARY 221 { write_exp_elt_opcode (UNOP_IND); } 222 ; 223 224 exp : '-' 225 { number_sign = -1; } 226 exp %prec UNARY 227 { number_sign = 1; 228 write_exp_elt_opcode (UNOP_NEG); } 229 ; 230 231 exp : '+' exp %prec UNARY 232 { write_exp_elt_opcode(UNOP_PLUS); } 233 ; 234 235 exp : not_exp exp %prec UNARY 236 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); } 237 ; 238 239 not_exp : NOT 240 | '~' 241 ; 242 243 exp : CAP '(' exp ')' 244 { write_exp_elt_opcode (UNOP_CAP); } 245 ; 246 247 exp : ORD '(' exp ')' 248 { write_exp_elt_opcode (UNOP_ORD); } 249 ; 250 251 exp : ABS '(' exp ')' 252 { write_exp_elt_opcode (UNOP_ABS); } 253 ; 254 255 exp : HIGH '(' exp ')' 256 { write_exp_elt_opcode (UNOP_HIGH); } 257 ; 258 259 exp : MIN_FUNC '(' type ')' 260 { write_exp_elt_opcode (UNOP_MIN); 261 write_exp_elt_type ($3); 262 write_exp_elt_opcode (UNOP_MIN); } 263 ; 264 265 exp : MAX_FUNC '(' type ')' 266 { write_exp_elt_opcode (UNOP_MAX); 267 write_exp_elt_type ($3); 268 write_exp_elt_opcode (UNOP_MAX); } 269 ; 270 271 exp : FLOAT_FUNC '(' exp ')' 272 { write_exp_elt_opcode (UNOP_FLOAT); } 273 ; 274 275 exp : VAL '(' type ',' exp ')' 276 { write_exp_elt_opcode (BINOP_VAL); 277 write_exp_elt_type ($3); 278 write_exp_elt_opcode (BINOP_VAL); } 279 ; 280 281 exp : CHR '(' exp ')' 282 { write_exp_elt_opcode (UNOP_CHR); } 283 ; 284 285 exp : ODD '(' exp ')' 286 { write_exp_elt_opcode (UNOP_ODD); } 287 ; 288 289 exp : TRUNC '(' exp ')' 290 { write_exp_elt_opcode (UNOP_TRUNC); } 291 ; 292 293 exp : TSIZE '(' exp ')' 294 { write_exp_elt_opcode (UNOP_SIZEOF); } 295 ; 296 297 exp : SIZE exp %prec UNARY 298 { write_exp_elt_opcode (UNOP_SIZEOF); } 299 ; 300 301 302 exp : INC '(' exp ')' 303 { write_exp_elt_opcode(UNOP_PREINCREMENT); } 304 ; 305 306 exp : INC '(' exp ',' exp ')' 307 { write_exp_elt_opcode(BINOP_ASSIGN_MODIFY); 308 write_exp_elt_opcode(BINOP_ADD); 309 write_exp_elt_opcode(BINOP_ASSIGN_MODIFY); } 310 ; 311 312 exp : DEC '(' exp ')' 313 { write_exp_elt_opcode(UNOP_PREDECREMENT);} 314 ; 315 316 exp : DEC '(' exp ',' exp ')' 317 { write_exp_elt_opcode(BINOP_ASSIGN_MODIFY); 318 write_exp_elt_opcode(BINOP_SUB); 319 write_exp_elt_opcode(BINOP_ASSIGN_MODIFY); } 320 ; 321 322 exp : exp DOT NAME 323 { write_exp_elt_opcode (STRUCTOP_STRUCT); 324 write_exp_string ($3); 325 write_exp_elt_opcode (STRUCTOP_STRUCT); } 326 ; 327 328 exp : set 329 ; 330 331 exp : exp IN set 332 { error("Sets are not implemented.");} 333 ; 334 335 exp : INCL '(' exp ',' exp ')' 336 { error("Sets are not implemented.");} 337 ; 338 339 exp : EXCL '(' exp ',' exp ')' 340 { error("Sets are not implemented.");} 341 ; 342 343 set : '{' arglist '}' 344 { error("Sets are not implemented.");} 345 | type '{' arglist '}' 346 { error("Sets are not implemented.");} 347 ; 348 349 350 /* Modula-2 array subscript notation [a,b,c...] */ 351 exp : exp '[' 352 /* This function just saves the number of arguments 353 that follow in the list. It is *not* specific to 354 function types */ 355 { start_arglist(); } 356 non_empty_arglist ']' %prec DOT 357 { write_exp_elt_opcode (MULTI_SUBSCRIPT); 358 write_exp_elt_longcst ((LONGEST) end_arglist()); 359 write_exp_elt_opcode (MULTI_SUBSCRIPT); } 360 ; 361 362 exp : exp '[' exp ']' 363 { write_exp_elt_opcode (BINOP_SUBSCRIPT); } 364 ; 365 366 exp : exp '(' 367 /* This is to save the value of arglist_len 368 being accumulated by an outer function call. */ 369 { start_arglist (); } 370 arglist ')' %prec DOT 371 { write_exp_elt_opcode (OP_FUNCALL); 372 write_exp_elt_longcst ((LONGEST) end_arglist ()); 373 write_exp_elt_opcode (OP_FUNCALL); } 374 ; 375 376 arglist : 377 ; 378 379 arglist : exp 380 { arglist_len = 1; } 381 ; 382 383 arglist : arglist ',' exp %prec ABOVE_COMMA 384 { arglist_len++; } 385 ; 386 387 non_empty_arglist 388 : exp 389 { arglist_len = 1; } 390 ; 391 392 non_empty_arglist 393 : non_empty_arglist ',' exp %prec ABOVE_COMMA 394 { arglist_len++; } 395 ; 396 397 /* GDB construct */ 398 exp : '{' type '}' exp %prec UNARY 399 { write_exp_elt_opcode (UNOP_MEMVAL); 400 write_exp_elt_type ($2); 401 write_exp_elt_opcode (UNOP_MEMVAL); } 402 ; 403 404 exp : type '(' exp ')' %prec UNARY 405 { write_exp_elt_opcode (UNOP_CAST); 406 write_exp_elt_type ($1); 407 write_exp_elt_opcode (UNOP_CAST); } 408 ; 409 410 exp : '(' exp ')' 411 { } 412 ; 413 414 /* Binary operators in order of decreasing precedence. Note that some 415 of these operators are overloaded! (ie. sets) */ 416 417 /* GDB construct */ 418 exp : exp '@' exp 419 { write_exp_elt_opcode (BINOP_REPEAT); } 420 ; 421 422 exp : exp '*' exp 423 { write_exp_elt_opcode (BINOP_MUL); } 424 ; 425 426 exp : exp '/' exp 427 { write_exp_elt_opcode (BINOP_DIV); } 428 ; 429 430 exp : exp DIV exp 431 { write_exp_elt_opcode (BINOP_INTDIV); } 432 ; 433 434 exp : exp MOD exp 435 { write_exp_elt_opcode (BINOP_REM); } 436 ; 437 438 exp : exp '+' exp 439 { write_exp_elt_opcode (BINOP_ADD); } 440 ; 441 442 exp : exp '-' exp 443 { write_exp_elt_opcode (BINOP_SUB); } 444 ; 445 446 exp : exp '=' exp 447 { write_exp_elt_opcode (BINOP_EQUAL); } 448 ; 449 450 exp : exp NOTEQUAL exp 451 { write_exp_elt_opcode (BINOP_NOTEQUAL); } 452 | exp '#' exp 453 { write_exp_elt_opcode (BINOP_NOTEQUAL); } 454 ; 455 456 exp : exp LEQ exp 457 { write_exp_elt_opcode (BINOP_LEQ); } 458 ; 459 460 exp : exp GEQ exp 461 { write_exp_elt_opcode (BINOP_GEQ); } 462 ; 463 464 exp : exp '<' exp 465 { write_exp_elt_opcode (BINOP_LESS); } 466 ; 467 468 exp : exp '>' exp 469 { write_exp_elt_opcode (BINOP_GTR); } 470 ; 471 472 exp : exp LOGICAL_AND exp 473 { write_exp_elt_opcode (BINOP_LOGICAL_AND); } 474 ; 475 476 exp : exp OROR exp 477 { write_exp_elt_opcode (BINOP_LOGICAL_OR); } 478 ; 479 480 exp : exp ASSIGN exp 481 { write_exp_elt_opcode (BINOP_ASSIGN); } 482 ; 483 484 485 /* Constants */ 486 487 exp : M2_TRUE 488 { write_exp_elt_opcode (OP_BOOL); 489 write_exp_elt_longcst ((LONGEST) $1); 490 write_exp_elt_opcode (OP_BOOL); } 491 ; 492 493 exp : M2_FALSE 494 { write_exp_elt_opcode (OP_BOOL); 495 write_exp_elt_longcst ((LONGEST) $1); 496 write_exp_elt_opcode (OP_BOOL); } 497 ; 498 499 exp : INT 500 { write_exp_elt_opcode (OP_LONG); 501 write_exp_elt_type (parse_m2_type->builtin_int); 502 write_exp_elt_longcst ((LONGEST) $1); 503 write_exp_elt_opcode (OP_LONG); } 504 ; 505 506 exp : UINT 507 { 508 write_exp_elt_opcode (OP_LONG); 509 write_exp_elt_type (parse_m2_type->builtin_card); 510 write_exp_elt_longcst ((LONGEST) $1); 511 write_exp_elt_opcode (OP_LONG); 512 } 513 ; 514 515 exp : CHAR 516 { write_exp_elt_opcode (OP_LONG); 517 write_exp_elt_type (parse_m2_type->builtin_char); 518 write_exp_elt_longcst ((LONGEST) $1); 519 write_exp_elt_opcode (OP_LONG); } 520 ; 521 522 523 exp : FLOAT 524 { write_exp_elt_opcode (OP_DOUBLE); 525 write_exp_elt_type (parse_m2_type->builtin_real); 526 write_exp_elt_dblcst ($1); 527 write_exp_elt_opcode (OP_DOUBLE); } 528 ; 529 530 exp : variable 531 ; 532 533 exp : SIZE '(' type ')' %prec UNARY 534 { write_exp_elt_opcode (OP_LONG); 535 write_exp_elt_type (parse_type->builtin_int); 536 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3)); 537 write_exp_elt_opcode (OP_LONG); } 538 ; 539 540 exp : STRING 541 { write_exp_elt_opcode (OP_M2_STRING); 542 write_exp_string ($1); 543 write_exp_elt_opcode (OP_M2_STRING); } 544 ; 545 546 /* This will be used for extensions later. Like adding modules. */ 547 block : fblock 548 { $$ = SYMBOL_BLOCK_VALUE($1); } 549 ; 550 551 fblock : BLOCKNAME 552 { struct symbol *sym 553 = lookup_symbol (copy_name ($1), expression_context_block, 554 VAR_DOMAIN, 0); 555 $$ = sym;} 556 ; 557 558 559 /* GDB scope operator */ 560 fblock : block COLONCOLON BLOCKNAME 561 { struct symbol *tem 562 = lookup_symbol (copy_name ($3), $1, 563 VAR_DOMAIN, 0); 564 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK) 565 error ("No function \"%s\" in specified context.", 566 copy_name ($3)); 567 $$ = tem; 568 } 569 ; 570 571 /* Useful for assigning to PROCEDURE variables */ 572 variable: fblock 573 { write_exp_elt_opcode(OP_VAR_VALUE); 574 write_exp_elt_block (NULL); 575 write_exp_elt_sym ($1); 576 write_exp_elt_opcode (OP_VAR_VALUE); } 577 ; 578 579 /* GDB internal ($foo) variable */ 580 variable: INTERNAL_VAR 581 ; 582 583 /* GDB scope operator */ 584 variable: block COLONCOLON NAME 585 { struct symbol *sym; 586 sym = lookup_symbol (copy_name ($3), $1, 587 VAR_DOMAIN, 0); 588 if (sym == 0) 589 error ("No symbol \"%s\" in specified context.", 590 copy_name ($3)); 591 592 write_exp_elt_opcode (OP_VAR_VALUE); 593 /* block_found is set by lookup_symbol. */ 594 write_exp_elt_block (block_found); 595 write_exp_elt_sym (sym); 596 write_exp_elt_opcode (OP_VAR_VALUE); } 597 ; 598 599 /* Base case for variables. */ 600 variable: NAME 601 { struct symbol *sym; 602 int is_a_field_of_this; 603 604 sym = lookup_symbol (copy_name ($1), 605 expression_context_block, 606 VAR_DOMAIN, 607 &is_a_field_of_this); 608 if (sym) 609 { 610 if (symbol_read_needs_frame (sym)) 611 { 612 if (innermost_block == 0 || 613 contained_in (block_found, 614 innermost_block)) 615 innermost_block = block_found; 616 } 617 618 write_exp_elt_opcode (OP_VAR_VALUE); 619 /* We want to use the selected frame, not 620 another more inner frame which happens to 621 be in the same block. */ 622 write_exp_elt_block (NULL); 623 write_exp_elt_sym (sym); 624 write_exp_elt_opcode (OP_VAR_VALUE); 625 } 626 else 627 { 628 struct minimal_symbol *msymbol; 629 char *arg = copy_name ($1); 630 631 msymbol = 632 lookup_minimal_symbol (arg, NULL, NULL); 633 if (msymbol != NULL) 634 write_exp_msymbol (msymbol); 635 else if (!have_full_symbols () && !have_partial_symbols ()) 636 error ("No symbol table is loaded. Use the \"symbol-file\" command."); 637 else 638 error ("No symbol \"%s\" in current context.", 639 copy_name ($1)); 640 } 641 } 642 ; 643 644 type 645 : TYPENAME 646 { $$ = lookup_typename (parse_language, parse_gdbarch, 647 copy_name ($1), 648 expression_context_block, 0); } 649 650 ; 651 652 %% 653 654 #if 0 /* FIXME! */ 655 int 656 overflow(a,b) 657 long a,b; 658 { 659 return (MAX_OF_TYPE(parse_m2_type->builtin_int) - b) < a; 660 } 661 662 int 663 uoverflow(a,b) 664 unsigned long a,b; 665 { 666 return (MAX_OF_TYPE(parse_m2_type->builtin_card) - b) < a; 667 } 668 #endif /* FIXME */ 669 670 /* Take care of parsing a number (anything that starts with a digit). 671 Set yylval and return the token type; update lexptr. 672 LEN is the number of characters in it. */ 673 674 /*** Needs some error checking for the float case ***/ 675 676 static int 677 parse_number (olen) 678 int olen; 679 { 680 char *p = lexptr; 681 LONGEST n = 0; 682 LONGEST prevn = 0; 683 int c,i,ischar=0; 684 int base = input_radix; 685 int len = olen; 686 int unsigned_p = number_sign == 1 ? 1 : 0; 687 688 if(p[len-1] == 'H') 689 { 690 base = 16; 691 len--; 692 } 693 else if(p[len-1] == 'C' || p[len-1] == 'B') 694 { 695 base = 8; 696 ischar = p[len-1] == 'C'; 697 len--; 698 } 699 700 /* Scan the number */ 701 for (c = 0; c < len; c++) 702 { 703 if (p[c] == '.' && base == 10) 704 { 705 /* It's a float since it contains a point. */ 706 yylval.dval = atof (p); 707 lexptr += len; 708 return FLOAT; 709 } 710 if (p[c] == '.' && base != 10) 711 error("Floating point numbers must be base 10."); 712 if (base == 10 && (p[c] < '0' || p[c] > '9')) 713 error("Invalid digit \'%c\' in number.",p[c]); 714 } 715 716 while (len-- > 0) 717 { 718 c = *p++; 719 n *= base; 720 if( base == 8 && (c == '8' || c == '9')) 721 error("Invalid digit \'%c\' in octal number.",c); 722 if (c >= '0' && c <= '9') 723 i = c - '0'; 724 else 725 { 726 if (base == 16 && c >= 'A' && c <= 'F') 727 i = c - 'A' + 10; 728 else 729 return ERROR; 730 } 731 n+=i; 732 if(i >= base) 733 return ERROR; 734 if(!unsigned_p && number_sign == 1 && (prevn >= n)) 735 unsigned_p=1; /* Try something unsigned */ 736 /* Don't do the range check if n==i and i==0, since that special 737 case will give an overflow error. */ 738 if(RANGE_CHECK && n!=i && i) 739 { 740 if((unsigned_p && (unsigned)prevn >= (unsigned)n) || 741 ((!unsigned_p && number_sign==-1) && -prevn <= -n)) 742 range_error("Overflow on numeric constant."); 743 } 744 prevn=n; 745 } 746 747 lexptr = p; 748 if(*p == 'B' || *p == 'C' || *p == 'H') 749 lexptr++; /* Advance past B,C or H */ 750 751 if (ischar) 752 { 753 yylval.ulval = n; 754 return CHAR; 755 } 756 else if ( unsigned_p && number_sign == 1) 757 { 758 yylval.ulval = n; 759 return UINT; 760 } 761 else if((unsigned_p && (n<0))) { 762 range_error("Overflow on numeric constant -- number too large."); 763 /* But, this can return if range_check == range_warn. */ 764 } 765 yylval.lval = n; 766 return INT; 767 } 768 769 770 /* Some tokens */ 771 772 static struct 773 { 774 char name[2]; 775 int token; 776 } tokentab2[] = 777 { 778 { {'<', '>'}, NOTEQUAL }, 779 { {':', '='}, ASSIGN }, 780 { {'<', '='}, LEQ }, 781 { {'>', '='}, GEQ }, 782 { {':', ':'}, COLONCOLON }, 783 784 }; 785 786 /* Some specific keywords */ 787 788 struct keyword { 789 char keyw[10]; 790 int token; 791 }; 792 793 static struct keyword keytab[] = 794 { 795 {"OR" , OROR }, 796 {"IN", IN },/* Note space after IN */ 797 {"AND", LOGICAL_AND}, 798 {"ABS", ABS }, 799 {"CHR", CHR }, 800 {"DEC", DEC }, 801 {"NOT", NOT }, 802 {"DIV", DIV }, 803 {"INC", INC }, 804 {"MAX", MAX_FUNC }, 805 {"MIN", MIN_FUNC }, 806 {"MOD", MOD }, 807 {"ODD", ODD }, 808 {"CAP", CAP }, 809 {"ORD", ORD }, 810 {"VAL", VAL }, 811 {"EXCL", EXCL }, 812 {"HIGH", HIGH }, 813 {"INCL", INCL }, 814 {"SIZE", SIZE }, 815 {"FLOAT", FLOAT_FUNC }, 816 {"TRUNC", TRUNC }, 817 {"TSIZE", SIZE }, 818 }; 819 820 821 /* Read one token, getting characters through lexptr. */ 822 823 /* This is where we will check to make sure that the language and the operators used are 824 compatible */ 825 826 static int 827 yylex () 828 { 829 int c; 830 int namelen; 831 int i; 832 char *tokstart; 833 char quote; 834 835 retry: 836 837 prev_lexptr = lexptr; 838 839 tokstart = lexptr; 840 841 842 /* See if it is a special token of length 2 */ 843 for( i = 0 ; i < (int) (sizeof tokentab2 / sizeof tokentab2[0]) ; i++) 844 if (strncmp (tokentab2[i].name, tokstart, 2) == 0) 845 { 846 lexptr += 2; 847 return tokentab2[i].token; 848 } 849 850 switch (c = *tokstart) 851 { 852 case 0: 853 return 0; 854 855 case ' ': 856 case '\t': 857 case '\n': 858 lexptr++; 859 goto retry; 860 861 case '(': 862 paren_depth++; 863 lexptr++; 864 return c; 865 866 case ')': 867 if (paren_depth == 0) 868 return 0; 869 paren_depth--; 870 lexptr++; 871 return c; 872 873 case ',': 874 if (comma_terminates && paren_depth == 0) 875 return 0; 876 lexptr++; 877 return c; 878 879 case '.': 880 /* Might be a floating point number. */ 881 if (lexptr[1] >= '0' && lexptr[1] <= '9') 882 break; /* Falls into number code. */ 883 else 884 { 885 lexptr++; 886 return DOT; 887 } 888 889 /* These are character tokens that appear as-is in the YACC grammar */ 890 case '+': 891 case '-': 892 case '*': 893 case '/': 894 case '^': 895 case '<': 896 case '>': 897 case '[': 898 case ']': 899 case '=': 900 case '{': 901 case '}': 902 case '#': 903 case '@': 904 case '~': 905 case '&': 906 lexptr++; 907 return c; 908 909 case '\'' : 910 case '"': 911 quote = c; 912 for (namelen = 1; (c = tokstart[namelen]) != quote && c != '\0'; namelen++) 913 if (c == '\\') 914 { 915 c = tokstart[++namelen]; 916 if (c >= '0' && c <= '9') 917 { 918 c = tokstart[++namelen]; 919 if (c >= '0' && c <= '9') 920 c = tokstart[++namelen]; 921 } 922 } 923 if(c != quote) 924 error("Unterminated string or character constant."); 925 yylval.sval.ptr = tokstart + 1; 926 yylval.sval.length = namelen - 1; 927 lexptr += namelen + 1; 928 929 if(namelen == 2) /* Single character */ 930 { 931 yylval.ulval = tokstart[1]; 932 return CHAR; 933 } 934 else 935 return STRING; 936 } 937 938 /* Is it a number? */ 939 /* Note: We have already dealt with the case of the token '.'. 940 See case '.' above. */ 941 if ((c >= '0' && c <= '9')) 942 { 943 /* It's a number. */ 944 int got_dot = 0, got_e = 0; 945 char *p = tokstart; 946 int toktype; 947 948 for (++p ;; ++p) 949 { 950 if (!got_e && (*p == 'e' || *p == 'E')) 951 got_dot = got_e = 1; 952 else if (!got_dot && *p == '.') 953 got_dot = 1; 954 else if (got_e && (p[-1] == 'e' || p[-1] == 'E') 955 && (*p == '-' || *p == '+')) 956 /* This is the sign of the exponent, not the end of the 957 number. */ 958 continue; 959 else if ((*p < '0' || *p > '9') && 960 (*p < 'A' || *p > 'F') && 961 (*p != 'H')) /* Modula-2 hexadecimal number */ 962 break; 963 } 964 toktype = parse_number (p - tokstart); 965 if (toktype == ERROR) 966 { 967 char *err_copy = (char *) alloca (p - tokstart + 1); 968 969 memcpy (err_copy, tokstart, p - tokstart); 970 err_copy[p - tokstart] = 0; 971 error ("Invalid number \"%s\".", err_copy); 972 } 973 lexptr = p; 974 return toktype; 975 } 976 977 if (!(c == '_' || c == '$' 978 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) 979 /* We must have come across a bad character (e.g. ';'). */ 980 error ("Invalid character '%c' in expression.", c); 981 982 /* It's a name. See how long it is. */ 983 namelen = 0; 984 for (c = tokstart[namelen]; 985 (c == '_' || c == '$' || (c >= '0' && c <= '9') 986 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')); 987 c = tokstart[++namelen]) 988 ; 989 990 /* The token "if" terminates the expression and is NOT 991 removed from the input stream. */ 992 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f') 993 { 994 return 0; 995 } 996 997 lexptr += namelen; 998 999 /* Lookup special keywords */ 1000 for(i = 0 ; i < (int) (sizeof(keytab) / sizeof(keytab[0])) ; i++) 1001 if (namelen == strlen (keytab[i].keyw) 1002 && strncmp (tokstart, keytab[i].keyw, namelen) == 0) 1003 return keytab[i].token; 1004 1005 yylval.sval.ptr = tokstart; 1006 yylval.sval.length = namelen; 1007 1008 if (*tokstart == '$') 1009 { 1010 write_dollar_variable (yylval.sval); 1011 return INTERNAL_VAR; 1012 } 1013 1014 /* Use token-type BLOCKNAME for symbols that happen to be defined as 1015 functions. If this is not so, then ... 1016 Use token-type TYPENAME for symbols that happen to be defined 1017 currently as names of types; NAME for other symbols. 1018 The caller is not constrained to care about the distinction. */ 1019 { 1020 1021 1022 char *tmp = copy_name (yylval.sval); 1023 struct symbol *sym; 1024 1025 if (lookup_partial_symtab (tmp)) 1026 return BLOCKNAME; 1027 sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN, 0); 1028 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK) 1029 return BLOCKNAME; 1030 if (lookup_typename (parse_language, parse_gdbarch, 1031 copy_name (yylval.sval), expression_context_block, 1)) 1032 return TYPENAME; 1033 1034 if(sym) 1035 { 1036 switch(SYMBOL_CLASS (sym)) 1037 { 1038 case LOC_STATIC: 1039 case LOC_REGISTER: 1040 case LOC_ARG: 1041 case LOC_REF_ARG: 1042 case LOC_REGPARM_ADDR: 1043 case LOC_LOCAL: 1044 case LOC_CONST: 1045 case LOC_CONST_BYTES: 1046 case LOC_OPTIMIZED_OUT: 1047 case LOC_COMPUTED: 1048 return NAME; 1049 1050 case LOC_TYPEDEF: 1051 return TYPENAME; 1052 1053 case LOC_BLOCK: 1054 return BLOCKNAME; 1055 1056 case LOC_UNDEF: 1057 error("internal: Undefined class in m2lex()"); 1058 1059 case LOC_LABEL: 1060 case LOC_UNRESOLVED: 1061 error("internal: Unforseen case in m2lex()"); 1062 1063 default: 1064 error ("unhandled token in m2lex()"); 1065 break; 1066 } 1067 } 1068 else 1069 { 1070 /* Built-in BOOLEAN type. This is sort of a hack. */ 1071 if (strncmp (tokstart, "TRUE", 4) == 0) 1072 { 1073 yylval.ulval = 1; 1074 return M2_TRUE; 1075 } 1076 else if (strncmp (tokstart, "FALSE", 5) == 0) 1077 { 1078 yylval.ulval = 0; 1079 return M2_FALSE; 1080 } 1081 } 1082 1083 /* Must be another type of name... */ 1084 return NAME; 1085 } 1086 } 1087 1088 #if 0 /* Unused */ 1089 static char * 1090 make_qualname(mod,ident) 1091 char *mod, *ident; 1092 { 1093 char *new = malloc(strlen(mod)+strlen(ident)+2); 1094 1095 strcpy(new,mod); 1096 strcat(new,"."); 1097 strcat(new,ident); 1098 return new; 1099 } 1100 #endif /* 0 */ 1101 1102 void 1103 yyerror (msg) 1104 char *msg; 1105 { 1106 if (prev_lexptr) 1107 lexptr = prev_lexptr; 1108 1109 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr); 1110 } 1111