1 /* YACC grammar for Modula-2 expressions, for GDB. 2 Copyright (C) 1986, 1989-1996, 1999-2000, 2007-2012 Free Software 3 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 /* Take care of parsing a number (anything that starts with a digit). 655 Set yylval and return the token type; update lexptr. 656 LEN is the number of characters in it. */ 657 658 /*** Needs some error checking for the float case ***/ 659 660 static int 661 parse_number (olen) 662 int olen; 663 { 664 char *p = lexptr; 665 LONGEST n = 0; 666 LONGEST prevn = 0; 667 int c,i,ischar=0; 668 int base = input_radix; 669 int len = olen; 670 int unsigned_p = number_sign == 1 ? 1 : 0; 671 672 if(p[len-1] == 'H') 673 { 674 base = 16; 675 len--; 676 } 677 else if(p[len-1] == 'C' || p[len-1] == 'B') 678 { 679 base = 8; 680 ischar = p[len-1] == 'C'; 681 len--; 682 } 683 684 /* Scan the number */ 685 for (c = 0; c < len; c++) 686 { 687 if (p[c] == '.' && base == 10) 688 { 689 /* It's a float since it contains a point. */ 690 yylval.dval = atof (p); 691 lexptr += len; 692 return FLOAT; 693 } 694 if (p[c] == '.' && base != 10) 695 error (_("Floating point numbers must be base 10.")); 696 if (base == 10 && (p[c] < '0' || p[c] > '9')) 697 error (_("Invalid digit \'%c\' in number."),p[c]); 698 } 699 700 while (len-- > 0) 701 { 702 c = *p++; 703 n *= base; 704 if( base == 8 && (c == '8' || c == '9')) 705 error (_("Invalid digit \'%c\' in octal number."),c); 706 if (c >= '0' && c <= '9') 707 i = c - '0'; 708 else 709 { 710 if (base == 16 && c >= 'A' && c <= 'F') 711 i = c - 'A' + 10; 712 else 713 return ERROR; 714 } 715 n+=i; 716 if(i >= base) 717 return ERROR; 718 if(!unsigned_p && number_sign == 1 && (prevn >= n)) 719 unsigned_p=1; /* Try something unsigned */ 720 /* Don't do the range check if n==i and i==0, since that special 721 case will give an overflow error. */ 722 if(RANGE_CHECK && n!=i && i) 723 { 724 if((unsigned_p && (unsigned)prevn >= (unsigned)n) || 725 ((!unsigned_p && number_sign==-1) && -prevn <= -n)) 726 range_error (_("Overflow on numeric constant.")); 727 } 728 prevn=n; 729 } 730 731 lexptr = p; 732 if(*p == 'B' || *p == 'C' || *p == 'H') 733 lexptr++; /* Advance past B,C or H */ 734 735 if (ischar) 736 { 737 yylval.ulval = n; 738 return CHAR; 739 } 740 else if ( unsigned_p && number_sign == 1) 741 { 742 yylval.ulval = n; 743 return UINT; 744 } 745 else if((unsigned_p && (n<0))) { 746 range_error (_("Overflow on numeric constant -- number too large.")); 747 /* But, this can return if range_check == range_warn. */ 748 } 749 yylval.lval = n; 750 return INT; 751 } 752 753 754 /* Some tokens */ 755 756 static struct 757 { 758 char name[2]; 759 int token; 760 } tokentab2[] = 761 { 762 { {'<', '>'}, NOTEQUAL }, 763 { {':', '='}, ASSIGN }, 764 { {'<', '='}, LEQ }, 765 { {'>', '='}, GEQ }, 766 { {':', ':'}, COLONCOLON }, 767 768 }; 769 770 /* Some specific keywords */ 771 772 struct keyword { 773 char keyw[10]; 774 int token; 775 }; 776 777 static struct keyword keytab[] = 778 { 779 {"OR" , OROR }, 780 {"IN", IN },/* Note space after IN */ 781 {"AND", LOGICAL_AND}, 782 {"ABS", ABS }, 783 {"CHR", CHR }, 784 {"DEC", DEC }, 785 {"NOT", NOT }, 786 {"DIV", DIV }, 787 {"INC", INC }, 788 {"MAX", MAX_FUNC }, 789 {"MIN", MIN_FUNC }, 790 {"MOD", MOD }, 791 {"ODD", ODD }, 792 {"CAP", CAP }, 793 {"ORD", ORD }, 794 {"VAL", VAL }, 795 {"EXCL", EXCL }, 796 {"HIGH", HIGH }, 797 {"INCL", INCL }, 798 {"SIZE", SIZE }, 799 {"FLOAT", FLOAT_FUNC }, 800 {"TRUNC", TRUNC }, 801 {"TSIZE", SIZE }, 802 }; 803 804 805 /* Read one token, getting characters through lexptr. */ 806 807 /* This is where we will check to make sure that the language and the operators used are 808 compatible */ 809 810 static int 811 yylex (void) 812 { 813 int c; 814 int namelen; 815 int i; 816 char *tokstart; 817 char quote; 818 819 retry: 820 821 prev_lexptr = lexptr; 822 823 tokstart = lexptr; 824 825 826 /* See if it is a special token of length 2 */ 827 for( i = 0 ; i < (int) (sizeof tokentab2 / sizeof tokentab2[0]) ; i++) 828 if (strncmp (tokentab2[i].name, tokstart, 2) == 0) 829 { 830 lexptr += 2; 831 return tokentab2[i].token; 832 } 833 834 switch (c = *tokstart) 835 { 836 case 0: 837 return 0; 838 839 case ' ': 840 case '\t': 841 case '\n': 842 lexptr++; 843 goto retry; 844 845 case '(': 846 paren_depth++; 847 lexptr++; 848 return c; 849 850 case ')': 851 if (paren_depth == 0) 852 return 0; 853 paren_depth--; 854 lexptr++; 855 return c; 856 857 case ',': 858 if (comma_terminates && paren_depth == 0) 859 return 0; 860 lexptr++; 861 return c; 862 863 case '.': 864 /* Might be a floating point number. */ 865 if (lexptr[1] >= '0' && lexptr[1] <= '9') 866 break; /* Falls into number code. */ 867 else 868 { 869 lexptr++; 870 return DOT; 871 } 872 873 /* These are character tokens that appear as-is in the YACC grammar */ 874 case '+': 875 case '-': 876 case '*': 877 case '/': 878 case '^': 879 case '<': 880 case '>': 881 case '[': 882 case ']': 883 case '=': 884 case '{': 885 case '}': 886 case '#': 887 case '@': 888 case '~': 889 case '&': 890 lexptr++; 891 return c; 892 893 case '\'' : 894 case '"': 895 quote = c; 896 for (namelen = 1; (c = tokstart[namelen]) != quote && c != '\0'; namelen++) 897 if (c == '\\') 898 { 899 c = tokstart[++namelen]; 900 if (c >= '0' && c <= '9') 901 { 902 c = tokstart[++namelen]; 903 if (c >= '0' && c <= '9') 904 c = tokstart[++namelen]; 905 } 906 } 907 if(c != quote) 908 error (_("Unterminated string or character constant.")); 909 yylval.sval.ptr = tokstart + 1; 910 yylval.sval.length = namelen - 1; 911 lexptr += namelen + 1; 912 913 if(namelen == 2) /* Single character */ 914 { 915 yylval.ulval = tokstart[1]; 916 return CHAR; 917 } 918 else 919 return STRING; 920 } 921 922 /* Is it a number? */ 923 /* Note: We have already dealt with the case of the token '.'. 924 See case '.' above. */ 925 if ((c >= '0' && c <= '9')) 926 { 927 /* It's a number. */ 928 int got_dot = 0, got_e = 0; 929 char *p = tokstart; 930 int toktype; 931 932 for (++p ;; ++p) 933 { 934 if (!got_e && (*p == 'e' || *p == 'E')) 935 got_dot = got_e = 1; 936 else if (!got_dot && *p == '.') 937 got_dot = 1; 938 else if (got_e && (p[-1] == 'e' || p[-1] == 'E') 939 && (*p == '-' || *p == '+')) 940 /* This is the sign of the exponent, not the end of the 941 number. */ 942 continue; 943 else if ((*p < '0' || *p > '9') && 944 (*p < 'A' || *p > 'F') && 945 (*p != 'H')) /* Modula-2 hexadecimal number */ 946 break; 947 } 948 toktype = parse_number (p - tokstart); 949 if (toktype == ERROR) 950 { 951 char *err_copy = (char *) alloca (p - tokstart + 1); 952 953 memcpy (err_copy, tokstart, p - tokstart); 954 err_copy[p - tokstart] = 0; 955 error (_("Invalid number \"%s\"."), err_copy); 956 } 957 lexptr = p; 958 return toktype; 959 } 960 961 if (!(c == '_' || c == '$' 962 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) 963 /* We must have come across a bad character (e.g. ';'). */ 964 error (_("Invalid character '%c' in expression."), c); 965 966 /* It's a name. See how long it is. */ 967 namelen = 0; 968 for (c = tokstart[namelen]; 969 (c == '_' || c == '$' || (c >= '0' && c <= '9') 970 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')); 971 c = tokstart[++namelen]) 972 ; 973 974 /* The token "if" terminates the expression and is NOT 975 removed from the input stream. */ 976 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f') 977 { 978 return 0; 979 } 980 981 lexptr += namelen; 982 983 /* Lookup special keywords */ 984 for(i = 0 ; i < (int) (sizeof(keytab) / sizeof(keytab[0])) ; i++) 985 if (namelen == strlen (keytab[i].keyw) 986 && strncmp (tokstart, keytab[i].keyw, namelen) == 0) 987 return keytab[i].token; 988 989 yylval.sval.ptr = tokstart; 990 yylval.sval.length = namelen; 991 992 if (*tokstart == '$') 993 { 994 write_dollar_variable (yylval.sval); 995 return INTERNAL_VAR; 996 } 997 998 /* Use token-type BLOCKNAME for symbols that happen to be defined as 999 functions. If this is not so, then ... 1000 Use token-type TYPENAME for symbols that happen to be defined 1001 currently as names of types; NAME for other symbols. 1002 The caller is not constrained to care about the distinction. */ 1003 { 1004 1005 1006 char *tmp = copy_name (yylval.sval); 1007 struct symbol *sym; 1008 1009 if (lookup_symtab (tmp)) 1010 return BLOCKNAME; 1011 sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN, 0); 1012 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK) 1013 return BLOCKNAME; 1014 if (lookup_typename (parse_language, parse_gdbarch, 1015 copy_name (yylval.sval), expression_context_block, 1)) 1016 return TYPENAME; 1017 1018 if(sym) 1019 { 1020 switch(SYMBOL_CLASS (sym)) 1021 { 1022 case LOC_STATIC: 1023 case LOC_REGISTER: 1024 case LOC_ARG: 1025 case LOC_REF_ARG: 1026 case LOC_REGPARM_ADDR: 1027 case LOC_LOCAL: 1028 case LOC_CONST: 1029 case LOC_CONST_BYTES: 1030 case LOC_OPTIMIZED_OUT: 1031 case LOC_COMPUTED: 1032 return NAME; 1033 1034 case LOC_TYPEDEF: 1035 return TYPENAME; 1036 1037 case LOC_BLOCK: 1038 return BLOCKNAME; 1039 1040 case LOC_UNDEF: 1041 error (_("internal: Undefined class in m2lex()")); 1042 1043 case LOC_LABEL: 1044 case LOC_UNRESOLVED: 1045 error (_("internal: Unforseen case in m2lex()")); 1046 1047 default: 1048 error (_("unhandled token in m2lex()")); 1049 break; 1050 } 1051 } 1052 else 1053 { 1054 /* Built-in BOOLEAN type. This is sort of a hack. */ 1055 if (strncmp (tokstart, "TRUE", 4) == 0) 1056 { 1057 yylval.ulval = 1; 1058 return M2_TRUE; 1059 } 1060 else if (strncmp (tokstart, "FALSE", 5) == 0) 1061 { 1062 yylval.ulval = 0; 1063 return M2_FALSE; 1064 } 1065 } 1066 1067 /* Must be another type of name... */ 1068 return NAME; 1069 } 1070 } 1071 1072 #if 0 /* Unused */ 1073 static char * 1074 make_qualname(mod,ident) 1075 char *mod, *ident; 1076 { 1077 char *new = malloc(strlen(mod)+strlen(ident)+2); 1078 1079 strcpy(new,mod); 1080 strcat(new,"."); 1081 strcat(new,ident); 1082 return new; 1083 } 1084 #endif /* 0 */ 1085 1086 void 1087 yyerror (msg) 1088 char *msg; 1089 { 1090 if (prev_lexptr) 1091 lexptr = prev_lexptr; 1092 1093 error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr); 1094 } 1095