gdb/ch-exp.y

   1 /* YACC grammar for Chill expressions, for GDB.
   2    Copyright (C) 1992 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 /* Parse a Chill expression from text in a string,
  21    and return the result as a  struct expression  pointer.
  22    That structure contains arithmetic operations in reverse polish,
  23    with constants represented by operations that are followed by special data.
  24    See expression.h for the details of the format.
  25    What is important here is that it can be built up sequentially
  26    during the process of parsing; the lower levels of the tree always
  27    come first in the result.
  28
  29    Note that malloc's and realloc's in this file are transformed to
  30    xmalloc and xrealloc respectively by the same sed command in the
  31    makefile that remaps any other malloc/realloc inserted by the parser
  32    generator.  Doing this with #defines and trying to control the interaction
  33    with include files (<malloc.h> and <stdlib.h> for example) just became
  34    too messy, particularly when such includes can be inserted at random
  35    times by the parser generator.
  36
  37    Also note that the language accepted by this parser is more liberal
  38    than the one accepted by an actual Chill compiler.  For example, the
  39    language rule that a simple name string can not be one of the reserved
  40    simple name strings is not enforced (e.g "case" is not treated as a
  41    reserved name).  Another example is that Chill is a strongly typed
  42    language, and certain expressions that violate the type constraints
  43    may still be evaluated if gdb can do so in a meaningful manner, while
  44    such expressions would be rejected by the compiler.  The reason for
  45    this more liberal behavior is the philosophy that the debugger
  46    is intended to be a tool that is used by the programmer when things
  47    go wrong, and as such, it should provide as few artificial barriers
  48    to it's use as possible.  If it can do something meaningful, even
  49    something that violates language contraints that are enforced by the
  50    compiler, it should do so without complaint.
  51
  52  */
  53
  54 %{
  55
  56 #include <stdio.h>
  57 #include <string.h>
  58 #include "defs.h"
  59 #include "symtab.h"
  60 #include "gdbtypes.h"
  61 #include "frame.h"
  62 #include "expression.h"
  63 #include "language.h"
  64 #include "value.h"
  65 #include "parser-defs.h"
  66 #include "bfd.h"
  67 #include "symfile.h"
  68 #include "objfiles.h"
  69
  70 /* These MUST be included in any grammar file!!!! Please choose unique names!
  71    Note that this are a combined list of variables that can be produced
  72    by any one of bison, byacc, or yacc. */
  73 #define yymaxdepth chill_maxdepth
  74 #define yyparse chill_parse
  75 #define yylex   chill_lex
  76 #define yyerror chill_error
  77 #define yylval  chill_lval
  78 #define yychar  chill_char
  79 #define yydebug chill_debug
  80 #define yypact  chill_pact
  81 #define yyr1    chill_r1
  82 #define yyr2    chill_r2
  83 #define yydef   chill_def
  84 #define yychk   chill_chk
  85 #define yypgo   chill_pgo
  86 #define yyact   chill_act
  87 #define yyexca  chill_exca
  88 #define yyerrflag chill_errflag
  89 #define yynerrs chill_nerrs
  90 #define yyps    chill_ps
  91 #define yypv    chill_pv
  92 #define yys     chill_s
  93 #define yy_yys  chill_yys
  94 #define yystate chill_state
  95 #define yytmp   chill_tmp
  96 #define yyv     chill_v
  97 #define yy_yyv  chill_yyv
  98 #define yyval   chill_val
  99 #define yylloc  chill_lloc
 100 #define yyss    chill_yyss              /* byacc */
 101 #define yyssp   chill_yysp              /* byacc */
 102 #define yyvs    chill_yyvs              /* byacc */
 103 #define yyvsp   chill_yyvsp     /* byacc */
 104
 105 static int
 106 yylex PARAMS ((void));
 107
 108 static void
 109 yyerror PARAMS ((char *));
 110
 111 int
 112 yyparse PARAMS ((void));
 113
 114 /* #define      YYDEBUG 1 */
 115
 116 %}
 117
 118 /* Although the yacc "value" of an expression is not used,
 119    since the result is stored in the structure being created,
 120    other node types do have values.  */
 121
 122 %union
 123   {
 124     LONGEST lval;
 125     unsigned LONGEST ulval;
 126     struct {
 127       LONGEST val;
 128       struct type *type;
 129     } typed_val;
 130     double dval;
 131     struct symbol *sym;
 132     struct type *tval;
 133     struct stoken sval;
 134     struct ttype tsym;
 135     struct symtoken ssym;
 136     int voidval;
 137     struct block *bval;
 138     enum exp_opcode opcode;
 139     struct internalvar *ivar;
 140
 141     struct type **tvec;
 142     int *ivec;
 143   }
 144
 145 %{
 146 static int parse_number PARAMS ((void));
 147 %}
 148
 149 %token <voidval> FIXME
 150
 151 %token <typed_val>      INTEGER_LITERAL
 152 %token <ulval>          BOOLEAN_LITERAL
 153 %token <typed_val>      CHARACTER_LITERAL
 154 %token <voidval>        SET_LITERAL
 155 %token <voidval>        EMPTINESS_LITERAL
 156 %token <voidval>        CHARACTER_STRING_LITERAL
 157 %token <voidval>        BIT_STRING_LITERAL
 158
 159 %token <voidval>        STRING
 160 %token <voidval>        CONSTANT
 161 %token <voidval>        '.'
 162 %token <voidval>        ';'
 163 %token <voidval>        ':'
 164 %token <voidval>        CASE
 165 %token <voidval>        OF
 166 %token <voidval>        ESAC
 167 %token <voidval>        LOGIOR
 168 %token <voidval>        ORIF
 169 %token <voidval>        LOGXOR
 170 %token <voidval>        LOGAND
 171 %token <voidval>        ANDIF
 172 %token <voidval>        '='
 173 %token <voidval>        NOTEQUAL
 174 %token <voidval>        '>'
 175 %token <voidval>        GTR
 176 %token <voidval>        '<'
 177 %token <voidval>        LEQ
 178 %token <voidval>        IN
 179 %token <voidval>        '+'
 180 %token <voidval>        '-'
 181 %token <voidval>        '*'
 182 %token <voidval>        '/'
 183 %token <voidval>        SLASH_SLASH
 184 %token <voidval>        MOD
 185 %token <voidval>        REM
 186 %token <voidval>        NOT
 187 %token <voidval>        POINTER
 188 %token <voidval>        RECEIVE
 189 %token <voidval>        SC
 190 %token <voidval>        '['
 191 %token <voidval>        ']'
 192 %token <voidval>        '('
 193 %token <voidval>        ')'
 194 %token <voidval>        UP
 195 %token <voidval>        IF
 196 %token <voidval>        THEN
 197 %token <voidval>        ELSE
 198 %token <voidval>        FI
 199 %token <voidval>        ELSIF
 200 %token <voidval>        ILLEGAL_TOKEN
 201
 202 %type <voidval>         location
 203 %type <voidval>         primitive_value
 204 %type <voidval>         location_contents
 205 %type <voidval>         value_name
 206 %type <voidval>         literal
 207 %type <voidval>         tuple
 208 %type <voidval>         value_string_element
 209 %type <voidval>         value_string_slice
 210 %type <voidval>         value_array_element
 211 %type <voidval>         value_array_slice
 212 %type <voidval>         value_structure_field
 213 %type <voidval>         expression_conversion
 214 %type <voidval>         value_procedure_call
 215 %type <voidval>         value_built_in_routine_call
 216 %type <voidval>         start_expression
 217 %type <voidval>         zero_adic_operator
 218 %type <voidval>         parenthesised_expression
 219 %type <voidval>         value
 220 %type <voidval>         undefined_value
 221 %type <voidval>         expression
 222 %type <voidval>         conditional_expression
 223 %type <voidval>         then_alternative
 224 %type <voidval>         else_alternative
 225 %type <voidval>         sub_expression
 226 %type <voidval>         value_case_alternative
 227 %type <voidval>         operand_0
 228 %type <voidval>         operand_1
 229 %type <voidval>         operand_2
 230 %type <voidval>         operand_3
 231 %type <voidval>         operand_4
 232 %type <voidval>         operand_5
 233 %type <voidval>         operand_6
 234 %type <voidval>         integer_literal_expression
 235 %type <voidval>         synonym_name
 236 %type <voidval>         value_enumeration_name
 237 %type <voidval>         value_do_with_name
 238 %type <voidval>         value_receive_name
 239 %type <voidval>         general_procedure_name
 240 %type <voidval>         string_primitive_value
 241 %type <voidval>         start_element
 242 %type <voidval>         left_element
 243 %type <voidval>         right_element
 244 %type <voidval>         slice_size
 245 %type <voidval>         array_primitive_value
 246 %type <voidval>         expression_list
 247 %type <voidval>         lower_element
 248 %type <voidval>         upper_element
 249 %type <voidval>         first_element
 250 %type <voidval>         structure_primitive_value
 251 %type <voidval>         field_name
 252 %type <voidval>         mode_name
 253 %type <voidval>         boolean_expression
 254 %type <voidval>         case_selector_list
 255 %type <voidval>         subexpression
 256 %type <voidval>         case_label_specification
 257 %type <voidval>         buffer_location
 258
 259 %%
 260
 261 /* Z.200, 5.3.1 */
 262
 263 value           :       expression
 264                         {
 265                           $$ = 0;       /* FIXME */
 266                         }
 267                 |       undefined_value
 268                         {
 269                           $$ = 0;       /* FIXME */
 270                         }
 271                 ;
 272
 273 undefined_value :       FIXME
 274                         {
 275                           $$ = 0;       /* FIXME */
 276                         }
 277                 ;
 278
 279 /* Z.200, 4.2.1 */
 280
 281 location        :       FIXME
 282                         {
 283                           $$ = 0;       /* FIXME */
 284                         }
 285                 ;
 286
 287 /* Z.200, 5.2.1 */
 288
 289 primitive_value :       location_contents
 290                         {
 291                           $$ = 0;       /* FIXME */
 292                         }
 293                 |       value_name
 294                         {
 295                           $$ = 0;       /* FIXME */
 296                         }
 297                 |       literal
 298                         {
 299                           $$ = 0;       /* FIXME */
 300                         }
 301                 |       tuple
 302                         {
 303                           $$ = 0;       /* FIXME */
 304                         }
 305                 |       value_string_element
 306                         {
 307                           $$ = 0;       /* FIXME */
 308                         }
 309                 |       value_string_slice
 310                         {
 311                           $$ = 0;       /* FIXME */
 312                         }
 313                 |       value_array_element
 314                         {
 315                           $$ = 0;       /* FIXME */
 316                         }
 317                 |       value_array_slice
 318                         {
 319                           $$ = 0;       /* FIXME */
 320                         }
 321                 |       value_structure_field
 322                         {
 323                           $$ = 0;       /* FIXME */
 324                         }
 325                 |       expression_conversion
 326                         {
 327                           $$ = 0;       /* FIXME */
 328                         }
 329                 |       value_procedure_call
 330                         {
 331                           $$ = 0;       /* FIXME */
 332                         }
 333                 |       value_built_in_routine_call
 334                         {
 335                           $$ = 0;       /* FIXME */
 336                         }
 337                 |       start_expression
 338                         {
 339                           $$ = 0;       /* FIXME */
 340                         }
 341                 |       zero_adic_operator
 342                         {
 343                           $$ = 0;       /* FIXME */
 344                         }
 345                 |       parenthesised_expression
 346                         {
 347                           $$ = 0;       /* FIXME */
 348                         }
 349                 ;
 350
 351 /* Z.200, 5.2.2 */
 352
 353 location_contents:      location
 354                         {
 355                           $$ = 0;       /* FIXME */
 356                         }
 357                 ;
 358
 359 /* Z.200, 5.2.3 */
 360
 361 value_name      :       synonym_name
 362                         {
 363                           $$ = 0;       /* FIXME */
 364                         }
 365                 |       value_enumeration_name
 366                         {
 367                           $$ = 0;       /* FIXME */
 368                         }
 369                 |       value_do_with_name
 370                         {
 371                           $$ = 0;       /* FIXME */
 372                         }
 373                 |       value_receive_name
 374                         {
 375                           $$ = 0;       /* FIXME */
 376                         }
 377                 |       general_procedure_name
 378                         {
 379                           $$ = 0;       /* FIXME */
 380                         }
 381                 ;
 382
 383 /* Z.200, 5.2.4.1 */
 384
 385 literal         :       INTEGER_LITERAL
 386                         {
 387                           write_exp_elt_opcode (OP_LONG);
 388                           write_exp_elt_type ($1.type);
 389                           write_exp_elt_longcst ((LONGEST) ($1.val));
 390                           write_exp_elt_opcode (OP_LONG);
 391                         }
 392                 |       BOOLEAN_LITERAL
 393                         {
 394                           write_exp_elt_opcode (OP_BOOL);
 395                           write_exp_elt_longcst ((LONGEST) $1);
 396                           write_exp_elt_opcode (OP_BOOL);
 397                         }
 398                 |       CHARACTER_LITERAL
 399                         {
 400                           write_exp_elt_opcode (OP_LONG);
 401                           write_exp_elt_type ($1.type);
 402                           write_exp_elt_longcst ((LONGEST) ($1.val));
 403                           write_exp_elt_opcode (OP_LONG);
 404                         }
 405                 |       SET_LITERAL
 406                         {
 407                           $$ = 0;       /* FIXME */
 408                         }
 409                 |       EMPTINESS_LITERAL
 410                         {
 411                           $$ = 0;       /* FIXME */
 412                         }
 413                 |       CHARACTER_STRING_LITERAL
 414                         {
 415                           $$ = 0;       /* FIXME */
 416                         }
 417                 |       BIT_STRING_LITERAL
 418                         {
 419                           $$ = 0;       /* FIXME */
 420                         }
 421                 ;
 422
 423 /* Z.200, 5.2.5 */
 424
 425 tuple           :       FIXME
 426                         {
 427                           $$ = 0;       /* FIXME */
 428                         }
 429                 ;
 430
 431
 432 /* Z.200, 5.2.6 */
 433
 434 value_string_element:   string_primitive_value '(' start_element ')'
 435                         {
 436                           $$ = 0;       /* FIXME */
 437                         }
 438                 ;
 439
 440 /* Z.200, 5.2.7 */
 441
 442 value_string_slice:     string_primitive_value '(' left_element ':' right_element ')'
 443                         {
 444                           $$ = 0;       /* FIXME */
 445                         }
 446                 |       string_primitive_value '(' start_element UP slice_size ')'
 447                         {
 448                           $$ = 0;       /* FIXME */
 449                         }
 450                 ;
 451
 452 /* Z.200, 5.2.8 */
 453
 454 value_array_element:    array_primitive_value '(' expression_list ')'
 455                         {
 456                           $$ = 0;       /* FIXME */
 457                         }
 458                 ;
 459
 460 /* Z.200, 5.2.9 */
 461
 462 value_array_slice:      array_primitive_value '(' lower_element ':' upper_element ')'
 463                         {
 464                           $$ = 0;       /* FIXME */
 465                         }
 466                 |       array_primitive_value '(' first_element UP slice_size '('
 467                         {
 468                           $$ = 0;       /* FIXME */
 469                         }
 470                 ;
 471
 472 /* Z.200, 5.2.10 */
 473
 474 value_structure_field:  structure_primitive_value '.' field_name
 475                         {
 476                           $$ = 0;       /* FIXME */
 477                         }
 478                 ;
 479
 480 /* Z.200, 5.2.11 */
 481
 482 expression_conversion:  mode_name '(' expression ')'
 483                         {
 484                           $$ = 0;       /* FIXME */
 485                         }
 486                 ;
 487
 488 /* Z.200, 5.2.12 */
 489
 490 value_procedure_call:   FIXME
 491                         {
 492                           $$ = 0;       /* FIXME */
 493                         }
 494                 ;
 495
 496 /* Z.200, 5.2.13 */
 497
 498 value_built_in_routine_call:    FIXME
 499                         {
 500                           $$ = 0;       /* FIXME */
 501                         }
 502                 ;
 503
 504 /* Z.200, 5.2.14 */
 505
 506 start_expression:       FIXME
 507                         {
 508                           $$ = 0;       /* FIXME */
 509                         }       /* Not in GNU-Chill */
 510                 ;
 511
 512 /* Z.200, 5.2.15 */
 513
 514 zero_adic_operator:     FIXME
 515                         {
 516                           $$ = 0;       /* FIXME */
 517                         }
 518                 ;
 519
 520 /* Z.200, 5.2.16 */
 521
 522 parenthesised_expression:       '(' expression ')'
 523                         {
 524                           $$ = 0;       /* FIXME */
 525                         }
 526                 ;
 527
 528 /* Z.200, 5.3.2 */
 529
 530 expression      :       operand_0
 531                         {
 532                           $$ = 0;       /* FIXME */
 533                         }
 534                 |       conditional_expression
 535                         {
 536                           $$ = 0;       /* FIXME */
 537                         }
 538                 ;
 539
 540 conditional_expression : IF boolean_expression then_alternative else_alternative FI
 541                         {
 542                           $$ = 0;       /* FIXME */
 543                         }
 544                 |       CASE case_selector_list OF value_case_alternative '[' ELSE sub_expression ']' ESAC
 545                         {
 546                           $$ = 0;       /* FIXME */
 547                         }
 548                 ;
 549
 550 then_alternative:       THEN subexpression
 551                         {
 552                           $$ = 0;       /* FIXME */
 553                         }
 554                 ;
 555
 556 else_alternative:       ELSE subexpression
 557                         {
 558                           $$ = 0;       /* FIXME */
 559                         }
 560                 |       ELSIF boolean_expression then_alternative else_alternative
 561                         {
 562                           $$ = 0;       /* FIXME */
 563                         }
 564                 ;
 565
 566 sub_expression  :       expression
 567                         {
 568                           $$ = 0;       /* FIXME */
 569                         }
 570                 ;
 571
 572 value_case_alternative: case_label_specification ':' sub_expression ';'
 573                         {
 574                           $$ = 0;       /* FIXME */
 575                         }
 576                 ;
 577
 578 /* Z.200, 5.3.3 */
 579
 580 operand_0       :       operand_1
 581                         {
 582                           $$ = 0;       /* FIXME */
 583                         }
 584                 |       operand_0 LOGIOR operand_1
 585                         {
 586                           write_exp_elt_opcode (BINOP_BITWISE_IOR);
 587                         }
 588                 |       operand_0 ORIF operand_1
 589                         {
 590                           $$ = 0;       /* FIXME */
 591                         }
 592                 |       operand_0 LOGXOR operand_1
 593                         {
 594                           write_exp_elt_opcode (BINOP_BITWISE_XOR);
 595                         }
 596                 ;
 597
 598 /* Z.200, 5.3.4 */
 599
 600 operand_1       :       operand_2
 601                         {
 602                           $$ = 0;       /* FIXME */
 603                         }
 604                 |       operand_1 LOGAND operand_2
 605                         {
 606                           write_exp_elt_opcode (BINOP_BITWISE_AND);
 607                         }
 608                 |       operand_1 ANDIF operand_2
 609                         {
 610                           $$ = 0;       /* FIXME */
 611                         }
 612                 ;
 613
 614 /* Z.200, 5.3.5 */
 615
 616 operand_2       :       operand_3
 617                         {
 618                           $$ = 0;       /* FIXME */
 619                         }
 620                 |       operand_2 '=' operand_3
 621                         {
 622                           write_exp_elt_opcode (BINOP_EQUAL);
 623                         }
 624                 |       operand_2 NOTEQUAL operand_3
 625                         {
 626                           write_exp_elt_opcode (BINOP_NOTEQUAL);
 627                         }
 628                 |       operand_2 '>' operand_3
 629                         {
 630                           write_exp_elt_opcode (BINOP_GTR);
 631                         }
 632                 |       operand_2 GTR operand_3
 633                         {
 634                           write_exp_elt_opcode (BINOP_GEQ);
 635                         }
 636                 |       operand_2 '<' operand_3
 637                         {
 638                           write_exp_elt_opcode (BINOP_LESS);
 639                         }
 640                 |       operand_2 LEQ operand_3
 641                         {
 642                           write_exp_elt_opcode (BINOP_LEQ);
 643                         }
 644                 |       operand_2 IN operand_3
 645                         {
 646                           $$ = 0;       /* FIXME */
 647                         }
 648                 ;
 649
 650
 651 /* Z.200, 5.3.6 */
 652
 653 operand_3       :       operand_4
 654                         {
 655                           $$ = 0;       /* FIXME */
 656                         }
 657                 |       operand_3 '+' operand_4
 658                         {
 659                           write_exp_elt_opcode (BINOP_ADD);
 660                         }
 661                 |       operand_3 '-' operand_4
 662                         {
 663                           write_exp_elt_opcode (BINOP_SUB);
 664                         }
 665                 |       operand_3 SLASH_SLASH operand_4
 666                         {
 667                           $$ = 0;       /* FIXME */
 668                         }
 669                 ;
 670
 671 /* Z.200, 5.3.7 */
 672
 673 operand_4       :       operand_5
 674                         {
 675                           $$ = 0;       /* FIXME */
 676                         }
 677                 |       operand_4 '*' operand_5
 678                         {
 679                           write_exp_elt_opcode (BINOP_MUL);
 680                         }
 681                 |       operand_4 '/' operand_5
 682                         {
 683                           write_exp_elt_opcode (BINOP_DIV);
 684                         }
 685                 |       operand_4 MOD operand_5
 686                         {
 687                           $$ = 0;       /* FIXME */
 688                         }
 689                 |       operand_4 REM operand_5
 690                         {
 691                           $$ = 0;       /* FIXME */
 692                         }
 693                 ;
 694
 695 /* Z.200, 5.3.8 */
 696
 697 operand_5       :       operand_6
 698                         {
 699                           $$ = 0;       /* FIXME */
 700                         }
 701                 |       '-' operand_6
 702                         {
 703                           write_exp_elt_opcode (UNOP_NEG);
 704                         }
 705                 |       NOT operand_6
 706                         {
 707                           write_exp_elt_opcode (UNOP_LOGICAL_NOT);
 708                         }
 709                 |       '(' integer_literal_expression ')' operand_6
 710                         {
 711                           $$ = 0;       /* FIXME */
 712                         }
 713                 ;
 714
 715 /* Z.200, 5.3.9 */
 716
 717 operand_6       :       POINTER location
 718                         {
 719                           $$ = 0;       /* FIXME */
 720                         }
 721                 |       RECEIVE buffer_location
 722                         {
 723                           $$ = 0;       /* FIXME */
 724                         }
 725                 |       primitive_value
 726                         {
 727                           $$ = 0;       /* FIXME */
 728                         }
 729                 ;
 730
 731
 732 /* Z.200, 12.4.3 */
 733 /* FIXME:  For now we just accept only a single integer literal. */
 734
 735 integer_literal_expression:
 736                         INTEGER_LITERAL
 737                         {
 738                           $$ = 0;
 739                         }
 740
 741 /* Things which still need productions... */
 742 synonym_name            :       FIXME { $$ = 0; }
 743 value_enumeration_name  :       FIXME { $$ = 0; }
 744 value_do_with_name      :       FIXME { $$ = 0; }
 745 value_receive_name      :       FIXME { $$ = 0; }
 746 general_procedure_name  :       FIXME { $$ = 0; }
 747 string_primitive_value  :       FIXME { $$ = 0; }
 748 start_element           :       FIXME { $$ = 0; }
 749 left_element            :       FIXME { $$ = 0; }
 750 right_element           :       FIXME { $$ = 0; }
 751 slice_size              :       FIXME { $$ = 0; }
 752 array_primitive_value   :       FIXME { $$ = 0; }
 753 expression_list         :       FIXME { $$ = 0; }
 754 lower_element           :       FIXME { $$ = 0; }
 755 upper_element           :       FIXME { $$ = 0; }
 756 first_element           :       FIXME { $$ = 0; }
 757 structure_primitive_value:      FIXME { $$ = 0; }
 758 field_name              :       FIXME { $$ = 0; }
 759 mode_name               :       FIXME { $$ = 0; }
 760 boolean_expression      :       FIXME { $$ = 0; }
 761 case_selector_list      :       FIXME { $$ = 0; }
 762 subexpression           :       FIXME { $$ = 0; }
 763 case_label_specification:       FIXME { $$ = 0; }
 764 buffer_location         :       FIXME { $$ = 0; }
 765
 766 %%
 767
 768 static int
 769 decode_integer_literal (valptr, tokptrptr)
 770 int *valptr;
 771 char **tokptrptr;
 772 {
 773   char *tokptr = *tokptrptr;
 774   int base = 0;
 775   int ival = 0;
 776   int digits = 0;
 777   int temp;
 778   int explicit_base = 0;
 779
 780   /* Look for an explicit base specifier, which is optional. */
 781
 782   switch (*tokptr)
 783     {
 784     case 'd':
 785     case 'D':
 786       explicit_base++;
 787       base = 10;
 788       tokptr++;
 789       break;
 790     case 'b':
 791     case 'B':
 792       explicit_base++;
 793       base = 2;
 794       tokptr++;
 795       break;
 796     case 'h':
 797     case 'H':
 798       explicit_base++;
 799       base = 16;
 800       tokptr++;
 801       break;
 802     case 'o':
 803     case 'O':
 804       explicit_base++;
 805       base = 8;
 806       tokptr++;
 807       break;
 808     default:
 809       base = 10;
 810       break;
 811     }
 812
 813   /* If we found an explicit base ensure that the character after the
 814      explicit base is a single quote. */
 815
 816   if (explicit_base && (*tokptr++ != '\''))
 817     {
 818       return (0);
 819     }
 820
 821   /* Start looking for a value composed of valid digits as set by the base
 822      in use.  Note that '_' characters are valid anywhere, in any quantity,
 823      and are simply ignored.  Since we must find at least one valid digit,
 824      or reject this token as an integer literal, we keep track of how many
 825      digits we have encountered. */
 826
 827   while (*tokptr != '\0')
 828     {
 829       temp = tolower (*tokptr);
 830       tokptr++;
 831       switch (temp)
 832         {
 833         case '_':
 834           continue;
 835         case '0':  case '1':  case '2':  case '3':  case '4':
 836         case '5':  case '6':  case '7':  case '8':  case '9':
 837           temp -= '0';
 838           break;
 839         case 'a':  case 'b':  case 'c':  case 'd':  case 'e': case 'f':
 840           temp -= 'a';
 841           temp += 10;
 842           break;
 843         default:
 844           temp = base;
 845           break;
 846         }
 847       if (temp < base)
 848         {
 849           digits++;
 850           ival *= base;
 851           ival += temp;
 852         }
 853       else
 854         {
 855           /* Found something not in domain for current base. */
 856           tokptr--;     /* Unconsume what gave us indigestion. */
 857           break;
 858         }
 859     }
 860
 861   /* If we didn't find any digits, then we don't have a valid integer
 862      literal, so reject the entire token.  Also, if we have an explicit
 863      base, then the next character must not be a single quote, or we
 864      have a bitstring literal, so reject the entire token in this case
 865      as well.  Otherwise, update the lexical scan pointer, and return
 866      non-zero for success. */
 867
 868   if (digits == 0)
 869     {
 870       return (0);
 871     }
 872   else if (explicit_base && (*tokptr == '\''))
 873     {
 874       return (0);
 875     }
 876   else
 877     {
 878       *valptr = ival;
 879       *tokptrptr = tokptr;
 880       return (1);
 881     }
 882 }
 883
 884 /* Recognize a character literal.  A character literal is single character
 885    or a control sequence, enclosed in single quotes.  A control sequence
 886    is a comma separated list of one or more integer literals, enclosed
 887    in parenthesis and introduced with a circumflex character.
 888
 889    EX:  'a'  '^(7)'  '^(7,8)'
 890
 891    Returns CHARACTER_LITERAL if a match is found.
 892    */
 893
 894 static int
 895 match_character_literal ()
 896 {
 897   char *tokptr = lexptr;
 898   int ival = 0;
 899
 900   /* All character literals must start with a single quote.  If we don't
 901      find it, don't bother looking any further. */
 902
 903   if (*tokptr++ != '\'')
 904     {
 905       return (0);
 906     }
 907
 908   /* Determine which form we have, either a control sequence or the
 909      single character form. */
 910
 911   if ((*tokptr == '^') && (*(tokptr + 1) == '('))
 912     {
 913       /* Match and decode a control sequence.  Return zero if we don't
 914          find a valid integer literal, or if the next unconsumed character
 915          after the integer literal is not the trailing ')'.
 916          FIXME:  We currently don't handle the multiple integer literal
 917          form. */
 918       tokptr += 2;
 919       if (!decode_integer_literal (&ival, &tokptr) || (*tokptr++ != ')'))
 920         {
 921           return (0);
 922         }
 923     }
 924   else
 925     {
 926       ival = *tokptr++;
 927     }
 928
 929   /* The trailing quote has not yet been consumed.  If we don't find
 930      it, then we have no match. */
 931
 932   if (*tokptr++ != '\'')
 933     {
 934       return (0);
 935     }
 936
 937   yylval.typed_val.val = ival;
 938   yylval.typed_val.type = builtin_type_chill_char;
 939   lexptr = tokptr;
 940   return (CHARACTER_LITERAL);
 941 }
 942
 943 /* Recognize an integer literal, as specified in Z.200 sec 5.2.4.2.
 944    Note that according to 5.2.4.2, a single "_" is also a valid integer
 945    literal, however GNU-chill requires there to be at least one "digit"
 946    in any integer literal. */
 947
 948 static int
 949 match_integer_literal ()
 950 {
 951   char *tokptr = lexptr;
 952   int ival = 0;
 953   int base = 0;
 954   int digits = 0;
 955   int temp;
 956
 957   /* Look for an explicit base specifier, which is optional. */
 958
 959   switch (*tokptr)
 960     {
 961     case 'd':
 962     case 'D':
 963       base = 10;
 964       tokptr++;
 965       break;
 966     case 'b':
 967     case 'B':
 968       base = 2;
 969       tokptr++;
 970       break;
 971     case 'h':
 972     case 'H':
 973       base = 16;
 974       tokptr++;
 975       break;
 976     case 'o':
 977     case 'O':
 978       base = 8;
 979       tokptr++;
 980       break;
 981     }
 982
 983   /* If we found no explicit base then default to 10, otherwise ensure
 984      that the character after the explicit base is a single quote. */
 985
 986   if (base == 0)
 987     {
 988       base = 10;
 989     }
 990   else
 991     {
 992       if (*tokptr++ != '\'')
 993         {
 994           return (0);
 995         }
 996     }
 997
 998   /* Start looking for a value composed of valid digits as set by the base
 999      in use.  Note that '_' characters are valid anywhere, in any quantity,
1000      and are simply ignored.  Since we must find at least one valid digit,
1001      or reject this token as an integer literal, we keep track of how many
1002      digits we have encountered. */
1003
1004   while (*tokptr != '\0')
1005     {
1006       temp = tolower (*tokptr);
1007       tokptr++;
1008       switch (temp)
1009         {
1010         case '_':
1011           continue;
1012         case '0':  case '1':  case '2':  case '3':  case '4':
1013         case '5':  case '6':  case '7':  case '8':  case '9':
1014           temp -= '0';
1015           break;
1016         case 'a':  case 'b':  case 'c':  case 'd':  case 'e': case 'f':
1017           temp -= 'a';
1018           temp += 10;
1019           break;
1020         default:
1021           temp = base;
1022           break;
1023         }
1024       if (temp < base)
1025         {
1026           digits++;
1027           ival *= base;
1028           ival += temp;
1029         }
1030       else
1031         {
1032           /* Found something not in domain for current base. */
1033           tokptr--;     /* Unconsume what gave us indigestion. */
1034           break;
1035         }
1036     }
1037
1038   /* If we didn't find any digits, then we don't have a valid integer
1039      literal, so reject the entire token.  Otherwise, set up the parser
1040      variables, advance the current lexical scan pointer, and return the
1041      INTEGER_LITERAL token. */
1042
1043   if (digits == 0)
1044     {
1045       return (0);
1046     }
1047   else
1048     {
1049       yylval.typed_val.val = ival;
1050       yylval.typed_val.type = builtin_type_int;
1051       lexptr = tokptr;
1052       return (INTEGER_LITERAL);
1053     }
1054 }
1055
1056 static void convert_float ()
1057 {
1058 #if 0
1059     extern double strtod ();
1060     double d;
1061     char        tmp[256];
1062     char        *p = yytext, *p1 = tmp;
1063     char        c;
1064
1065     while (c = *p++)
1066     {
1067         switch (c)
1068         {
1069         case '_':
1070             break;
1071         case 'E':
1072         case 'd':
1073         case 'D':
1074             *p1++ = 'e';
1075             break;
1076         default:
1077             *p1++ = c;
1078             break;
1079         }
1080     }
1081     *p1 = '\0';
1082     d = strtod (tmp, &p1);
1083     if (*p1)
1084     {
1085         /* add error handling here */
1086         ;
1087     }
1088     yylval.dval = d;
1089 #endif
1090 }
1091
1092 /* Take care of parsing a number (anything that starts with a digit).
1093    Set yylval and return the token type; update lexptr.
1094    LEN is the number of characters in it.  */
1095
1096 /*** Needs some error checking for the float case ***/
1097
1098 static int
1099 parse_number ()
1100 {
1101 }
1102
1103 struct token
1104 {
1105   char *operator;
1106   int token;
1107 };
1108
1109 const static struct token tokentab5[] =
1110 {
1111     { "ANDIF", ANDIF }
1112 };
1113
1114 const static struct token tokentab4[] =
1115 {
1116     { "ORIF", ORIF }
1117 };
1118
1119 const static struct token tokentab3[] =
1120 {
1121     { "NOT", NOT },
1122     { "XOR", LOGXOR },
1123     { "AND", LOGAND }
1124 };
1125
1126 const static struct token tokentab2[] =
1127 {
1128     { "//", SLASH_SLASH },
1129     { "/=", NOTEQUAL },
1130     { "<=", LEQ },
1131     { ">=", GTR },
1132     { "IN", IN },
1133     { "OR", LOGIOR }
1134 };
1135
1136 /* Read one token, getting characters through lexptr.  */
1137 /* This is where we will check to make sure that the language and the
1138    operators used are compatible.  */
1139
1140 static int
1141 yylex ()
1142 {
1143     unsigned int i;
1144     int token;
1145
1146     /* Skip over any leading whitespace. */
1147     while (isspace (*lexptr))
1148         {
1149             lexptr++;
1150         }
1151     /* Look for special single character cases which can't be the first
1152        character of some other multicharacter token. */
1153     switch (*lexptr)
1154         {
1155             case '\0':
1156                 return (0);
1157             case '.':
1158             case '=':
1159             case ':':
1160             case ';':
1161             case '!':
1162             case '+':
1163             case '-':
1164             case '*':
1165             case '/':
1166             case '(':
1167             case ')':
1168             case '[':
1169             case ']':
1170                 return (*lexptr++);
1171         }
1172     /* Look for characters which start a particular kind of multicharacter
1173        token, such as a character literal. */
1174     switch (*lexptr)
1175       {
1176         case '^':
1177         case '\'':
1178           token = match_character_literal ();
1179           if (token != 0)
1180             {
1181               return (token);
1182             }
1183           break;
1184       }
1185     /* See if it is a special token of length 5.  */
1186     for (i = 0; i < sizeof (tokentab5) / sizeof (tokentab5[0]); i++)
1187         {
1188             if (strncmp (lexptr, tokentab5[i].operator, 5) == 0)
1189                 {
1190                     lexptr += 5;
1191                     return (tokentab5[i].token);
1192                 }
1193         }
1194     /* See if it is a special token of length 4.  */
1195     for (i = 0; i < sizeof (tokentab4) / sizeof (tokentab4[0]); i++)
1196         {
1197             if (strncmp (lexptr, tokentab4[i].operator, 4) == 0)
1198                 {
1199                     lexptr += 4;
1200                     return (tokentab4[i].token);
1201                 }
1202         }
1203     /* See if it is a special token of length 3.  */
1204     for (i = 0; i < sizeof (tokentab3) / sizeof (tokentab3[0]); i++)
1205         {
1206             if (strncmp (lexptr, tokentab3[i].operator, 3) == 0)
1207                 {
1208                     lexptr += 3;
1209                     return (tokentab3[i].token);
1210                 }
1211         }
1212     /* See if it is a special token of length 2.  */
1213     for (i = 0; i < sizeof (tokentab2) / sizeof (tokentab2[0]); i++)
1214         {
1215             if (strncmp (lexptr, tokentab2[i].operator, 2) == 0)
1216                 {
1217                     lexptr += 2;
1218                     return (tokentab2[i].token);
1219                 }
1220         }
1221     /* Look for single character cases which which could be the first
1222        character of some other multicharacter token, but aren't, or we
1223        would already have found it. */
1224     switch (*lexptr)
1225         {
1226             case '/':
1227             case '<':
1228             case '>':
1229                 return (*lexptr++);
1230         }
1231     /* Look for other special tokens. */
1232     if (strncmp (lexptr, "TRUE", 4) == 0) /* FIXME:  What about lowercase? */
1233         {
1234             yylval.ulval = 1;
1235             lexptr += 4;
1236             return (BOOLEAN_LITERAL);
1237         }
1238     if (strncmp (lexptr, "FALSE", 5) == 0) /* FIXME:  What about lowercase? */
1239         {
1240             yylval.ulval = 0;
1241             lexptr += 5;
1242             return (BOOLEAN_LITERAL);
1243         }
1244     token = match_integer_literal ();
1245     if (token != 0);
1246         {
1247             return (token);
1248         }
1249     return (ILLEGAL_TOKEN);
1250 }
1251
1252 static void
1253 yyerror (msg)
1254      char *msg; /* unused */
1255 {
1256   printf ("Parsing:  %s\n", lexptr);
1257   if (yychar < 256)
1258     {
1259       error ("Invalid syntax in expression near character '%c'.", yychar);
1260     }
1261   else
1262     {
1263       error ("Invalid syntax in expression");
1264     }
1265 }
1266
1267 \f
1268 /* Table of operators and their precedences for printing expressions.  */
1269
1270 const static struct op_print chill_op_print_tab[] = {
1271     {"AND", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
1272     {"OR",  BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
1273     {"NOT", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
1274     {"MOD", BINOP_REM, PREC_MUL, 0},
1275     {":=",  BINOP_ASSIGN, PREC_ASSIGN, 1},
1276     {"=",   BINOP_EQUAL, PREC_EQUAL, 0},
1277     {"/=",  BINOP_NOTEQUAL, PREC_EQUAL, 0},
1278     {"<=",  BINOP_LEQ, PREC_ORDER, 0},
1279     {">=",  BINOP_GEQ, PREC_ORDER, 0},
1280     {">",   BINOP_GTR, PREC_ORDER, 0},
1281     {"<",   BINOP_LESS, PREC_ORDER, 0},
1282     {"+",   BINOP_ADD, PREC_ADD, 0},
1283     {"-",   BINOP_SUB, PREC_ADD, 0},
1284     {"*",   BINOP_MUL, PREC_MUL, 0},
1285     {"/",   BINOP_DIV, PREC_MUL, 0},
1286     {"-",   UNOP_NEG, PREC_PREFIX, 0},
1287     {NULL,  0, 0, 0}
1288 };
1289
1290 \f
1291 /* The built-in types of Chill.  */
1292
1293 struct type *builtin_type_chill_bool;
1294 struct type *builtin_type_chill_char;
1295 struct type *builtin_type_chill_long;
1296 struct type *builtin_type_chill_ulong;
1297 struct type *builtin_type_chill_real;
1298
1299 struct type ** const (chill_builtin_types[]) =
1300 {
1301   &builtin_type_chill_bool,
1302   &builtin_type_chill_char,
1303   &builtin_type_chill_long,
1304   &builtin_type_chill_ulong,
1305   &builtin_type_chill_real,
1306   0
1307 };
1308
1309 const struct language_defn chill_language_defn = {
1310   "chill",
1311   language_chill,
1312   chill_builtin_types,
1313   range_check_on,
1314   type_check_on,
1315   chill_parse,                  /* parser */
1316   chill_error,                  /* parser error function */
1317   &BUILTIN_TYPE_LONGEST,        /* longest signed   integral type */
1318   &BUILTIN_TYPE_UNSIGNED_LONGEST,/* longest unsigned integral type */
1319   &builtin_type_chill_real,     /* longest floating point type */
1320   {"",      "B'",  "",   ""},   /* Binary format info */
1321   {"O'%o",  "O'",  "o",  ""},   /* Octal format info */
1322   {"D'%d",  "D'",  "d",  ""},   /* Decimal format info */
1323   {"H'%x",  "H'",  "x",  ""},   /* Hex format info */
1324   chill_op_print_tab,           /* expression operators for printing */
1325   LANG_MAGIC
1326 };
1327
1328 /* Initialization for Chill */
1329
1330 void
1331 _initialize_chill_exp ()
1332 {
1333   builtin_type_chill_bool =
1334     init_type (TYPE_CODE_BOOL, TARGET_INT_BIT / TARGET_CHAR_BIT,
1335                TYPE_FLAG_UNSIGNED,
1336                "BOOL", (struct objfile *) NULL);
1337   builtin_type_chill_char =
1338     init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
1339                TYPE_FLAG_UNSIGNED,
1340                "CHAR", (struct objfile *) NULL);
1341   builtin_type_chill_long =
1342     init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
1343                0,
1344                "LONG", (struct objfile *) NULL);
1345   builtin_type_chill_ulong =
1346     init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
1347                TYPE_FLAG_UNSIGNED,
1348                "ULONG", (struct objfile *) NULL);
1349   builtin_type_chill_real =
1350     init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
1351                0,
1352                "LONG_REAL", (struct objfile *) NULL);
1353
1354   add_language (&chill_language_defn);
1355 }