gdb/rust-exp.y

   1 /* Bison parser for Rust expressions, for GDB.
   2    Copyright (C) 2016 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 3 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, see <http://www.gnu.org/licenses/>.  */
  18
  19 /* Removing the last conflict seems difficult.  */
  20 %expect 1
  21
  22 %{
  23
  24 #include "defs.h"
  25
  26 #include "block.h"
  27 #include "charset.h"
  28 #include "cp-support.h"
  29 #include "gdb_obstack.h"
  30 #include "gdb_regex.h"
  31 #include "rust-lang.h"
  32 #include "parser-defs.h"
  33 #include "selftest.h"
  34 #include "value.h"
  35 #include "vec.h"
  36
  37 #define GDB_YY_REMAP_PREFIX rust
  38 #include "yy-remap.h"
  39
  40 #define RUSTSTYPE YYSTYPE
  41
  42 extern initialize_file_ftype _initialize_rust_exp;
  43
  44 struct rust_op;
  45 typedef const struct rust_op *rust_op_ptr;
  46 DEF_VEC_P (rust_op_ptr);
  47
  48 /* A typed integer constant.  */
  49
  50 struct typed_val_int
  51 {
  52   LONGEST val;
  53   struct type *type;
  54 };
  55
  56 /* A typed floating point constant.  */
  57
  58 struct typed_val_float
  59 {
  60   DOUBLEST dval;
  61   struct type *type;
  62 };
  63
  64 /* An identifier and an expression.  This is used to represent one
  65    element of a struct initializer.  */
  66
  67 struct set_field
  68 {
  69   struct stoken name;
  70   const struct rust_op *init;
  71 };
  72
  73 typedef struct set_field set_field;
  74
  75 DEF_VEC_O (set_field);
  76
  77
  78 static int rustyylex (void);
  79 static void rust_push_back (char c);
  80 static const char *rust_copy_name (const char *, int);
  81 static struct stoken rust_concat3 (const char *, const char *, const char *);
  82 static struct stoken make_stoken (const char *);
  83 static struct block_symbol rust_lookup_symbol (const char *name,
  84                                                const struct block *block,
  85                                                const domain_enum domain);
  86 static struct type *rust_lookup_type (const char *name,
  87                                       const struct block *block);
  88 static struct type *rust_type (const char *name);
  89
  90 static const struct rust_op *crate_name (const struct rust_op *name);
  91 static const struct rust_op *super_name (const struct rust_op *name,
  92                                          unsigned int n_supers);
  93
  94 static const struct rust_op *ast_operation (enum exp_opcode opcode,
  95                                             const struct rust_op *left,
  96                                             const struct rust_op *right);
  97 static const struct rust_op *ast_compound_assignment
  98   (enum exp_opcode opcode, const struct rust_op *left,
  99    const struct rust_op *rust_op);
 100 static const struct rust_op *ast_literal (struct typed_val_int val);
 101 static const struct rust_op *ast_dliteral (struct typed_val_float val);
 102 static const struct rust_op *ast_structop (const struct rust_op *left,
 103                                            const char *name,
 104                                            int completing);
 105 static const struct rust_op *ast_structop_anonymous
 106   (const struct rust_op *left, struct typed_val_int number);
 107 static const struct rust_op *ast_unary (enum exp_opcode opcode,
 108                                         const struct rust_op *expr);
 109 static const struct rust_op *ast_cast (const struct rust_op *expr,
 110                                        const struct rust_op *type);
 111 static const struct rust_op *ast_call_ish (enum exp_opcode opcode,
 112                                            const struct rust_op *expr,
 113                                            VEC (rust_op_ptr) **params);
 114 static const struct rust_op *ast_path (struct stoken name,
 115                                        VEC (rust_op_ptr) **params);
 116 static const struct rust_op *ast_string (struct stoken str);
 117 static const struct rust_op *ast_struct (const struct rust_op *name,
 118                                          VEC (set_field) **fields);
 119 static const struct rust_op *ast_range (const struct rust_op *lhs,
 120                                         const struct rust_op *rhs);
 121 static const struct rust_op *ast_array_type (const struct rust_op *lhs,
 122                                              struct typed_val_int val);
 123 static const struct rust_op *ast_slice_type (const struct rust_op *type);
 124 static const struct rust_op *ast_reference_type (const struct rust_op *type);
 125 static const struct rust_op *ast_pointer_type (const struct rust_op *type,
 126                                                int is_mut);
 127 static const struct rust_op *ast_function_type (const struct rust_op *result,
 128                                                 VEC (rust_op_ptr) **params);
 129 static const struct rust_op *ast_tuple_type (VEC (rust_op_ptr) **params);
 130
 131 /* The state of the parser, used internally when we are parsing the
 132    expression.  */
 133
 134 static struct parser_state *pstate = NULL;
 135
 136 /* A regular expression for matching Rust numbers.  This is split up
 137    since it is very long and this gives us a way to comment the
 138    sections.  */
 139
 140 static const char *number_regex_text =
 141   /* subexpression 1: allows use of alternation, otherwise uninteresting */
 142   "^("
 143   /* First comes floating point.  */
 144   /* Recognize number after the decimal point, with optional
 145      exponent and optional type suffix.
 146      subexpression 2: allows "?", otherwise uninteresting
 147      subexpression 3: if present, type suffix
 148   */
 149   "[0-9][0-9_]*\\.[0-9][0-9_]*([eE][-+]?[0-9][0-9_]*)?(f32|f64)?"
 150 #define FLOAT_TYPE1 3
 151   "|"
 152   /* Recognize exponent without decimal point, with optional type
 153      suffix.
 154      subexpression 4: if present, type suffix
 155   */
 156 #define FLOAT_TYPE2 4
 157   "[0-9][0-9_]*[eE][-+]?[0-9][0-9_]*(f32|f64)?"
 158   "|"
 159   /* "23." is a valid floating point number, but "23.e5" and
 160      "23.f32" are not.  So, handle the trailing-. case
 161      separately.  */
 162   "[0-9][0-9_]*\\."
 163   "|"
 164   /* Finally come integers.
 165      subexpression 5: text of integer
 166      subexpression 6: if present, type suffix
 167      subexpression 7: allows use of alternation, otherwise uninteresting
 168   */
 169 #define INT_TEXT 5
 170 #define INT_TYPE 6
 171   "(0x[a-fA-F0-9_]+|0o[0-7_]+|0b[01_]+|[0-9][0-9_]*)"
 172   "([iu](size|8|16|32|64))?"
 173   ")";
 174 /* The number of subexpressions to allocate space for, including the
 175    "0th" whole match subexpression.  */
 176 #define NUM_SUBEXPRESSIONS 8
 177
 178 /* The compiled number-matching regex.  */
 179
 180 static regex_t number_regex;
 181
 182 /* True if we're running unit tests.  */
 183
 184 static int unit_testing;
 185
 186 /* Obstack for data temporarily allocated during parsing.  */
 187
 188 static struct obstack work_obstack;
 189
 190 /* Result of parsing.  Points into work_obstack.  */
 191
 192 static const struct rust_op *rust_ast;
 193
 194 %}
 195
 196 %union
 197 {
 198   /* A typed integer constant.  */
 199   struct typed_val_int typed_val_int;
 200
 201   /* A typed floating point constant.  */
 202   struct typed_val_float typed_val_float;
 203
 204   /* An identifier or string.  */
 205   struct stoken sval;
 206
 207   /* A token representing an opcode, like "==".  */
 208   enum exp_opcode opcode;
 209
 210   /* A list of expressions; for example, the arguments to a function
 211      call.  */
 212   VEC (rust_op_ptr) **params;
 213
 214   /* A list of field initializers.  */
 215   VEC (set_field) **field_inits;
 216
 217   /* A single field initializer.  */
 218   struct set_field one_field_init;
 219
 220   /* An expression.  */
 221   const struct rust_op *op;
 222
 223   /* A plain integer, for example used to count the number of
 224      "super::" prefixes on a path.  */
 225   unsigned int depth;
 226 }
 227
 228 %{
 229
 230   /* Rust AST operations.  We build a tree of these; then lower them
 231      to gdb expressions when parsing has completed.  */
 232
 233 struct rust_op
 234 {
 235   /* The opcode.  */
 236   enum exp_opcode opcode;
 237   /* If OPCODE is OP_TYPE, then this holds information about what type
 238      is described by this node.  */
 239   enum type_code typecode;
 240   /* Indicates whether OPCODE actually represents a compound
 241      assignment.  For example, if OPCODE is GTGT and this is false,
 242      then this rust_op represents an ordinary ">>"; but if this is
 243      true, then this rust_op represents ">>=".  Unused in other
 244      cases.  */
 245   unsigned int compound_assignment : 1;
 246   /* Only used by a field expression; if set, indicates that the field
 247      name occurred at the end of the expression and is eligible for
 248      completion.  */
 249   unsigned int completing : 1;
 250   /* Operands of expression.  Which one is used and how depends on the
 251      particular opcode.  */
 252   RUSTSTYPE left;
 253   RUSTSTYPE right;
 254 };
 255
 256 %}
 257
 258 %token <sval> GDBVAR
 259 %token <sval> IDENT
 260 %token <sval> COMPLETE
 261 %token <typed_val_int> INTEGER
 262 %token <typed_val_int> DECIMAL_INTEGER
 263 %token <sval> STRING
 264 %token <sval> BYTESTRING
 265 %token <typed_val_float> FLOAT
 266 %token <opcode> COMPOUND_ASSIGN
 267
 268 /* Keyword tokens.  */
 269 %token <voidval> KW_AS
 270 %token <voidval> KW_IF
 271 %token <voidval> KW_TRUE
 272 %token <voidval> KW_FALSE
 273 %token <voidval> KW_SUPER
 274 %token <voidval> KW_SELF
 275 %token <voidval> KW_MUT
 276 %token <voidval> KW_EXTERN
 277 %token <voidval> KW_CONST
 278 %token <voidval> KW_FN
 279
 280 /* Operator tokens.  */
 281 %token <voidval> DOTDOT
 282 %token <voidval> OROR
 283 %token <voidval> ANDAND
 284 %token <voidval> EQEQ
 285 %token <voidval> NOTEQ
 286 %token <voidval> LTEQ
 287 %token <voidval> GTEQ
 288 %token <voidval> LSH RSH
 289 %token <voidval> COLONCOLON
 290 %token <voidval> ARROW
 291
 292 %type <op> type
 293 %type <op> path_for_expr
 294 %type <op> identifier_path_for_expr
 295 %type <op> path_for_type
 296 %type <op> identifier_path_for_type
 297 %type <op> just_identifiers_for_type
 298
 299 %type <params> maybe_type_list
 300 %type <params> type_list
 301
 302 %type <depth> super_path
 303
 304 %type <op> literal
 305 %type <op> expr
 306 %type <op> field_expr
 307 %type <op> idx_expr
 308 %type <op> unop_expr
 309 %type <op> binop_expr
 310 %type <op> binop_expr_expr
 311 %type <op> type_cast_expr
 312 %type <op> assignment_expr
 313 %type <op> compound_assignment_expr
 314 %type <op> paren_expr
 315 %type <op> call_expr
 316 %type <op> path_expr
 317 %type <op> tuple_expr
 318 %type <op> unit_expr
 319 %type <op> struct_expr
 320 %type <op> array_expr
 321 %type <op> range_expr
 322
 323 %type <params> expr_list
 324 %type <params> maybe_expr_list
 325 %type <params> paren_expr_list
 326
 327 %type <field_inits> struct_expr_list
 328 %type <one_field_init> struct_expr_tail
 329
 330 /* Precedence.  */
 331 %nonassoc DOTDOT
 332 %right '=' COMPOUND_ASSIGN
 333 %left OROR
 334 %left ANDAND
 335 %nonassoc EQEQ NOTEQ '<' '>' LTEQ GTEQ
 336 %left '|'
 337 %left '^'
 338 %left '&'
 339 %left LSH RSH
 340 %left '@'
 341 %left '+' '-'
 342 %left '*' '/' '%'
 343 /* These could be %precedence in Bison, but that isn't a yacc
 344    feature.  */
 345 %left KW_AS
 346 %left UNARY
 347 %left '[' '.' '('
 348
 349 %%
 350
 351 start:
 352         expr
 353                 {
 354                   /* If we are completing and see a valid parse,
 355                      rust_ast will already have been set.  */
 356                   if (rust_ast == NULL)
 357                     rust_ast = $1;
 358                 }
 359 ;
 360
 361 /* Note that the Rust grammar includes a method_call_expr, but we
 362    handle this differently, to avoid a shift/reduce conflict with
 363    call_expr.  */
 364 expr:
 365         literal
 366 |       path_expr
 367 |       tuple_expr
 368 |       unit_expr
 369 |       struct_expr
 370 |       field_expr
 371 |       array_expr
 372 |       idx_expr
 373 |       range_expr
 374 |       unop_expr
 375 |       binop_expr
 376 |       paren_expr
 377 |       call_expr
 378 ;
 379
 380 tuple_expr:
 381         '(' expr ',' maybe_expr_list ')'
 382                 {
 383                   VEC_safe_insert (rust_op_ptr, *$4, 0, $2);
 384                   error (_("Tuple expressions not supported yet"));
 385                 }
 386 ;
 387
 388 unit_expr:
 389         '(' ')'
 390                 {
 391                   struct typed_val_int val;
 392
 393                   val.type
 394                     = language_lookup_primitive_type (parse_language (pstate),
 395                                                       parse_gdbarch (pstate),
 396                                                       "()");
 397                   val.val = 0;
 398                   $$ = ast_literal (val);
 399                 }
 400 ;
 401
 402 /* To avoid a shift/reduce conflict with call_expr, we don't handle
 403    tuple struct expressions here, but instead when examining the
 404    AST.  */
 405 struct_expr:
 406         path_for_expr '{' struct_expr_list '}'
 407                 { $$ = ast_struct ($1, $3); }
 408 ;
 409
 410 struct_expr_tail:
 411         DOTDOT expr
 412                 {
 413                   struct set_field sf;
 414
 415                   sf.name.ptr = NULL;
 416                   sf.name.length = 0;
 417                   sf.init = $2;
 418
 419                   $$ = sf;
 420                 }
 421 |       IDENT ':' expr
 422                 {
 423                   struct set_field sf;
 424
 425                   sf.name = $1;
 426                   sf.init = $3;
 427                   $$ = sf;
 428                 }
 429 ;
 430
 431 /* S{} is documented as valid but seems to be an unstable feature, so
 432    it is left out here.  */
 433 struct_expr_list:
 434         struct_expr_tail
 435                 {
 436                   VEC (set_field) **result
 437                     = OBSTACK_ZALLOC (&work_obstack, VEC (set_field) *);
 438
 439                   make_cleanup (VEC_cleanup (set_field), result);
 440                   VEC_safe_push (set_field, *result, &$1);
 441
 442                   $$ = result;
 443                 }
 444 |       IDENT ':' expr ',' struct_expr_list
 445                 {
 446                   struct set_field sf;
 447
 448                   sf.name = $1;
 449                   sf.init = $3;
 450                   VEC_safe_push (set_field, *$5, &sf);
 451                   $$ = $5;
 452                 }
 453 ;
 454
 455 array_expr:
 456         '[' KW_MUT expr_list ']'
 457                 { $$ = ast_call_ish (OP_ARRAY, NULL, $3); }
 458 |       '[' expr_list ']'
 459                 { $$ = ast_call_ish (OP_ARRAY, NULL, $2); }
 460 |       '[' KW_MUT expr ';' expr ']'
 461                 { $$ = ast_operation (OP_RUST_ARRAY, $3, $5); }
 462 |       '[' expr ';' expr ']'
 463                 { $$ = ast_operation (OP_RUST_ARRAY, $2, $4); }
 464 ;
 465
 466 range_expr:
 467         expr DOTDOT
 468                 { $$ = ast_range ($1, NULL); }
 469 |       expr DOTDOT expr
 470                 { $$ = ast_range ($1, $3); }
 471 |       DOTDOT expr
 472                 { $$ = ast_range (NULL, $2); }
 473 |       DOTDOT
 474                 { $$ = ast_range (NULL, NULL); }
 475 ;
 476
 477 literal:
 478         INTEGER
 479                 { $$ = ast_literal ($1); }
 480 |       DECIMAL_INTEGER
 481                 { $$ = ast_literal ($1); }
 482 |       FLOAT
 483                 { $$ = ast_dliteral ($1); }
 484 |       STRING
 485                 {
 486                   const struct rust_op *str = ast_string ($1);
 487                   VEC (set_field) **fields;
 488                   struct set_field field;
 489                   struct typed_val_int val;
 490                   struct stoken token;
 491
 492                   fields = OBSTACK_ZALLOC (&work_obstack, VEC (set_field) *);
 493                   make_cleanup (VEC_cleanup (set_field), fields);
 494
 495                   /* Wrap the raw string in the &str struct.  */
 496                   field.name.ptr = "data_ptr";
 497                   field.name.length = strlen (field.name.ptr);
 498                   field.init = ast_unary (UNOP_ADDR, ast_string ($1));
 499                   VEC_safe_push (set_field, *fields, &field);
 500
 501                   val.type = rust_type ("usize");
 502                   val.val = $1.length;
 503
 504                   field.name.ptr = "length";
 505                   field.name.length = strlen (field.name.ptr);
 506                   field.init = ast_literal (val);
 507                   VEC_safe_push (set_field, *fields, &field);
 508
 509                   token.ptr = "&str";
 510                   token.length = strlen (token.ptr);
 511                   $$ = ast_struct (ast_path (token, NULL), fields);
 512                 }
 513 |       BYTESTRING
 514                 { $$ = ast_string ($1); }
 515 |       KW_TRUE
 516                 {
 517                   struct typed_val_int val;
 518
 519                   val.type = language_bool_type (parse_language (pstate),
 520                                                  parse_gdbarch (pstate));
 521                   val.val = 1;
 522                   $$ = ast_literal (val);
 523                 }
 524 |       KW_FALSE
 525                 {
 526                   struct typed_val_int val;
 527
 528                   val.type = language_bool_type (parse_language (pstate),
 529                                                  parse_gdbarch (pstate));
 530                   val.val = 0;
 531                   $$ = ast_literal (val);
 532                 }
 533 ;
 534
 535 field_expr:
 536         expr '.' IDENT
 537                 { $$ = ast_structop ($1, $3.ptr, 0); }
 538 |       expr '.' COMPLETE
 539                 {
 540                   $$ = ast_structop ($1, $3.ptr, 1);
 541                   rust_ast = $$;
 542                 }
 543 |       expr '.' DECIMAL_INTEGER
 544                 { $$ = ast_structop_anonymous ($1, $3); }
 545 ;
 546
 547 idx_expr:
 548         expr '[' expr ']'
 549                 { $$ = ast_operation (BINOP_SUBSCRIPT, $1, $3); }
 550 ;
 551
 552 unop_expr:
 553         '+' expr        %prec UNARY
 554                 { $$ = ast_unary (UNOP_PLUS, $2); }
 555
 556 |       '-' expr        %prec UNARY
 557                 { $$ = ast_unary (UNOP_NEG, $2); }
 558
 559 |       '!' expr        %prec UNARY
 560                 {
 561                   /* Note that we provide a Rust-specific evaluator
 562                      override for UNOP_COMPLEMENT, so it can do the
 563                      right thing for both bool and integral
 564                      values.  */
 565                   $$ = ast_unary (UNOP_COMPLEMENT, $2);
 566                 }
 567
 568 |       '*' expr        %prec UNARY
 569                 { $$ = ast_unary (UNOP_IND, $2); }
 570
 571 |       '&' expr        %prec UNARY
 572                 { $$ = ast_unary (UNOP_ADDR, $2); }
 573
 574 |       '&' KW_MUT expr %prec UNARY
 575                 { $$ = ast_unary (UNOP_ADDR, $3); }
 576
 577 ;
 578
 579 binop_expr:
 580         binop_expr_expr
 581 |       type_cast_expr
 582 |       assignment_expr
 583 |       compound_assignment_expr
 584 ;
 585
 586 binop_expr_expr:
 587         expr '*' expr
 588                 { $$ = ast_operation (BINOP_MUL, $1, $3); }
 589
 590 |       expr '@' expr
 591                 { $$ = ast_operation (BINOP_REPEAT, $1, $3); }
 592
 593 |       expr '/' expr
 594                 { $$ = ast_operation (BINOP_DIV, $1, $3); }
 595
 596 |       expr '%' expr
 597                 { $$ = ast_operation (BINOP_REM, $1, $3); }
 598
 599 |       expr '<' expr
 600                 { $$ = ast_operation (BINOP_LESS, $1, $3); }
 601
 602 |       expr '>' expr
 603                 { $$ = ast_operation (BINOP_GTR, $1, $3); }
 604
 605 |       expr '&' expr
 606                 { $$ = ast_operation (BINOP_BITWISE_AND, $1, $3); }
 607
 608 |       expr '|' expr
 609                 { $$ = ast_operation (BINOP_BITWISE_IOR, $1, $3); }
 610
 611 |       expr '^' expr
 612                 { $$ = ast_operation (BINOP_BITWISE_XOR, $1, $3); }
 613
 614 |       expr '+' expr
 615                 { $$ = ast_operation (BINOP_ADD, $1, $3); }
 616
 617 |       expr '-' expr
 618                 { $$ = ast_operation (BINOP_SUB, $1, $3); }
 619
 620 |       expr OROR expr
 621                 { $$ = ast_operation (BINOP_LOGICAL_OR, $1, $3); }
 622
 623 |       expr ANDAND expr
 624                 { $$ = ast_operation (BINOP_LOGICAL_AND, $1, $3); }
 625
 626 |       expr EQEQ expr
 627                 { $$ = ast_operation (BINOP_EQUAL, $1, $3); }
 628
 629 |       expr NOTEQ expr
 630                 { $$ = ast_operation (BINOP_NOTEQUAL, $1, $3); }
 631
 632 |       expr LTEQ expr
 633                 { $$ = ast_operation (BINOP_LEQ, $1, $3); }
 634
 635 |       expr GTEQ expr
 636                 { $$ = ast_operation (BINOP_GEQ, $1, $3); }
 637
 638 |       expr LSH expr
 639                 { $$ = ast_operation (BINOP_LSH, $1, $3); }
 640
 641 |       expr RSH expr
 642                 { $$ = ast_operation (BINOP_RSH, $1, $3); }
 643 ;
 644
 645 type_cast_expr:
 646         expr KW_AS type
 647                 { $$ = ast_cast ($1, $3); }
 648 ;
 649
 650 assignment_expr:
 651         expr '=' expr
 652                 { $$ = ast_operation (BINOP_ASSIGN, $1, $3); }
 653 ;
 654
 655 compound_assignment_expr:
 656         expr COMPOUND_ASSIGN expr
 657                 { $$ = ast_compound_assignment ($2, $1, $3); }
 658
 659 ;
 660
 661 paren_expr:
 662         '(' expr ')'
 663                 { $$ = $2; }
 664 ;
 665
 666 expr_list:
 667         expr
 668                 {
 669                   $$ = OBSTACK_ZALLOC (&work_obstack, VEC (rust_op_ptr) *);
 670                   make_cleanup (VEC_cleanup (rust_op_ptr), $$);
 671                   VEC_safe_push (rust_op_ptr, *$$, $1);
 672                 }
 673 |       expr_list ',' expr
 674                 {
 675                   VEC_safe_push (rust_op_ptr, *$1, $3);
 676                   $$ = $1;
 677                 }
 678 ;
 679
 680 maybe_expr_list:
 681         /* %empty */
 682                 {
 683                   /* The result can't be NULL.  */
 684                   $$ = OBSTACK_ZALLOC (&work_obstack, VEC (rust_op_ptr) *);
 685                   make_cleanup (VEC_cleanup (rust_op_ptr), $$);
 686                 }
 687 |       expr_list
 688                 { $$ = $1; }
 689 ;
 690
 691 paren_expr_list:
 692         '('
 693         maybe_expr_list
 694         ')'
 695                 { $$ = $2; }
 696 ;
 697
 698 call_expr:
 699         expr paren_expr_list
 700                 { $$ = ast_call_ish (OP_FUNCALL, $1, $2); }
 701 ;
 702
 703 maybe_self_path:
 704         /* %empty */
 705 |       KW_SELF COLONCOLON
 706 ;
 707
 708 super_path:
 709         KW_SUPER COLONCOLON
 710                 { $$ = 1; }
 711 |       super_path KW_SUPER COLONCOLON
 712                 { $$ = $1 + 1; }
 713 ;
 714
 715 path_expr:
 716         path_for_expr
 717                 { $$ = $1; }
 718 |       GDBVAR
 719                 { $$ = ast_path ($1, NULL); }
 720 |       KW_SELF
 721                 { $$ = ast_path (make_stoken ("self"), NULL); }
 722 ;
 723
 724 path_for_expr:
 725         identifier_path_for_expr
 726 |       KW_SELF COLONCOLON identifier_path_for_expr
 727                 { $$ = super_name ($3, 0); }
 728 |       maybe_self_path super_path identifier_path_for_expr
 729                 { $$ = super_name ($3, $2); }
 730 |       COLONCOLON identifier_path_for_expr
 731                 { $$ = crate_name ($2); }
 732 |       KW_EXTERN identifier_path_for_expr
 733                 {
 734                   /* This is a gdb extension to make it possible to
 735                      refer to items in other crates.  It just bypasses
 736                      adding the current crate to the front of the
 737                      name.  */
 738                   $$ = ast_path (rust_concat3 ("::", $2->left.sval.ptr, NULL),
 739                                  $2->right.params);
 740                 }
 741 ;
 742
 743 identifier_path_for_expr:
 744         IDENT
 745                 { $$ = ast_path ($1, NULL); }
 746 |       identifier_path_for_expr COLONCOLON IDENT
 747                 {
 748                   $$ = ast_path (rust_concat3 ($1->left.sval.ptr, "::",
 749                                                $3.ptr),
 750                                  NULL);
 751                 }
 752 |       identifier_path_for_expr COLONCOLON '<' type_list '>'
 753                 { $$ = ast_path ($1->left.sval, $4); }
 754 |       identifier_path_for_expr COLONCOLON '<' type_list RSH
 755                 {
 756                   $$ = ast_path ($1->left.sval, $4);
 757                   rust_push_back ('>');
 758                 }
 759 ;
 760
 761 path_for_type:
 762         identifier_path_for_type
 763 |       KW_SELF COLONCOLON identifier_path_for_type
 764                 { $$ = super_name ($3, 0); }
 765 |       maybe_self_path super_path identifier_path_for_type
 766                 { $$ = super_name ($3, $2); }
 767 |       COLONCOLON identifier_path_for_type
 768                 { $$ = crate_name ($2); }
 769 |       KW_EXTERN identifier_path_for_type
 770                 {
 771                   /* This is a gdb extension to make it possible to
 772                      refer to items in other crates.  It just bypasses
 773                      adding the current crate to the front of the
 774                      name.  */
 775                   $$ = ast_path (rust_concat3 ("::", $2->left.sval.ptr, NULL),
 776                                  $2->right.params);
 777                 }
 778 ;
 779
 780 just_identifiers_for_type:
 781         IDENT
 782                 { $$ = ast_path ($1, NULL); }
 783 |       just_identifiers_for_type COLONCOLON IDENT
 784                 {
 785                   $$ = ast_path (rust_concat3 ($1->left.sval.ptr, "::",
 786                                                $3.ptr),
 787                                  NULL);
 788                 }
 789 ;
 790
 791 identifier_path_for_type:
 792         just_identifiers_for_type
 793 |       just_identifiers_for_type '<' type_list '>'
 794                 { $$ = ast_path ($1->left.sval, $3); }
 795 |       just_identifiers_for_type '<' type_list RSH
 796                 {
 797                   $$ = ast_path ($1->left.sval, $3);
 798                   rust_push_back ('>');
 799                 }
 800 ;
 801
 802 type:
 803         path_for_type
 804 |       '[' type ';' INTEGER ']'
 805                 { $$ = ast_array_type ($2, $4); }
 806 |       '[' type ';' DECIMAL_INTEGER ']'
 807                 { $$ = ast_array_type ($2, $4); }
 808 |       '&' '[' type ']'
 809                 { $$ = ast_slice_type ($3); }
 810 |       '&' type
 811                 { $$ = ast_reference_type ($2); }
 812 |       '*' KW_MUT type
 813                 { $$ = ast_pointer_type ($3, 1); }
 814 |       '*' KW_CONST type
 815                 { $$ = ast_pointer_type ($3, 0); }
 816 |       KW_FN '(' maybe_type_list ')' ARROW type
 817                 { $$ = ast_function_type ($6, $3); }
 818 |       '(' maybe_type_list ')'
 819                 { $$ = ast_tuple_type ($2); }
 820 ;
 821
 822 maybe_type_list:
 823         /* %empty */
 824                 { $$ = NULL; }
 825 |       type_list
 826                 { $$ = $1; }
 827 ;
 828
 829 type_list:
 830         type
 831                 {
 832                   VEC (rust_op_ptr) **result
 833                     = OBSTACK_ZALLOC (&work_obstack, VEC (rust_op_ptr) *);
 834
 835                   make_cleanup (VEC_cleanup (rust_op_ptr), result);
 836                   VEC_safe_push (rust_op_ptr, *result, $1);
 837                   $$ = result;
 838                 }
 839 |       type_list ',' type
 840                 {
 841                   VEC_safe_push (rust_op_ptr, *$1, $3);
 842                   $$ = $1;
 843                 }
 844 ;
 845
 846 %%
 847
 848 /* A struct of this type is used to describe a token.  */
 849
 850 struct token_info
 851 {
 852   const char *name;
 853   int value;
 854   enum exp_opcode opcode;
 855 };
 856
 857 /* Identifier tokens.  */
 858
 859 static const struct token_info identifier_tokens[] =
 860 {
 861   { "as", KW_AS, OP_NULL },
 862   { "false", KW_FALSE, OP_NULL },
 863   { "if", 0, OP_NULL },
 864   { "mut", KW_MUT, OP_NULL },
 865   { "const", KW_CONST, OP_NULL },
 866   { "self", KW_SELF, OP_NULL },
 867   { "super", KW_SUPER, OP_NULL },
 868   { "true", KW_TRUE, OP_NULL },
 869   { "extern", KW_EXTERN, OP_NULL },
 870   { "fn", KW_FN, OP_NULL },
 871 };
 872
 873 /* Operator tokens, sorted longest first.  */
 874
 875 static const struct token_info operator_tokens[] =
 876 {
 877   { ">>=", COMPOUND_ASSIGN, BINOP_RSH },
 878   { "<<=", COMPOUND_ASSIGN, BINOP_LSH },
 879
 880   { "<<", LSH, OP_NULL },
 881   { ">>", RSH, OP_NULL },
 882   { "&&", ANDAND, OP_NULL },
 883   { "||", OROR, OP_NULL },
 884   { "==", EQEQ, OP_NULL },
 885   { "!=", NOTEQ, OP_NULL },
 886   { "<=", LTEQ, OP_NULL },
 887   { ">=", GTEQ, OP_NULL },
 888   { "+=", COMPOUND_ASSIGN, BINOP_ADD },
 889   { "-=", COMPOUND_ASSIGN, BINOP_SUB },
 890   { "*=", COMPOUND_ASSIGN, BINOP_MUL },
 891   { "/=", COMPOUND_ASSIGN, BINOP_DIV },
 892   { "%=", COMPOUND_ASSIGN, BINOP_REM },
 893   { "&=", COMPOUND_ASSIGN, BINOP_BITWISE_AND },
 894   { "|=", COMPOUND_ASSIGN, BINOP_BITWISE_IOR },
 895   { "^=", COMPOUND_ASSIGN, BINOP_BITWISE_XOR },
 896
 897   { "::", COLONCOLON, OP_NULL },
 898   { "..", DOTDOT, OP_NULL },
 899   { "->", ARROW, OP_NULL }
 900 };
 901
 902 /* Helper function to copy to the name obstack.  */
 903
 904 static const char *
 905 rust_copy_name (const char *name, int len)
 906 {
 907   return (const char *) obstack_copy0 (&work_obstack, name, len);
 908 }
 909
 910 /* Helper function to make an stoken from a C string.  */
 911
 912 static struct stoken
 913 make_stoken (const char *p)
 914 {
 915   struct stoken result;
 916
 917   result.ptr = p;
 918   result.length = strlen (result.ptr);
 919   return result;
 920 }
 921
 922 /* Helper function to concatenate three strings on the name
 923    obstack.  */
 924
 925 static struct stoken
 926 rust_concat3 (const char *s1, const char *s2, const char *s3)
 927 {
 928   return make_stoken (obconcat (&work_obstack, s1, s2, s3, (char *) NULL));
 929 }
 930
 931 /* Return an AST node referring to NAME, but relative to the crate's
 932    name.  */
 933
 934 static const struct rust_op *
 935 crate_name (const struct rust_op *name)
 936 {
 937   char *crate = rust_crate_for_block (expression_context_block);
 938   struct stoken result;
 939
 940   gdb_assert (name->opcode == OP_VAR_VALUE);
 941
 942   if (crate == NULL)
 943     error (_("Could not find crate for current location"));
 944   result = make_stoken (obconcat (&work_obstack, "::", crate, "::",
 945                                   name->left.sval.ptr, (char *) NULL));
 946   xfree (crate);
 947
 948   return ast_path (result, name->right.params);
 949 }
 950
 951 /* Create an AST node referring to a "super::" qualified name.  IDENT
 952    is the base name and N_SUPERS is how many "super::"s were
 953    provided.  N_SUPERS can be zero.  */
 954
 955 static const struct rust_op *
 956 super_name (const struct rust_op *ident, unsigned int n_supers)
 957 {
 958   const char *scope = block_scope (expression_context_block);
 959   int offset;
 960
 961   gdb_assert (ident->opcode == OP_VAR_VALUE);
 962
 963   if (scope[0] == '\0')
 964     error (_("Couldn't find namespace scope for self::"));
 965
 966   if (n_supers > 0)
 967     {
 968       int i;
 969       int len;
 970       VEC (int) *offsets = NULL;
 971       unsigned int current_len, previous_len;
 972       struct cleanup *cleanup;
 973
 974       cleanup = make_cleanup (VEC_cleanup (int), &offsets);
 975       current_len = cp_find_first_component (scope);
 976       previous_len = 0;
 977       while (scope[current_len] != '\0')
 978         {
 979           VEC_safe_push (int, offsets, current_len);
 980           gdb_assert (scope[current_len] == ':');
 981           previous_len = current_len;
 982           /* The "::".  */
 983           current_len += 2;
 984           current_len += cp_find_first_component (scope
 985                                                   + current_len);
 986         }
 987
 988       len = VEC_length (int, offsets);
 989       if (n_supers >= len)
 990         error (_("Too many super:: uses from '%s'"), scope);
 991
 992       offset = VEC_index (int, offsets, len - n_supers);
 993
 994       do_cleanups (cleanup);
 995     }
 996   else
 997     offset = strlen (scope);
 998
 999   obstack_grow (&work_obstack, "::", 2);
1000   obstack_grow (&work_obstack, scope, offset);
1001   obstack_grow (&work_obstack, "::", 2);
1002   obstack_grow0 (&work_obstack, ident->left.sval.ptr, ident->left.sval.length);
1003
1004   return ast_path (make_stoken ((const char *) obstack_finish (&work_obstack)),
1005                    ident->right.params);
1006 }
1007
1008 /* A helper that updates innermost_block as appropriate.  */
1009
1010 static void
1011 update_innermost_block (struct block_symbol sym)
1012 {
1013   if (symbol_read_needs_frame (sym.symbol)
1014       && (innermost_block == NULL
1015           || contained_in (sym.block, innermost_block)))
1016     innermost_block = sym.block;
1017 }
1018
1019 /* A helper to look up a Rust type, or fail.  This only works for
1020    types defined by rust_language_arch_info.  */
1021
1022 static struct type *
1023 rust_type (const char *name)
1024 {
1025   struct type *type;
1026
1027   /* When unit testing, we don't bother checking the types, so avoid a
1028      possibly-failing lookup here.  */
1029   if (unit_testing)
1030     return NULL;
1031
1032   type = language_lookup_primitive_type (parse_language (pstate),
1033                                          parse_gdbarch (pstate),
1034                                          name);
1035   if (type == NULL)
1036     error (_("Could not find Rust type %s"), name);
1037   return type;
1038 }
1039
1040 /* Lex a hex number with at least MIN digits and at most MAX
1041    digits.  */
1042
1043 static uint32_t
1044 lex_hex (int min, int max)
1045 {
1046   uint32_t result = 0;
1047   int len = 0;
1048   /* We only want to stop at MAX if we're lexing a byte escape.  */
1049   int check_max = min == max;
1050
1051   while ((check_max ? len <= max : 1)
1052          && ((lexptr[0] >= 'a' && lexptr[0] <= 'f')
1053              || (lexptr[0] >= 'A' && lexptr[0] <= 'F')
1054              || (lexptr[0] >= '0' && lexptr[0] <= '9')))
1055     {
1056       result *= 16;
1057       if (lexptr[0] >= 'a' && lexptr[0] <= 'f')
1058         result = result + 10 + lexptr[0] - 'a';
1059       else if (lexptr[0] >= 'A' && lexptr[0] <= 'F')
1060         result = result + 10 + lexptr[0] - 'A';
1061       else
1062         result = result + lexptr[0] - '0';
1063       ++lexptr;
1064       ++len;
1065     }
1066
1067   if (len < min)
1068     error (_("Not enough hex digits seen"));
1069   if (len > max)
1070     {
1071       gdb_assert (min != max);
1072       error (_("Overlong hex escape"));
1073     }
1074
1075   return result;
1076 }
1077
1078 /* Lex an escape.  IS_BYTE is true if we're lexing a byte escape;
1079    otherwise we're lexing a character escape.  */
1080
1081 static uint32_t
1082 lex_escape (int is_byte)
1083 {
1084   uint32_t result;
1085
1086   gdb_assert (lexptr[0] == '\\');
1087   ++lexptr;
1088   switch (lexptr[0])
1089     {
1090     case 'x':
1091       ++lexptr;
1092       result = lex_hex (2, 2);
1093       break;
1094
1095     case 'u':
1096       if (is_byte)
1097         error (_("Unicode escape in byte literal"));
1098       ++lexptr;
1099       if (lexptr[0] != '{')
1100         error (_("Missing '{' in Unicode escape"));
1101       ++lexptr;
1102       result = lex_hex (1, 6);
1103       /* Could do range checks here.  */
1104       if (lexptr[0] != '}')
1105         error (_("Missing '}' in Unicode escape"));
1106       ++lexptr;
1107       break;
1108
1109     case 'n':
1110       result = '\n';
1111       ++lexptr;
1112       break;
1113     case 'r':
1114       result = '\r';
1115       ++lexptr;
1116       break;
1117     case 't':
1118       result = '\t';
1119       ++lexptr;
1120       break;
1121     case '\\':
1122       result = '\\';
1123       ++lexptr;
1124       break;
1125     case '0':
1126       result = '\0';
1127       ++lexptr;
1128       break;
1129     case '\'':
1130       result = '\'';
1131       ++lexptr;
1132       break;
1133     case '"':
1134       result = '"';
1135       ++lexptr;
1136       break;
1137
1138     default:
1139       error (_("Invalid escape \\%c in literal"), lexptr[0]);
1140     }
1141
1142   return result;
1143 }
1144
1145 /* Lex a character constant.  */
1146
1147 static int
1148 lex_character (void)
1149 {
1150   int is_byte = 0;
1151   uint32_t value;
1152
1153   if (lexptr[0] == 'b')
1154     {
1155       is_byte = 1;
1156       ++lexptr;
1157     }
1158   gdb_assert (lexptr[0] == '\'');
1159   ++lexptr;
1160   /* This should handle UTF-8 here.  */
1161   if (lexptr[0] == '\\')
1162     value = lex_escape (is_byte);
1163   else
1164     {
1165       value = lexptr[0] & 0xff;
1166       ++lexptr;
1167     }
1168
1169   if (lexptr[0] != '\'')
1170     error (_("Unterminated character literal"));
1171   ++lexptr;
1172
1173   rustyylval.typed_val_int.val = value;
1174   rustyylval.typed_val_int.type = rust_type (is_byte ? "u8" : "char");
1175
1176   return INTEGER;
1177 }
1178
1179 /* Return the offset of the double quote if STR looks like the start
1180    of a raw string, or 0 if STR does not start a raw string.  */
1181
1182 static int
1183 starts_raw_string (const char *str)
1184 {
1185   const char *save = str;
1186
1187   if (str[0] != 'r')
1188     return 0;
1189   ++str;
1190   while (str[0] == '#')
1191     ++str;
1192   if (str[0] == '"')
1193     return str - save;
1194   return 0;
1195 }
1196
1197 /* Return true if STR looks like the end of a raw string that had N
1198    hashes at the start.  */
1199
1200 static int
1201 ends_raw_string (const char *str, int n)
1202 {
1203   int i;
1204
1205   gdb_assert (str[0] == '"');
1206   for (i = 0; i < n; ++i)
1207     if (str[i + 1] != '#')
1208       return 0;
1209   return 1;
1210 }
1211
1212 /* Lex a string constant.  */
1213
1214 static int
1215 lex_string (void)
1216 {
1217   int is_byte = lexptr[0] == 'b';
1218   int raw_length;
1219   int len_in_chars = 0;
1220
1221   if (is_byte)
1222     ++lexptr;
1223   raw_length = starts_raw_string (lexptr);
1224   lexptr += raw_length;
1225   gdb_assert (lexptr[0] == '"');
1226   ++lexptr;
1227
1228   while (1)
1229     {
1230       uint32_t value;
1231
1232       if (raw_length > 0)
1233         {
1234           if (lexptr[0] == '"' && ends_raw_string (lexptr, raw_length - 1))
1235             {
1236               /* Exit with lexptr pointing after the final "#".  */
1237               lexptr += raw_length;
1238               break;
1239             }
1240           else if (lexptr[0] == '\0')
1241             error (_("Unexpected EOF in string"));
1242
1243           value = lexptr[0] & 0xff;
1244           if (is_byte && value > 127)
1245             error (_("Non-ASCII value in raw byte string"));
1246           obstack_1grow (&work_obstack, value);
1247
1248           ++lexptr;
1249         }
1250       else if (lexptr[0] == '"')
1251         {
1252           /* Make sure to skip the quote.  */
1253           ++lexptr;
1254           break;
1255         }
1256       else if (lexptr[0] == '\\')
1257         {
1258           value = lex_escape (is_byte);
1259
1260           if (is_byte)
1261             obstack_1grow (&work_obstack, value);
1262           else
1263             convert_between_encodings ("UTF-32", "UTF-8", (gdb_byte *) &value,
1264                                        sizeof (value), sizeof (value),
1265                                        &work_obstack, translit_none);
1266         }
1267       else if (lexptr[0] == '\0')
1268         error (_("Unexpected EOF in string"));
1269       else
1270         {
1271           value = lexptr[0] & 0xff;
1272           if (is_byte && value > 127)
1273             error (_("Non-ASCII value in byte string"));
1274           obstack_1grow (&work_obstack, value);
1275           ++lexptr;
1276         }
1277     }
1278
1279   rustyylval.sval.length = obstack_object_size (&work_obstack);
1280   rustyylval.sval.ptr = (const char *) obstack_finish (&work_obstack);
1281   return is_byte ? BYTESTRING : STRING;
1282 }
1283
1284 /* Return true if STRING starts with whitespace followed by a digit.  */
1285
1286 static int
1287 space_then_number (const char *string)
1288 {
1289   const char *p = string;
1290
1291   while (p[0] == ' ' || p[0] == '\t')
1292     ++p;
1293   if (p == string)
1294     return 0;
1295
1296   return *p >= '0' && *p <= '9';
1297 }
1298
1299 /* Return true if C can start an identifier.  */
1300
1301 static int
1302 rust_identifier_start_p (char c)
1303 {
1304   return ((c >= 'a' && c <= 'z')
1305           || (c >= 'A' && c <= 'Z')
1306           || c == '_'
1307           || c == '$');
1308 }
1309
1310 /* Lex an identifier.  */
1311
1312 static int
1313 lex_identifier (void)
1314 {
1315   const char *start = lexptr;
1316   unsigned int length;
1317   const struct token_info *token;
1318   int i;
1319   int is_gdb_var = lexptr[0] == '$';
1320
1321   gdb_assert (rust_identifier_start_p (lexptr[0]));
1322
1323   ++lexptr;
1324
1325   /* For the time being this doesn't handle Unicode rules.  Non-ASCII
1326      identifiers are gated anyway.  */
1327   while ((lexptr[0] >= 'a' && lexptr[0] <= 'z')
1328          || (lexptr[0] >= 'A' && lexptr[0] <= 'Z')
1329          || lexptr[0] == '_'
1330          || (is_gdb_var && lexptr[0] == '$')
1331          || (lexptr[0] >= '0' && lexptr[0] <= '9'))
1332     ++lexptr;
1333
1334
1335   length = lexptr - start;
1336   token = NULL;
1337   for (i = 0; i < ARRAY_SIZE (identifier_tokens); ++i)
1338     {
1339       if (length == strlen (identifier_tokens[i].name)
1340           && strncmp (identifier_tokens[i].name, start, length) == 0)
1341         {
1342           token = &identifier_tokens[i];
1343           break;
1344         }
1345     }
1346
1347   if (token != NULL)
1348     {
1349       if (token->value == 0)
1350         {
1351           /* Leave the terminating token alone.  */
1352           lexptr = start;
1353           return 0;
1354         }
1355     }
1356   else if (token == NULL
1357            && (strncmp (start, "thread", length) == 0
1358                || strncmp (start, "task", length) == 0)
1359            && space_then_number (lexptr))
1360     {
1361       /* "task" or "thread" followed by a number terminates the
1362          parse, per gdb rules.  */
1363       lexptr = start;
1364       return 0;
1365     }
1366
1367   if (token == NULL || (parse_completion && lexptr[0] == '\0'))
1368     rustyylval.sval = make_stoken (rust_copy_name (start, length));
1369
1370   if (parse_completion && lexptr[0] == '\0')
1371     {
1372       /* Prevent rustyylex from returning two COMPLETE tokens.  */
1373       prev_lexptr = lexptr;
1374       return COMPLETE;
1375     }
1376
1377   if (token != NULL)
1378     return token->value;
1379   if (is_gdb_var)
1380     return GDBVAR;
1381   return IDENT;
1382 }
1383
1384 /* Lex an operator.  */
1385
1386 static int
1387 lex_operator (void)
1388 {
1389   const struct token_info *token = NULL;
1390   int i;
1391
1392   for (i = 0; i < ARRAY_SIZE (operator_tokens); ++i)
1393     {
1394       if (strncmp (operator_tokens[i].name, lexptr,
1395                    strlen (operator_tokens[i].name)) == 0)
1396         {
1397           lexptr += strlen (operator_tokens[i].name);
1398           token = &operator_tokens[i];
1399           break;
1400         }
1401     }
1402
1403   if (token != NULL)
1404     {
1405       rustyylval.opcode = token->opcode;
1406       return token->value;
1407     }
1408
1409   return *lexptr++;
1410 }
1411
1412 /* Lex a number.  */
1413
1414 static int
1415 lex_number (void)
1416 {
1417   regmatch_t subexps[NUM_SUBEXPRESSIONS];
1418   int match;
1419   int is_integer = 0;
1420   int could_be_decimal = 1;
1421   char *type_name = NULL;
1422   struct type *type;
1423   int end_index;
1424   int type_index = -1;
1425   int i, out;
1426   char *number;
1427   struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
1428
1429   match = regexec (&number_regex, lexptr, ARRAY_SIZE (subexps), subexps, 0);
1430   /* Failure means the regexp is broken.  */
1431   gdb_assert (match == 0);
1432
1433   if (subexps[INT_TEXT].rm_so != -1)
1434     {
1435       /* Integer part matched.  */
1436       is_integer = 1;
1437       end_index = subexps[INT_TEXT].rm_eo;
1438       if (subexps[INT_TYPE].rm_so == -1)
1439         type_name = "i32";
1440       else
1441         {
1442           type_index = INT_TYPE;
1443           could_be_decimal = 0;
1444         }
1445     }
1446   else if (subexps[FLOAT_TYPE1].rm_so != -1)
1447     {
1448       /* Found floating point type suffix.  */
1449       end_index = subexps[FLOAT_TYPE1].rm_so;
1450       type_index = FLOAT_TYPE1;
1451     }
1452   else if (subexps[FLOAT_TYPE2].rm_so != -1)
1453     {
1454       /* Found floating point type suffix.  */
1455       end_index = subexps[FLOAT_TYPE2].rm_so;
1456       type_index = FLOAT_TYPE2;
1457     }
1458   else
1459     {
1460       /* Any other floating point match.  */
1461       end_index = subexps[0].rm_eo;
1462       type_name = "f64";
1463     }
1464
1465   /* We need a special case if the final character is ".".  In this
1466      case we might need to parse an integer.  For example, "23.f()" is
1467      a request for a trait method call, not a syntax error involving
1468      the floating point number "23.".  */
1469   gdb_assert (subexps[0].rm_eo > 0);
1470   if (lexptr[subexps[0].rm_eo - 1] == '.')
1471     {
1472       const char *next = skip_spaces_const (&lexptr[subexps[0].rm_eo]);
1473
1474       if (rust_identifier_start_p (*next) || *next == '.')
1475         {
1476           --subexps[0].rm_eo;
1477           is_integer = 1;
1478           end_index = subexps[0].rm_eo;
1479           type_name = "i32";
1480           could_be_decimal = 1;
1481         }
1482     }
1483
1484   /* Compute the type name if we haven't already.  */
1485   if (type_name == NULL)
1486     {
1487       gdb_assert (type_index != -1);
1488       type_name = xstrndup (lexptr + subexps[type_index].rm_so,
1489                            (subexps[type_index].rm_eo
1490                             - subexps[type_index].rm_so));
1491       make_cleanup (xfree, type_name);
1492     }
1493
1494   /* Look up the type.  */
1495   type = rust_type (type_name);
1496
1497   /* Copy the text of the number and remove the "_"s.  */
1498   number = xstrndup (lexptr, end_index);
1499   make_cleanup (xfree, number);
1500   for (i = out = 0; number[i]; ++i)
1501     {
1502       if (number[i] == '_')
1503         could_be_decimal = 0;
1504       else
1505         number[out++] = number[i];
1506     }
1507   number[out] = '\0';
1508
1509   /* Advance past the match.  */
1510   lexptr += subexps[0].rm_eo;
1511
1512   /* Parse the number.  */
1513   if (is_integer)
1514     {
1515       int radix = 10;
1516       if (number[0] == '0')
1517         {
1518           if (number[1] == 'x')
1519             radix = 16;
1520           else if (number[1] == 'o')
1521             radix = 8;
1522           else if (number[1] == 'b')
1523             radix = 2;
1524           if (radix != 10)
1525             {
1526               number += 2;
1527               could_be_decimal = 0;
1528             }
1529         }
1530       rustyylval.typed_val_int.val = strtoul (number, NULL, radix);
1531       rustyylval.typed_val_int.type = type;
1532     }
1533   else
1534     {
1535       rustyylval.typed_val_float.dval = strtod (number, NULL);
1536       rustyylval.typed_val_float.type = type;
1537     }
1538
1539   do_cleanups (cleanup);
1540   return is_integer ? (could_be_decimal ? DECIMAL_INTEGER : INTEGER) : FLOAT;
1541 }
1542
1543 /* The lexer.  */
1544
1545 static int
1546 rustyylex (void)
1547 {
1548   /* Skip all leading whitespace.  */
1549   while (lexptr[0] == ' ' || lexptr[0] == '\t' || lexptr[0] == '\r'
1550          || lexptr[0] == '\n')
1551     ++lexptr;
1552
1553   /* If we hit EOF and we're completing, then return COMPLETE -- maybe
1554      we're completing an empty string at the end of a field_expr.
1555      But, we don't want to return two COMPLETE tokens in a row.  */
1556   if (lexptr[0] == '\0' && lexptr == prev_lexptr)
1557     return 0;
1558   prev_lexptr = lexptr;
1559   if (lexptr[0] == '\0')
1560     {
1561       if (parse_completion)
1562         {
1563           rustyylval.sval = make_stoken ("");
1564           return COMPLETE;
1565         }
1566       return 0;
1567     }
1568
1569   if (lexptr[0] >= '0' && lexptr[0] <= '9')
1570     return lex_number ();
1571   else if (lexptr[0] == 'b' && lexptr[1] == '\'')
1572     return lex_character ();
1573   else if (lexptr[0] == 'b' && lexptr[1] == '"')
1574     return lex_string ();
1575   else if (lexptr[0] == 'b' && starts_raw_string (lexptr + 1))
1576     return lex_string ();
1577   else if (starts_raw_string (lexptr))
1578     return lex_string ();
1579   else if (rust_identifier_start_p (lexptr[0]))
1580     return lex_identifier ();
1581   else if (lexptr[0] == '"')
1582     return lex_string ();
1583   else if (lexptr[0] == '\'')
1584     return lex_character ();
1585   else if (lexptr[0] == '}' || lexptr[0] == ']')
1586     {
1587       /* Falls through to lex_operator.  */
1588       --paren_depth;
1589     }
1590   else if (lexptr[0] == '(' || lexptr[0] == '{')
1591     {
1592       /* Falls through to lex_operator.  */
1593       ++paren_depth;
1594     }
1595   else if (lexptr[0] == ',' && comma_terminates && paren_depth == 0)
1596     return 0;
1597
1598   return lex_operator ();
1599 }
1600
1601 /* Push back a single character to be re-lexed.  */
1602
1603 static void
1604 rust_push_back (char c)
1605 {
1606   /* Can't be called before any lexing.  */
1607   gdb_assert (prev_lexptr != NULL);
1608
1609   --lexptr;
1610   gdb_assert (*lexptr == c);
1611 }
1612
1613 \f
1614
1615 /* Make an arbitrary operation and fill in the fields.  */
1616
1617 static const struct rust_op *
1618 ast_operation (enum exp_opcode opcode, const struct rust_op *left,
1619                 const struct rust_op *right)
1620 {
1621   struct rust_op *result = OBSTACK_ZALLOC (&work_obstack, struct rust_op);
1622
1623   result->opcode = opcode;
1624   result->left.op = left;
1625   result->right.op = right;
1626
1627   return result;
1628 }
1629
1630 /* Make a compound assignment operation.  */
1631
1632 static const struct rust_op *
1633 ast_compound_assignment (enum exp_opcode opcode, const struct rust_op *left,
1634                           const struct rust_op *right)
1635 {
1636   struct rust_op *result = OBSTACK_ZALLOC (&work_obstack, struct rust_op);
1637
1638   result->opcode = opcode;
1639   result->compound_assignment = 1;
1640   result->left.op = left;
1641   result->right.op = right;
1642
1643   return result;
1644 }
1645
1646 /* Make a typed integer literal operation.  */
1647
1648 static const struct rust_op *
1649 ast_literal (struct typed_val_int val)
1650 {
1651   struct rust_op *result = OBSTACK_ZALLOC (&work_obstack, struct rust_op);
1652
1653   result->opcode = OP_LONG;
1654   result->left.typed_val_int = val;
1655
1656   return result;
1657 }
1658
1659 /* Make a typed floating point literal operation.  */
1660
1661 static const struct rust_op *
1662 ast_dliteral (struct typed_val_float val)
1663 {
1664   struct rust_op *result = OBSTACK_ZALLOC (&work_obstack, struct rust_op);
1665
1666   result->opcode = OP_DOUBLE;
1667   result->left.typed_val_float = val;
1668
1669   return result;
1670 }
1671
1672 /* Make a unary operation.  */
1673
1674 static const struct rust_op *
1675 ast_unary (enum exp_opcode opcode, const struct rust_op *expr)
1676 {
1677   return ast_operation (opcode, expr, NULL);
1678 }
1679
1680 /* Make a cast operation.  */
1681
1682 static const struct rust_op *
1683 ast_cast (const struct rust_op *expr, const struct rust_op *type)
1684 {
1685   struct rust_op *result = OBSTACK_ZALLOC (&work_obstack, struct rust_op);
1686
1687   result->opcode = UNOP_CAST;
1688   result->left.op = expr;
1689   result->right.op = type;
1690
1691   return result;
1692 }
1693
1694 /* Make a call-like operation.  This is nominally a function call, but
1695    when lowering we may discover that it actually represents the
1696    creation of a tuple struct.  */
1697
1698 static const struct rust_op *
1699 ast_call_ish (enum exp_opcode opcode, const struct rust_op *expr,
1700                VEC (rust_op_ptr) **params)
1701 {
1702   struct rust_op *result = OBSTACK_ZALLOC (&work_obstack, struct rust_op);
1703
1704   result->opcode = opcode;
1705   result->left.op = expr;
1706   result->right.params = params;
1707
1708   return result;
1709 }
1710
1711 /* Make a structure creation operation.  */
1712
1713 static const struct rust_op *
1714 ast_struct (const struct rust_op *name, VEC (set_field) **fields)
1715 {
1716   struct rust_op *result = OBSTACK_ZALLOC (&work_obstack, struct rust_op);
1717
1718   result->opcode = OP_AGGREGATE;
1719   result->left.op = name;
1720   result->right.field_inits = fields;
1721
1722   return result;
1723 }
1724
1725 /* Make an identifier path.  */
1726
1727 static const struct rust_op *
1728 ast_path (struct stoken path, VEC (rust_op_ptr) **params)
1729 {
1730   struct rust_op *result = OBSTACK_ZALLOC (&work_obstack, struct rust_op);
1731
1732   result->opcode = OP_VAR_VALUE;
1733   result->left.sval = path;
1734   result->right.params = params;
1735
1736   return result;
1737 }
1738
1739 /* Make a string constant operation.  */
1740
1741 static const struct rust_op *
1742 ast_string (struct stoken str)
1743 {
1744   struct rust_op *result = OBSTACK_ZALLOC (&work_obstack, struct rust_op);
1745
1746   result->opcode = OP_STRING;
1747   result->left.sval = str;
1748
1749   return result;
1750 }
1751
1752 /* Make a field expression.  */
1753
1754 static const struct rust_op *
1755 ast_structop (const struct rust_op *left, const char *name, int completing)
1756 {
1757   struct rust_op *result = OBSTACK_ZALLOC (&work_obstack, struct rust_op);
1758
1759   result->opcode = STRUCTOP_STRUCT;
1760   result->completing = completing;
1761   result->left.op = left;
1762   result->right.sval = make_stoken (name);
1763
1764   return result;
1765 }
1766
1767 /* Make an anonymous struct operation, like 'x.0'.  */
1768
1769 static const struct rust_op *
1770 ast_structop_anonymous (const struct rust_op *left,
1771                          struct typed_val_int number)
1772 {
1773   struct rust_op *result = OBSTACK_ZALLOC (&work_obstack, struct rust_op);
1774
1775   result->opcode = STRUCTOP_ANONYMOUS;
1776   result->left.op = left;
1777   result->right.typed_val_int = number;
1778
1779   return result;
1780 }
1781
1782 /* Make a range operation.  */
1783
1784 static const struct rust_op *
1785 ast_range (const struct rust_op *lhs, const struct rust_op *rhs)
1786 {
1787   struct rust_op *result = OBSTACK_ZALLOC (&work_obstack, struct rust_op);
1788
1789   result->opcode = OP_RANGE;
1790   result->left.op = lhs;
1791   result->right.op = rhs;
1792
1793   return result;
1794 }
1795
1796 /* A helper function to make a type-related AST node.  */
1797
1798 static struct rust_op *
1799 ast_basic_type (enum type_code typecode)
1800 {
1801   struct rust_op *result = OBSTACK_ZALLOC (&work_obstack, struct rust_op);
1802
1803   result->opcode = OP_TYPE;
1804   result->typecode = typecode;
1805   return result;
1806 }
1807
1808 /* Create an AST node describing an array type.  */
1809
1810 static const struct rust_op *
1811 ast_array_type (const struct rust_op *lhs, struct typed_val_int val)
1812 {
1813   struct rust_op *result = ast_basic_type (TYPE_CODE_ARRAY);
1814
1815   result->left.op = lhs;
1816   result->right.typed_val_int = val;
1817   return result;
1818 }
1819
1820 /* Create an AST node describing a reference type.  */
1821
1822 static const struct rust_op *
1823 ast_slice_type (const struct rust_op *type)
1824 {
1825   /* Use TYPE_CODE_COMPLEX just because it is handy.  */
1826   struct rust_op *result = ast_basic_type (TYPE_CODE_COMPLEX);
1827
1828   result->left.op = type;
1829   return result;
1830 }
1831
1832 /* Create an AST node describing a reference type.  */
1833
1834 static const struct rust_op *
1835 ast_reference_type (const struct rust_op *type)
1836 {
1837   struct rust_op *result = ast_basic_type (TYPE_CODE_REF);
1838
1839   result->left.op = type;
1840   return result;
1841 }
1842
1843 /* Create an AST node describing a pointer type.  */
1844
1845 static const struct rust_op *
1846 ast_pointer_type (const struct rust_op *type, int is_mut)
1847 {
1848   struct rust_op *result = ast_basic_type (TYPE_CODE_PTR);
1849
1850   result->left.op = type;
1851   /* For the time being we ignore is_mut.  */
1852   return result;
1853 }
1854
1855 /* Create an AST node describing a function type.  */
1856
1857 static const struct rust_op *
1858 ast_function_type (const struct rust_op *rtype, VEC (rust_op_ptr) **params)
1859 {
1860   struct rust_op *result = ast_basic_type (TYPE_CODE_FUNC);
1861
1862   result->left.op = rtype;
1863   result->right.params = params;
1864   return result;
1865 }
1866
1867 /* Create an AST node describing a tuple type.  */
1868
1869 static const struct rust_op *
1870 ast_tuple_type (VEC (rust_op_ptr) **params)
1871 {
1872   struct rust_op *result = ast_basic_type (TYPE_CODE_STRUCT);
1873
1874   result->left.params = params;
1875   return result;
1876 }
1877
1878 /* A helper to appropriately munge NAME and BLOCK depending on the
1879    presence of a leading "::".  */
1880
1881 static void
1882 munge_name_and_block (const char **name, const struct block **block)
1883 {
1884   /* If it is a global reference, skip the current block in favor of
1885      the static block.  */
1886   if (strncmp (*name, "::", 2) == 0)
1887     {
1888       *name += 2;
1889       *block = block_static_block (*block);
1890     }
1891 }
1892
1893 /* Like lookup_symbol, but handles Rust namespace conventions, and
1894    doesn't require field_of_this_result.  */
1895
1896 static struct block_symbol
1897 rust_lookup_symbol (const char *name, const struct block *block,
1898                     const domain_enum domain)
1899 {
1900   struct block_symbol result;
1901
1902   munge_name_and_block (&name, &block);
1903
1904   result = lookup_symbol (name, block, domain, NULL);
1905   if (result.symbol != NULL)
1906     update_innermost_block (result);
1907   return result;
1908 }
1909
1910 /* Look up a type, following Rust namespace conventions.  */
1911
1912 static struct type *
1913 rust_lookup_type (const char *name, const struct block *block)
1914 {
1915   struct block_symbol result;
1916   struct type *type;
1917
1918   munge_name_and_block (&name, &block);
1919
1920   result = lookup_symbol (name, block, STRUCT_DOMAIN, NULL);
1921   if (result.symbol != NULL)
1922     {
1923       update_innermost_block (result);
1924       return SYMBOL_TYPE (result.symbol);
1925     }
1926
1927   type = lookup_typename (parse_language (pstate), parse_gdbarch (pstate),
1928                           name, NULL, 1);
1929   if (type != NULL)
1930     return type;
1931
1932   /* Last chance, try a built-in type.  */
1933   return language_lookup_primitive_type (parse_language (pstate),
1934                                          parse_gdbarch (pstate),
1935                                          name);
1936 }
1937
1938 static struct type *convert_ast_to_type (struct parser_state *state,
1939                                          const struct rust_op *operation);
1940 static const char *convert_name (struct parser_state *state,
1941                                  const struct rust_op *operation);
1942
1943 /* Convert a vector of rust_ops representing types to a vector of
1944    types.  */
1945
1946 static VEC (type_ptr) *
1947 convert_params_to_types (struct parser_state *state, VEC (rust_op_ptr) *params)
1948 {
1949   int i;
1950   const struct rust_op *op;
1951   VEC (type_ptr) *result = NULL;
1952   struct cleanup *cleanup = make_cleanup (VEC_cleanup (type_ptr), &result);
1953
1954   for (i = 0; VEC_iterate (rust_op_ptr, params, i, op); ++i)
1955     VEC_safe_push (type_ptr, result, convert_ast_to_type (state, op));
1956
1957   discard_cleanups (cleanup);
1958   return result;
1959 }
1960
1961 /* Convert a rust_op representing a type to a struct type *.  */
1962
1963 static struct type *
1964 convert_ast_to_type (struct parser_state *state,
1965                      const struct rust_op *operation)
1966 {
1967   struct type *type, *result = NULL;
1968
1969   if (operation->opcode == OP_VAR_VALUE)
1970     {
1971       const char *varname = convert_name (state, operation);
1972
1973       result = rust_lookup_type (varname, expression_context_block);
1974       if (result == NULL)
1975         error (_("No typed name '%s' in current context"), varname);
1976       return result;
1977     }
1978
1979   gdb_assert (operation->opcode == OP_TYPE);
1980
1981   switch (operation->typecode)
1982     {
1983     case TYPE_CODE_ARRAY:
1984       type = convert_ast_to_type (state, operation->left.op);
1985       if (operation->right.typed_val_int.val < 0)
1986         error (_("Negative array length"));
1987       result = lookup_array_range_type (type, 0,
1988                                         operation->right.typed_val_int.val - 1);
1989       break;
1990
1991     case TYPE_CODE_COMPLEX:
1992       {
1993         struct type *usize = rust_type ("usize");
1994
1995         type = convert_ast_to_type (state, operation->left.op);
1996         result = rust_slice_type ("&[*gdb*]", type, usize);
1997       }
1998       break;
1999
2000     case TYPE_CODE_REF:
2001     case TYPE_CODE_PTR:
2002       /* For now we treat &x and *x identically.  */
2003       type = convert_ast_to_type (state, operation->left.op);
2004       result = lookup_pointer_type (type);
2005       break;
2006
2007     case TYPE_CODE_FUNC:
2008       {
2009         VEC (type_ptr) *args
2010           = convert_params_to_types (state, *operation->right.params);
2011         struct cleanup *cleanup
2012           = make_cleanup (VEC_cleanup (type_ptr), &args);
2013         struct type **argtypes = NULL;
2014
2015         type = convert_ast_to_type (state, operation->left.op);
2016         if (!VEC_empty (type_ptr, args))
2017           argtypes = VEC_address (type_ptr, args);
2018
2019         result
2020           = lookup_function_type_with_arguments (type,
2021                                                  VEC_length (type_ptr, args),
2022                                                  argtypes);
2023         result = lookup_pointer_type (result);
2024
2025         do_cleanups (cleanup);
2026       }
2027       break;
2028
2029     case TYPE_CODE_STRUCT:
2030       {
2031         VEC (type_ptr) *args
2032           = convert_params_to_types (state, *operation->left.params);
2033         struct cleanup *cleanup
2034           = make_cleanup (VEC_cleanup (type_ptr), &args);
2035         int i;
2036         struct type *type;
2037         const char *name;
2038
2039         obstack_1grow (&work_obstack, '(');
2040         for (i = 0; VEC_iterate (type_ptr, args, i, type); ++i)
2041           {
2042             char *type_name = type_to_string (type);
2043
2044             if (i > 0)
2045               obstack_1grow (&work_obstack, ',');
2046             obstack_grow_str (&work_obstack, type_name);
2047
2048             xfree (type_name);
2049           }
2050
2051         obstack_grow_str0 (&work_obstack, ")");
2052         name = (const char *) obstack_finish (&work_obstack);
2053
2054         /* We don't allow creating new tuple types (yet), but we do
2055            allow looking up existing tuple types.  */
2056         result = rust_lookup_type (name, expression_context_block);
2057         if (result == NULL)
2058           error (_("could not find tuple type '%s'"), name);
2059
2060         do_cleanups (cleanup);
2061       }
2062       break;
2063
2064     default:
2065       gdb_assert_not_reached ("unhandled opcode in convert_ast_to_type");
2066     }
2067
2068   gdb_assert (result != NULL);
2069   return result;
2070 }
2071
2072 /* A helper function to turn a rust_op representing a name into a full
2073    name.  This applies generic arguments as needed.  The returned name
2074    is allocated on the work obstack.  */
2075
2076 static const char *
2077 convert_name (struct parser_state *state, const struct rust_op *operation)
2078 {
2079   VEC (type_ptr) *types;
2080   struct cleanup *cleanup;
2081   int i;
2082   struct type *type;
2083
2084   gdb_assert (operation->opcode == OP_VAR_VALUE);
2085
2086   if (operation->right.params == NULL)
2087     return operation->left.sval.ptr;
2088
2089   types = convert_params_to_types (state, *operation->right.params);
2090   cleanup = make_cleanup (VEC_cleanup (type_ptr), &types);
2091
2092   obstack_grow_str (&work_obstack, operation->left.sval.ptr);
2093   obstack_1grow (&work_obstack, '<');
2094   for (i = 0; VEC_iterate (type_ptr, types, i, type); ++i)
2095     {
2096       char *type_name = type_to_string (type);
2097
2098       if (i > 0)
2099         obstack_1grow (&work_obstack, ',');
2100
2101       obstack_grow_str (&work_obstack, type_name);
2102       xfree (type_name);
2103     }
2104   obstack_grow_str0 (&work_obstack, ">");
2105
2106   do_cleanups (cleanup);
2107
2108   return (const char *) obstack_finish (&work_obstack);
2109 }
2110
2111 static void convert_ast_to_expression (struct parser_state *state,
2112                                        const struct rust_op *operation,
2113                                        const struct rust_op *top);
2114
2115 /* A helper function that converts a vec of rust_ops to a gdb
2116    expression.  */
2117
2118 static void
2119 convert_params_to_expression (struct parser_state *state,
2120                               VEC (rust_op_ptr) *params,
2121                               const struct rust_op *top)
2122 {
2123   int i;
2124   rust_op_ptr elem;
2125
2126   for (i = 0; VEC_iterate (rust_op_ptr, params, i, elem); ++i)
2127     convert_ast_to_expression (state, elem, top);
2128 }
2129
2130 /* Lower a rust_op to a gdb expression.  STATE is the parser state.
2131    OPERATION is the operation to lower.  TOP is a pointer to the
2132    top-most operation; it is used to handle the special case where the
2133    top-most expression is an identifier and can be optionally lowered
2134    to OP_TYPE.  */
2135
2136 static void
2137 convert_ast_to_expression (struct parser_state *state,
2138                            const struct rust_op *operation,
2139                            const struct rust_op *top)
2140 {
2141   switch (operation->opcode)
2142     {
2143     case OP_LONG:
2144       write_exp_elt_opcode (state, OP_LONG);
2145       write_exp_elt_type (state, operation->left.typed_val_int.type);
2146       write_exp_elt_longcst (state, operation->left.typed_val_int.val);
2147       write_exp_elt_opcode (state, OP_LONG);
2148       break;
2149
2150     case OP_DOUBLE:
2151       write_exp_elt_opcode (state, OP_DOUBLE);
2152       write_exp_elt_type (state, operation->left.typed_val_float.type);
2153       write_exp_elt_dblcst (state, operation->left.typed_val_float.dval);
2154       write_exp_elt_opcode (state, OP_DOUBLE);
2155       break;
2156
2157     case STRUCTOP_STRUCT:
2158       {
2159         convert_ast_to_expression (state, operation->left.op, top);
2160
2161         if (operation->completing)
2162           mark_struct_expression (state);
2163         write_exp_elt_opcode (state, STRUCTOP_STRUCT);
2164         write_exp_string (state, operation->right.sval);
2165         write_exp_elt_opcode (state, STRUCTOP_STRUCT);
2166       }
2167       break;
2168
2169     case STRUCTOP_ANONYMOUS:
2170       {
2171         convert_ast_to_expression (state, operation->left.op, top);
2172
2173         write_exp_elt_opcode (state, STRUCTOP_ANONYMOUS);
2174         write_exp_elt_longcst (state, operation->right.typed_val_int.val);
2175         write_exp_elt_opcode (state, STRUCTOP_ANONYMOUS);
2176       }
2177       break;
2178
2179     case UNOP_PLUS:
2180     case UNOP_NEG:
2181     case UNOP_COMPLEMENT:
2182     case UNOP_IND:
2183     case UNOP_ADDR:
2184       convert_ast_to_expression (state, operation->left.op, top);
2185       write_exp_elt_opcode (state, operation->opcode);
2186       break;
2187
2188     case BINOP_SUBSCRIPT:
2189     case BINOP_MUL:
2190     case BINOP_REPEAT:
2191     case BINOP_DIV:
2192     case BINOP_REM:
2193     case BINOP_LESS:
2194     case BINOP_GTR:
2195     case BINOP_BITWISE_AND:
2196     case BINOP_BITWISE_IOR:
2197     case BINOP_BITWISE_XOR:
2198     case BINOP_ADD:
2199     case BINOP_SUB:
2200     case BINOP_LOGICAL_OR:
2201     case BINOP_LOGICAL_AND:
2202     case BINOP_EQUAL:
2203     case BINOP_NOTEQUAL:
2204     case BINOP_LEQ:
2205     case BINOP_GEQ:
2206     case BINOP_LSH:
2207     case BINOP_RSH:
2208     case BINOP_ASSIGN:
2209     case OP_RUST_ARRAY:
2210       convert_ast_to_expression (state, operation->left.op, top);
2211       convert_ast_to_expression (state, operation->right.op, top);
2212       if (operation->compound_assignment)
2213         {
2214           write_exp_elt_opcode (state, BINOP_ASSIGN_MODIFY);
2215           write_exp_elt_opcode (state, operation->opcode);
2216           write_exp_elt_opcode (state, BINOP_ASSIGN_MODIFY);
2217         }
2218       else
2219         write_exp_elt_opcode (state, operation->opcode);
2220
2221       if (operation->compound_assignment
2222           || operation->opcode == BINOP_ASSIGN)
2223         {
2224           struct type *type;
2225
2226           type = language_lookup_primitive_type (parse_language (state),
2227                                                  parse_gdbarch (state),
2228                                                  "()");
2229
2230           write_exp_elt_opcode (state, OP_LONG);
2231           write_exp_elt_type (state, type);
2232           write_exp_elt_longcst (state, 0);
2233           write_exp_elt_opcode (state, OP_LONG);
2234
2235           write_exp_elt_opcode (state, BINOP_COMMA);
2236         }
2237       break;
2238
2239     case UNOP_CAST:
2240       {
2241         struct type *type = convert_ast_to_type (state, operation->right.op);
2242
2243         convert_ast_to_expression (state, operation->left.op, top);
2244         write_exp_elt_opcode (state, UNOP_CAST);
2245         write_exp_elt_type (state, type);
2246         write_exp_elt_opcode (state, UNOP_CAST);
2247       }
2248       break;
2249
2250     case OP_FUNCALL:
2251       {
2252         if (operation->left.op->opcode == OP_VAR_VALUE)
2253           {
2254             struct type *type;
2255             const char *varname = convert_name (state, operation->left.op);
2256
2257             type = rust_lookup_type (varname, expression_context_block);
2258             if (type != NULL)
2259               {
2260                 /* This is actually a tuple struct expression, not a
2261                    call expression.  */
2262                 rust_op_ptr elem;
2263                 int i;
2264                 VEC (rust_op_ptr) *params = *operation->right.params;
2265
2266                 if (TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
2267                   {
2268                     if (!rust_tuple_struct_type_p (type))
2269                       error (_("Type %s is not a tuple struct"), varname);
2270
2271                     for (i = 0;
2272                          VEC_iterate (rust_op_ptr, params, i, elem);
2273                          ++i)
2274                       {
2275                         char *cell = get_print_cell ();
2276
2277                         xsnprintf (cell, PRINT_CELL_SIZE, "__%d", i);
2278                         write_exp_elt_opcode (state, OP_NAME);
2279                         write_exp_string (state, make_stoken (cell));
2280                         write_exp_elt_opcode (state, OP_NAME);
2281
2282                         convert_ast_to_expression (state, elem, top);
2283                       }
2284
2285                     write_exp_elt_opcode (state, OP_AGGREGATE);
2286                     write_exp_elt_type (state, type);
2287                     write_exp_elt_longcst (state,
2288                                            2 * VEC_length (rust_op_ptr,
2289                                                            params));
2290                     write_exp_elt_opcode (state, OP_AGGREGATE);
2291                     break;
2292                   }
2293               }
2294           }
2295         convert_ast_to_expression (state, operation->left.op, top);
2296         convert_params_to_expression (state, *operation->right.params, top);
2297         write_exp_elt_opcode (state, OP_FUNCALL);
2298         write_exp_elt_longcst (state, VEC_length (rust_op_ptr,
2299                                                   *operation->right.params));
2300         write_exp_elt_longcst (state, OP_FUNCALL);
2301       }
2302       break;
2303
2304     case OP_ARRAY:
2305       gdb_assert (operation->left.op == NULL);
2306       convert_params_to_expression (state, *operation->right.params, top);
2307       write_exp_elt_opcode (state, OP_ARRAY);
2308       write_exp_elt_longcst (state, 0);
2309       write_exp_elt_longcst (state, VEC_length (rust_op_ptr,
2310                                                 *operation->right.params) - 1);
2311       write_exp_elt_longcst (state, OP_ARRAY);
2312       break;
2313
2314     case OP_VAR_VALUE:
2315       {
2316         struct block_symbol sym;
2317         const char *varname;
2318
2319         if (operation->left.sval.ptr[0] == '$')
2320           {
2321             write_dollar_variable (state, operation->left.sval);
2322             break;
2323           }
2324
2325         varname = convert_name (state, operation);
2326         sym = rust_lookup_symbol (varname, expression_context_block,
2327                                   VAR_DOMAIN);
2328         if (sym.symbol != NULL)
2329           {
2330             write_exp_elt_opcode (state, OP_VAR_VALUE);
2331             write_exp_elt_block (state, sym.block);
2332             write_exp_elt_sym (state, sym.symbol);
2333             write_exp_elt_opcode (state, OP_VAR_VALUE);
2334           }
2335         else
2336           {
2337             struct type *type;
2338
2339             type = rust_lookup_type (varname, expression_context_block);
2340             if (type == NULL)
2341               error (_("No symbol '%s' in current context"), varname);
2342
2343             if (TYPE_CODE (type) == TYPE_CODE_STRUCT
2344                 && TYPE_NFIELDS (type) == 0)
2345               {
2346                 /* A unit-like struct.  */
2347                 write_exp_elt_opcode (state, OP_AGGREGATE);
2348                 write_exp_elt_type (state, type);
2349                 write_exp_elt_longcst (state, 0);
2350                 write_exp_elt_opcode (state, OP_AGGREGATE);
2351               }
2352             else if (operation == top)
2353               {
2354                 write_exp_elt_opcode (state, OP_TYPE);
2355                 write_exp_elt_type (state, type);
2356                 write_exp_elt_opcode (state, OP_TYPE);
2357                 break;
2358               }
2359           }
2360       }
2361       break;
2362
2363     case OP_AGGREGATE:
2364       {
2365         int i;
2366         int length;
2367         struct set_field *init;
2368         VEC (set_field) *fields = *operation->right.field_inits;
2369         struct type *type;
2370         const char *name;
2371
2372         length = 0;
2373         for (i = 0; VEC_iterate (set_field, fields, i, init); ++i)
2374           {
2375             if (init->name.ptr != NULL)
2376               {
2377                 write_exp_elt_opcode (state, OP_NAME);
2378                 write_exp_string (state, init->name);
2379                 write_exp_elt_opcode (state, OP_NAME);
2380                 ++length;
2381               }
2382
2383             convert_ast_to_expression (state, init->init, top);
2384             ++length;
2385
2386             if (init->name.ptr == NULL)
2387               {
2388                 /* This is handled differently from Ada in our
2389                    evaluator.  */
2390                 write_exp_elt_opcode (state, OP_OTHERS);
2391               }
2392           }
2393
2394         name = convert_name (state, operation->left.op);
2395         type = rust_lookup_type (name, expression_context_block);
2396         if (type == NULL)
2397           error (_("Could not find type '%s'"), operation->left.sval.ptr);
2398
2399         if (TYPE_CODE (type) != TYPE_CODE_STRUCT
2400             || rust_tuple_type_p (type)
2401             || rust_tuple_struct_type_p (type))
2402           error (_("Struct expression applied to non-struct type"));
2403
2404         write_exp_elt_opcode (state, OP_AGGREGATE);
2405         write_exp_elt_type (state, type);
2406         write_exp_elt_longcst (state, length);
2407         write_exp_elt_opcode (state, OP_AGGREGATE);
2408       }
2409       break;
2410
2411     case OP_STRING:
2412       {
2413         write_exp_elt_opcode (state, OP_STRING);
2414         write_exp_string (state, operation->left.sval);
2415         write_exp_elt_opcode (state, OP_STRING);
2416       }
2417       break;
2418
2419     case OP_RANGE:
2420       {
2421         enum range_type kind = BOTH_BOUND_DEFAULT;
2422
2423         if (operation->left.op != NULL)
2424           {
2425             convert_ast_to_expression (state, operation->left.op, top);
2426             kind = HIGH_BOUND_DEFAULT;
2427           }
2428         if (operation->right.op != NULL)
2429           {
2430             convert_ast_to_expression (state, operation->right.op, top);
2431             if (kind == BOTH_BOUND_DEFAULT)
2432               kind = LOW_BOUND_DEFAULT;
2433             else
2434               {
2435                 gdb_assert (kind == HIGH_BOUND_DEFAULT);
2436                 kind = NONE_BOUND_DEFAULT;
2437               }
2438           }
2439         write_exp_elt_opcode (state, OP_RANGE);
2440         write_exp_elt_longcst (state, kind);
2441         write_exp_elt_opcode (state, OP_RANGE);
2442       }
2443       break;
2444
2445     default:
2446       gdb_assert_not_reached ("unhandled opcode in convert_ast_to_expression");
2447     }
2448 }
2449
2450 \f
2451
2452 /* The parser as exposed to gdb.  */
2453
2454 int
2455 rust_parse (struct parser_state *state)
2456 {
2457   int result;
2458   struct cleanup *cleanup;
2459
2460   obstack_init (&work_obstack);
2461   cleanup = make_cleanup_obstack_free (&work_obstack);
2462   rust_ast = NULL;
2463
2464   pstate = state;
2465   result = rustyyparse ();
2466
2467   if (!result || (parse_completion && rust_ast != NULL))
2468     {
2469       const struct rust_op *ast = rust_ast;
2470
2471       rust_ast = NULL;
2472       gdb_assert (ast != NULL);
2473       convert_ast_to_expression (state, ast, ast);
2474     }
2475
2476   do_cleanups (cleanup);
2477   return result;
2478 }
2479
2480 /* The parser error handler.  */
2481
2482 void
2483 rustyyerror (char *msg)
2484 {
2485   const char *where = prev_lexptr ? prev_lexptr : lexptr;
2486   error (_("%s in expression, near `%s'."), (msg ? msg : "Error"), where);
2487 }
2488
2489 \f
2490
2491 #if GDB_SELF_TEST
2492
2493 /* Initialize the lexer for testing.  */
2494
2495 static void
2496 rust_lex_test_init (const char *input)
2497 {
2498   prev_lexptr = NULL;
2499   lexptr = input;
2500   paren_depth = 0;
2501 }
2502
2503 /* A test helper that lexes a string, expecting a single token.  It
2504    returns the lexer data for this token.  */
2505
2506 static RUSTSTYPE
2507 rust_lex_test_one (const char *input, int expected)
2508 {
2509   int token;
2510   RUSTSTYPE result;
2511
2512   rust_lex_test_init (input);
2513
2514   token = rustyylex ();
2515   SELF_CHECK (token == expected);
2516   result = rustyylval;
2517
2518   if (token)
2519     {
2520       token = rustyylex ();
2521       SELF_CHECK (token == 0);
2522     }
2523
2524   return result;
2525 }
2526
2527 /* Test that INPUT lexes as the integer VALUE.  */
2528
2529 static void
2530 rust_lex_int_test (const char *input, int value, int kind)
2531 {
2532   RUSTSTYPE result = rust_lex_test_one (input, kind);
2533   SELF_CHECK (result.typed_val_int.val == value);
2534 }
2535
2536 /* Test that INPUT throws an exception with text ERR.  */
2537
2538 static void
2539 rust_lex_exception_test (const char *input, const char *err)
2540 {
2541   TRY
2542     {
2543       /* The "kind" doesn't matter.  */
2544       rust_lex_test_one (input, DECIMAL_INTEGER);
2545       SELF_CHECK (0);
2546     }
2547   CATCH (except, RETURN_MASK_ERROR)
2548     {
2549       SELF_CHECK (strcmp (except.message, err) == 0);
2550     }
2551   END_CATCH
2552 }
2553
2554 /* Test that INPUT lexes as the identifier, string, or byte-string
2555    VALUE.  KIND holds the expected token kind.  */
2556
2557 static void
2558 rust_lex_stringish_test (const char *input, const char *value, int kind)
2559 {
2560   RUSTSTYPE result = rust_lex_test_one (input, kind);
2561   SELF_CHECK (result.sval.length == strlen (value));
2562   SELF_CHECK (strncmp (result.sval.ptr, value, result.sval.length) == 0);
2563 }
2564
2565 /* Helper to test that a string parses as a given token sequence.  */
2566
2567 static void
2568 rust_lex_test_sequence (const char *input, int len, const int expected[])
2569 {
2570   int i;
2571
2572   lexptr = input;
2573   paren_depth = 0;
2574
2575   for (i = 0; i < len; ++i)
2576     {
2577       int token = rustyylex ();
2578
2579       SELF_CHECK (token == expected[i]);
2580     }
2581 }
2582
2583 /* Tests for an integer-parsing corner case.  */
2584
2585 static void
2586 rust_lex_test_trailing_dot (void)
2587 {
2588   const int expected1[] = { DECIMAL_INTEGER, '.', IDENT, '(', ')', 0 };
2589   const int expected2[] = { INTEGER, '.', IDENT, '(', ')', 0 };
2590   const int expected3[] = { FLOAT, EQEQ, '(', ')', 0 };
2591   const int expected4[] = { DECIMAL_INTEGER, DOTDOT, DECIMAL_INTEGER, 0 };
2592
2593   rust_lex_test_sequence ("23.g()", ARRAY_SIZE (expected1), expected1);
2594   rust_lex_test_sequence ("23_0.g()", ARRAY_SIZE (expected2), expected2);
2595   rust_lex_test_sequence ("23.==()", ARRAY_SIZE (expected3), expected3);
2596   rust_lex_test_sequence ("23..25", ARRAY_SIZE (expected4), expected4);
2597 }
2598
2599 /* Tests of completion.  */
2600
2601 static void
2602 rust_lex_test_completion (void)
2603 {
2604   const int expected[] = { IDENT, '.', COMPLETE, 0 };
2605
2606   parse_completion = 1;
2607
2608   rust_lex_test_sequence ("something.wha", ARRAY_SIZE (expected), expected);
2609   rust_lex_test_sequence ("something.", ARRAY_SIZE (expected), expected);
2610
2611   parse_completion = 0;
2612 }
2613
2614 /* Test pushback.  */
2615
2616 static void
2617 rust_lex_test_push_back (void)
2618 {
2619   int token;
2620
2621   rust_lex_test_init (">>=");
2622
2623   token = rustyylex ();
2624   SELF_CHECK (token == COMPOUND_ASSIGN);
2625   SELF_CHECK (rustyylval.opcode == BINOP_RSH);
2626
2627   rust_push_back ('=');
2628
2629   token = rustyylex ();
2630   SELF_CHECK (token == '=');
2631
2632   token = rustyylex ();
2633   SELF_CHECK (token == 0);
2634 }
2635
2636 /* Unit test the lexer.  */
2637
2638 static void
2639 rust_lex_tests (void)
2640 {
2641   int i;
2642
2643   obstack_init (&work_obstack);
2644   unit_testing = 1;
2645
2646   rust_lex_test_one ("", 0);
2647   rust_lex_test_one ("    \t  \n \r  ", 0);
2648   rust_lex_test_one ("thread 23", 0);
2649   rust_lex_test_one ("task 23", 0);
2650   rust_lex_test_one ("th 104", 0);
2651   rust_lex_test_one ("ta 97", 0);
2652
2653   rust_lex_int_test ("'z'", 'z', INTEGER);
2654   rust_lex_int_test ("'\\xff'", 0xff, INTEGER);
2655   rust_lex_int_test ("'\\u{1016f}'", 0x1016f, INTEGER);
2656   rust_lex_int_test ("b'z'", 'z', INTEGER);
2657   rust_lex_int_test ("b'\\xfe'", 0xfe, INTEGER);
2658   rust_lex_int_test ("b'\\xFE'", 0xfe, INTEGER);
2659   rust_lex_int_test ("b'\\xfE'", 0xfe, INTEGER);
2660
2661   /* Test all escapes in both modes.  */
2662   rust_lex_int_test ("'\\n'", '\n', INTEGER);
2663   rust_lex_int_test ("'\\r'", '\r', INTEGER);
2664   rust_lex_int_test ("'\\t'", '\t', INTEGER);
2665   rust_lex_int_test ("'\\\\'", '\\', INTEGER);
2666   rust_lex_int_test ("'\\0'", '\0', INTEGER);
2667   rust_lex_int_test ("'\\''", '\'', INTEGER);
2668   rust_lex_int_test ("'\\\"'", '"', INTEGER);
2669
2670   rust_lex_int_test ("b'\\n'", '\n', INTEGER);
2671   rust_lex_int_test ("b'\\r'", '\r', INTEGER);
2672   rust_lex_int_test ("b'\\t'", '\t', INTEGER);
2673   rust_lex_int_test ("b'\\\\'", '\\', INTEGER);
2674   rust_lex_int_test ("b'\\0'", '\0', INTEGER);
2675   rust_lex_int_test ("b'\\''", '\'', INTEGER);
2676   rust_lex_int_test ("b'\\\"'", '"', INTEGER);
2677
2678   rust_lex_exception_test ("'z", "Unterminated character literal");
2679   rust_lex_exception_test ("b'\\x0'", "Not enough hex digits seen");
2680   rust_lex_exception_test ("b'\\u{0}'", "Unicode escape in byte literal");
2681   rust_lex_exception_test ("'\\x0'", "Not enough hex digits seen");
2682   rust_lex_exception_test ("'\\u0'", "Missing '{' in Unicode escape");
2683   rust_lex_exception_test ("'\\u{0", "Missing '}' in Unicode escape");
2684   rust_lex_exception_test ("'\\u{0000007}", "Overlong hex escape");
2685   rust_lex_exception_test ("'\\u{}", "Not enough hex digits seen");
2686   rust_lex_exception_test ("'\\Q'", "Invalid escape \\Q in literal");
2687   rust_lex_exception_test ("b'\\Q'", "Invalid escape \\Q in literal");
2688
2689   rust_lex_int_test ("23", 23, DECIMAL_INTEGER);
2690   rust_lex_int_test ("2_344__29", 234429, INTEGER);
2691   rust_lex_int_test ("0x1f", 0x1f, INTEGER);
2692   rust_lex_int_test ("23usize", 23, INTEGER);
2693   rust_lex_int_test ("23i32", 23, INTEGER);
2694   rust_lex_int_test ("0x1_f", 0x1f, INTEGER);
2695   rust_lex_int_test ("0b1_101011__", 0x6b, INTEGER);
2696   rust_lex_int_test ("0o001177i64", 639, INTEGER);
2697
2698   rust_lex_test_trailing_dot ();
2699
2700   rust_lex_test_one ("23.", FLOAT);
2701   rust_lex_test_one ("23.99f32", FLOAT);
2702   rust_lex_test_one ("23e7", FLOAT);
2703   rust_lex_test_one ("23E-7", FLOAT);
2704   rust_lex_test_one ("23e+7", FLOAT);
2705   rust_lex_test_one ("23.99e+7f64", FLOAT);
2706   rust_lex_test_one ("23.82f32", FLOAT);
2707
2708   rust_lex_stringish_test ("hibob", "hibob", IDENT);
2709   rust_lex_stringish_test ("hibob__93", "hibob__93", IDENT);
2710   rust_lex_stringish_test ("thread", "thread", IDENT);
2711
2712   rust_lex_stringish_test ("\"string\"", "string", STRING);
2713   rust_lex_stringish_test ("\"str\\ting\"", "str\ting", STRING);
2714   rust_lex_stringish_test ("\"str\\\"ing\"", "str\"ing", STRING);
2715   rust_lex_stringish_test ("r\"str\\ing\"", "str\\ing", STRING);
2716   rust_lex_stringish_test ("r#\"str\\ting\"#", "str\\ting", STRING);
2717   rust_lex_stringish_test ("r###\"str\\\"ing\"###", "str\\\"ing", STRING);
2718
2719   rust_lex_stringish_test ("b\"string\"", "string", BYTESTRING);
2720   rust_lex_stringish_test ("b\"\x73tring\"", "string", BYTESTRING);
2721   rust_lex_stringish_test ("b\"str\\\"ing\"", "str\"ing", BYTESTRING);
2722   rust_lex_stringish_test ("br####\"\\x73tring\"####", "\\x73tring",
2723                            BYTESTRING);
2724
2725   for (i = 0; i < ARRAY_SIZE (identifier_tokens); ++i)
2726     rust_lex_test_one (identifier_tokens[i].name, identifier_tokens[i].value);
2727
2728   for (i = 0; i < ARRAY_SIZE (operator_tokens); ++i)
2729     rust_lex_test_one (operator_tokens[i].name, operator_tokens[i].value);
2730
2731   rust_lex_test_completion ();
2732   rust_lex_test_push_back ();
2733
2734   obstack_free (&work_obstack, NULL);
2735   unit_testing = 0;
2736 }
2737
2738 #endif /* GDB_SELF_TEST */
2739
2740 void
2741 _initialize_rust_exp (void)
2742 {
2743   int code = regcomp (&number_regex, number_regex_text, REG_EXTENDED);
2744   /* If the regular expression was incorrect, it was a programming
2745      error.  */
2746   gdb_assert (code == 0);
2747
2748 #if GDB_SELF_TEST
2749   register_self_test (rust_lex_tests);
2750 #endif
2751 }