gdb/rust-parse.c

   1 /* Rust expression parsing for GDB, the GNU debugger.
   2
   3    Copyright (C) 2016-2022 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21
  22 #include "block.h"
  23 #include "charset.h"
  24 #include "cp-support.h"
  25 #include "gdbsupport/gdb_obstack.h"
  26 #include "gdbsupport/gdb_regex.h"
  27 #include "rust-lang.h"
  28 #include "parser-defs.h"
  29 #include "gdbsupport/selftest.h"
  30 #include "value.h"
  31 #include "gdbarch.h"
  32 #include "rust-exp.h"
  33
  34 using namespace expr;
  35
  36 /* A regular expression for matching Rust numbers.  This is split up
  37    since it is very long and this gives us a way to comment the
  38    sections.  */
  39
  40 static const char number_regex_text[] =
  41   /* subexpression 1: allows use of alternation, otherwise uninteresting */
  42   "^("
  43   /* First comes floating point.  */
  44   /* Recognize number after the decimal point, with optional
  45      exponent and optional type suffix.
  46      subexpression 2: allows "?", otherwise uninteresting
  47      subexpression 3: if present, type suffix
  48   */
  49   "[0-9][0-9_]*\\.[0-9][0-9_]*([eE][-+]?[0-9][0-9_]*)?(f32|f64)?"
  50 #define FLOAT_TYPE1 3
  51   "|"
  52   /* Recognize exponent without decimal point, with optional type
  53      suffix.
  54      subexpression 4: if present, type suffix
  55   */
  56 #define FLOAT_TYPE2 4
  57   "[0-9][0-9_]*[eE][-+]?[0-9][0-9_]*(f32|f64)?"
  58   "|"
  59   /* "23." is a valid floating point number, but "23.e5" and
  60      "23.f32" are not.  So, handle the trailing-. case
  61      separately.  */
  62   "[0-9][0-9_]*\\."
  63   "|"
  64   /* Finally come integers.
  65      subexpression 5: text of integer
  66      subexpression 6: if present, type suffix
  67      subexpression 7: allows use of alternation, otherwise uninteresting
  68   */
  69 #define INT_TEXT 5
  70 #define INT_TYPE 6
  71   "(0x[a-fA-F0-9_]+|0o[0-7_]+|0b[01_]+|[0-9][0-9_]*)"
  72   "([iu](size|8|16|32|64))?"
  73   ")";
  74 /* The number of subexpressions to allocate space for, including the
  75    "0th" whole match subexpression.  */
  76 #define NUM_SUBEXPRESSIONS 8
  77
  78 /* The compiled number-matching regex.  */
  79
  80 static regex_t number_regex;
  81
  82 /* The kinds of tokens.  Note that single-character tokens are
  83    represented by themselves, so for instance '[' is a token.  */
  84 enum token_type : int
  85 {
  86   /* Make sure to start after any ASCII character.  */
  87   GDBVAR = 256,
  88   IDENT,
  89   COMPLETE,
  90   INTEGER,
  91   DECIMAL_INTEGER,
  92   STRING,
  93   BYTESTRING,
  94   FLOAT,
  95   COMPOUND_ASSIGN,
  96
  97   /* Keyword tokens.  */
  98   KW_AS,
  99   KW_IF,
 100   KW_TRUE,
 101   KW_FALSE,
 102   KW_SUPER,
 103   KW_SELF,
 104   KW_MUT,
 105   KW_EXTERN,
 106   KW_CONST,
 107   KW_FN,
 108   KW_SIZEOF,
 109
 110   /* Operator tokens.  */
 111   DOTDOT,
 112   DOTDOTEQ,
 113   OROR,
 114   ANDAND,
 115   EQEQ,
 116   NOTEQ,
 117   LTEQ,
 118   GTEQ,
 119   LSH,
 120   RSH,
 121   COLONCOLON,
 122   ARROW,
 123 };
 124
 125 /* A typed integer constant.  */
 126
 127 struct typed_val_int
 128 {
 129   ULONGEST val;
 130   struct type *type;
 131 };
 132
 133 /* A typed floating point constant.  */
 134
 135 struct typed_val_float
 136 {
 137   float_data val;
 138   struct type *type;
 139 };
 140
 141 /* A struct of this type is used to describe a token.  */
 142
 143 struct token_info
 144 {
 145   const char *name;
 146   int value;
 147   enum exp_opcode opcode;
 148 };
 149
 150 /* Identifier tokens.  */
 151
 152 static const struct token_info identifier_tokens[] =
 153 {
 154   { "as", KW_AS, OP_NULL },
 155   { "false", KW_FALSE, OP_NULL },
 156   { "if", 0, OP_NULL },
 157   { "mut", KW_MUT, OP_NULL },
 158   { "const", KW_CONST, OP_NULL },
 159   { "self", KW_SELF, OP_NULL },
 160   { "super", KW_SUPER, OP_NULL },
 161   { "true", KW_TRUE, OP_NULL },
 162   { "extern", KW_EXTERN, OP_NULL },
 163   { "fn", KW_FN, OP_NULL },
 164   { "sizeof", KW_SIZEOF, OP_NULL },
 165 };
 166
 167 /* Operator tokens, sorted longest first.  */
 168
 169 static const struct token_info operator_tokens[] =
 170 {
 171   { ">>=", COMPOUND_ASSIGN, BINOP_RSH },
 172   { "<<=", COMPOUND_ASSIGN, BINOP_LSH },
 173
 174   { "<<", LSH, OP_NULL },
 175   { ">>", RSH, OP_NULL },
 176   { "&&", ANDAND, OP_NULL },
 177   { "||", OROR, OP_NULL },
 178   { "==", EQEQ, OP_NULL },
 179   { "!=", NOTEQ, OP_NULL },
 180   { "<=", LTEQ, OP_NULL },
 181   { ">=", GTEQ, OP_NULL },
 182   { "+=", COMPOUND_ASSIGN, BINOP_ADD },
 183   { "-=", COMPOUND_ASSIGN, BINOP_SUB },
 184   { "*=", COMPOUND_ASSIGN, BINOP_MUL },
 185   { "/=", COMPOUND_ASSIGN, BINOP_DIV },
 186   { "%=", COMPOUND_ASSIGN, BINOP_REM },
 187   { "&=", COMPOUND_ASSIGN, BINOP_BITWISE_AND },
 188   { "|=", COMPOUND_ASSIGN, BINOP_BITWISE_IOR },
 189   { "^=", COMPOUND_ASSIGN, BINOP_BITWISE_XOR },
 190   { "..=", DOTDOTEQ, OP_NULL },
 191
 192   { "::", COLONCOLON, OP_NULL },
 193   { "..", DOTDOT, OP_NULL },
 194   { "->", ARROW, OP_NULL }
 195 };
 196
 197 /* An instance of this is created before parsing, and destroyed when
 198    parsing is finished.  */
 199
 200 struct rust_parser
 201 {
 202   explicit rust_parser (struct parser_state *state)
 203     : pstate (state)
 204   {
 205   }
 206
 207   DISABLE_COPY_AND_ASSIGN (rust_parser);
 208
 209   /* Return the parser's language.  */
 210   const struct language_defn *language () const
 211   {
 212     return pstate->language ();
 213   }
 214
 215   /* Return the parser's gdbarch.  */
 216   struct gdbarch *arch () const
 217   {
 218     return pstate->gdbarch ();
 219   }
 220
 221   /* A helper to look up a Rust type, or fail.  This only works for
 222      types defined by rust_language_arch_info.  */
 223
 224   struct type *get_type (const char *name)
 225   {
 226     struct type *type;
 227
 228     type = language_lookup_primitive_type (language (), arch (), name);
 229     if (type == NULL)
 230       error (_("Could not find Rust type %s"), name);
 231     return type;
 232   }
 233
 234   std::string crate_name (const std::string &name);
 235   std::string super_name (const std::string &ident, unsigned int n_supers);
 236
 237   int lex_character ();
 238   int lex_number ();
 239   int lex_string ();
 240   int lex_identifier ();
 241   uint32_t lex_hex (int min, int max);
 242   uint32_t lex_escape (int is_byte);
 243   int lex_operator ();
 244   int lex_one_token ();
 245   void push_back (char c);
 246
 247   /* The main interface to lexing.  Lexes one token and updates the
 248      internal state.  */
 249   void lex ()
 250   {
 251     current_token = lex_one_token ();
 252   }
 253
 254   /* Assuming the current token is TYPE, lex the next token.  */
 255   void assume (int type)
 256   {
 257     gdb_assert (current_token == type);
 258     lex ();
 259   }
 260
 261   /* Require the single-character token C, and lex the next token; or
 262      throw an exception.  */
 263   void require (char type)
 264   {
 265     if (current_token != type)
 266       error (_("'%c' expected"), type);
 267     lex ();
 268   }
 269
 270   /* Entry point for all parsing.  */
 271   operation_up parse_entry_point ()
 272   {
 273     lex ();
 274     return parse_expr ();
 275   }
 276
 277   operation_up parse_tuple ();
 278   operation_up parse_array ();
 279   operation_up name_to_operation (const std::string &name);
 280   operation_up parse_struct_expr (struct type *type);
 281   operation_up parse_binop (bool required);
 282   operation_up parse_range ();
 283   operation_up parse_expr ();
 284   operation_up parse_sizeof ();
 285   operation_up parse_addr ();
 286   operation_up parse_field (operation_up &&);
 287   operation_up parse_index (operation_up &&);
 288   std::vector<operation_up> parse_paren_args ();
 289   operation_up parse_call (operation_up &&);
 290   std::vector<struct type *> parse_type_list ();
 291   std::vector<struct type *> parse_maybe_type_list ();
 292   struct type *parse_array_type ();
 293   struct type *parse_slice_type ();
 294   struct type *parse_pointer_type ();
 295   struct type *parse_function_type ();
 296   struct type *parse_tuple_type ();
 297   struct type *parse_type ();
 298   std::string parse_path (bool for_expr);
 299   operation_up parse_string ();
 300   operation_up parse_tuple_struct (struct type *type);
 301   operation_up parse_path_expr ();
 302   operation_up parse_atom (bool required);
 303
 304   void update_innermost_block (struct block_symbol sym);
 305   struct block_symbol lookup_symbol (const char *name,
 306                                      const struct block *block,
 307                                      const domain_enum domain);
 308   struct type *rust_lookup_type (const char *name);
 309
 310   /* Clear some state.  This is only used for testing.  */
 311 #if GDB_SELF_TEST
 312   void reset (const char *input)
 313   {
 314     pstate->prev_lexptr = nullptr;
 315     pstate->lexptr = input;
 316     paren_depth = 0;
 317     current_token = 0;
 318     current_int_val = {};
 319     current_float_val = {};
 320     current_string_val = {};
 321     current_opcode = OP_NULL;
 322   }
 323 #endif /* GDB_SELF_TEST */
 324
 325   /* Return the token's string value as a string.  */
 326   std::string get_string () const
 327   {
 328     return std::string (current_string_val.ptr, current_string_val.length);
 329   }
 330
 331   /* A pointer to this is installed globally.  */
 332   auto_obstack obstack;
 333
 334   /* The parser state gdb gave us.  */
 335   struct parser_state *pstate;
 336
 337   /* Depth of parentheses.  */
 338   int paren_depth = 0;
 339
 340   /* The current token's type.  */
 341   int current_token = 0;
 342   /* The current token's payload, if any.  */
 343   typed_val_int current_int_val {};
 344   typed_val_float current_float_val {};
 345   struct stoken current_string_val {};
 346   enum exp_opcode current_opcode = OP_NULL;
 347
 348   /* When completing, this may be set to the field operation to
 349      complete.  */
 350   operation_up completion_op;
 351 };
 352
 353 /* Return an string referring to NAME, but relative to the crate's
 354    name.  */
 355
 356 std::string
 357 rust_parser::crate_name (const std::string &name)
 358 {
 359   std::string crate = rust_crate_for_block (pstate->expression_context_block);
 360
 361   if (crate.empty ())
 362     error (_("Could not find crate for current location"));
 363   return "::" + crate + "::" + name;
 364 }
 365
 366 /* Return a string referring to a "super::" qualified name.  IDENT is
 367    the base name and N_SUPERS is how many "super::"s were provided.
 368    N_SUPERS can be zero.  */
 369
 370 std::string
 371 rust_parser::super_name (const std::string &ident, unsigned int n_supers)
 372 {
 373   const char *scope = block_scope (pstate->expression_context_block);
 374   int offset;
 375
 376   if (scope[0] == '\0')
 377     error (_("Couldn't find namespace scope for self::"));
 378
 379   if (n_supers > 0)
 380     {
 381       int len;
 382       std::vector<int> offsets;
 383       unsigned int current_len;
 384
 385       current_len = cp_find_first_component (scope);
 386       while (scope[current_len] != '\0')
 387         {
 388           offsets.push_back (current_len);
 389           gdb_assert (scope[current_len] == ':');
 390           /* The "::".  */
 391           current_len += 2;
 392           current_len += cp_find_first_component (scope
 393                                                   + current_len);
 394         }
 395
 396       len = offsets.size ();
 397       if (n_supers >= len)
 398         error (_("Too many super:: uses from '%s'"), scope);
 399
 400       offset = offsets[len - n_supers];
 401     }
 402   else
 403     offset = strlen (scope);
 404
 405   return "::" + std::string (scope, offset) + "::" + ident;
 406 }
 407
 408 /* A helper to appropriately munge NAME and BLOCK depending on the
 409    presence of a leading "::".  */
 410
 411 static void
 412 munge_name_and_block (const char **name, const struct block **block)
 413 {
 414   /* If it is a global reference, skip the current block in favor of
 415      the static block.  */
 416   if (startswith (*name, "::"))
 417     {
 418       *name += 2;
 419       *block = block_static_block (*block);
 420     }
 421 }
 422
 423 /* Like lookup_symbol, but handles Rust namespace conventions, and
 424    doesn't require field_of_this_result.  */
 425
 426 struct block_symbol
 427 rust_parser::lookup_symbol (const char *name, const struct block *block,
 428                             const domain_enum domain)
 429 {
 430   struct block_symbol result;
 431
 432   munge_name_and_block (&name, &block);
 433
 434   result = ::lookup_symbol (name, block, domain, NULL);
 435   if (result.symbol != NULL)
 436     update_innermost_block (result);
 437   return result;
 438 }
 439
 440 /* Look up a type, following Rust namespace conventions.  */
 441
 442 struct type *
 443 rust_parser::rust_lookup_type (const char *name)
 444 {
 445   struct block_symbol result;
 446   struct type *type;
 447
 448   const struct block *block = pstate->expression_context_block;
 449   munge_name_and_block (&name, &block);
 450
 451   result = ::lookup_symbol (name, block, STRUCT_DOMAIN, NULL);
 452   if (result.symbol != NULL)
 453     {
 454       update_innermost_block (result);
 455       return SYMBOL_TYPE (result.symbol);
 456     }
 457
 458   type = lookup_typename (language (), name, NULL, 1);
 459   if (type != NULL)
 460     return type;
 461
 462   /* Last chance, try a built-in type.  */
 463   return language_lookup_primitive_type (language (), arch (), name);
 464 }
 465
 466 /* A helper that updates the innermost block as appropriate.  */
 467
 468 void
 469 rust_parser::update_innermost_block (struct block_symbol sym)
 470 {
 471   if (symbol_read_needs_frame (sym.symbol))
 472     pstate->block_tracker->update (sym);
 473 }
 474
 475 /* Lex a hex number with at least MIN digits and at most MAX
 476    digits.  */
 477
 478 uint32_t
 479 rust_parser::lex_hex (int min, int max)
 480 {
 481   uint32_t result = 0;
 482   int len = 0;
 483   /* We only want to stop at MAX if we're lexing a byte escape.  */
 484   int check_max = min == max;
 485
 486   while ((check_max ? len <= max : 1)
 487          && ((pstate->lexptr[0] >= 'a' && pstate->lexptr[0] <= 'f')
 488              || (pstate->lexptr[0] >= 'A' && pstate->lexptr[0] <= 'F')
 489              || (pstate->lexptr[0] >= '0' && pstate->lexptr[0] <= '9')))
 490     {
 491       result *= 16;
 492       if (pstate->lexptr[0] >= 'a' && pstate->lexptr[0] <= 'f')
 493         result = result + 10 + pstate->lexptr[0] - 'a';
 494       else if (pstate->lexptr[0] >= 'A' && pstate->lexptr[0] <= 'F')
 495         result = result + 10 + pstate->lexptr[0] - 'A';
 496       else
 497         result = result + pstate->lexptr[0] - '0';
 498       ++pstate->lexptr;
 499       ++len;
 500     }
 501
 502   if (len < min)
 503     error (_("Not enough hex digits seen"));
 504   if (len > max)
 505     {
 506       gdb_assert (min != max);
 507       error (_("Overlong hex escape"));
 508     }
 509
 510   return result;
 511 }
 512
 513 /* Lex an escape.  IS_BYTE is true if we're lexing a byte escape;
 514    otherwise we're lexing a character escape.  */
 515
 516 uint32_t
 517 rust_parser::lex_escape (int is_byte)
 518 {
 519   uint32_t result;
 520
 521   gdb_assert (pstate->lexptr[0] == '\\');
 522   ++pstate->lexptr;
 523   switch (pstate->lexptr[0])
 524     {
 525     case 'x':
 526       ++pstate->lexptr;
 527       result = lex_hex (2, 2);
 528       break;
 529
 530     case 'u':
 531       if (is_byte)
 532         error (_("Unicode escape in byte literal"));
 533       ++pstate->lexptr;
 534       if (pstate->lexptr[0] != '{')
 535         error (_("Missing '{' in Unicode escape"));
 536       ++pstate->lexptr;
 537       result = lex_hex (1, 6);
 538       /* Could do range checks here.  */
 539       if (pstate->lexptr[0] != '}')
 540         error (_("Missing '}' in Unicode escape"));
 541       ++pstate->lexptr;
 542       break;
 543
 544     case 'n':
 545       result = '\n';
 546       ++pstate->lexptr;
 547       break;
 548     case 'r':
 549       result = '\r';
 550       ++pstate->lexptr;
 551       break;
 552     case 't':
 553       result = '\t';
 554       ++pstate->lexptr;
 555       break;
 556     case '\\':
 557       result = '\\';
 558       ++pstate->lexptr;
 559       break;
 560     case '0':
 561       result = '\0';
 562       ++pstate->lexptr;
 563       break;
 564     case '\'':
 565       result = '\'';
 566       ++pstate->lexptr;
 567       break;
 568     case '"':
 569       result = '"';
 570       ++pstate->lexptr;
 571       break;
 572
 573     default:
 574       error (_("Invalid escape \\%c in literal"), pstate->lexptr[0]);
 575     }
 576
 577   return result;
 578 }
 579
 580 /* Lex a character constant.  */
 581
 582 int
 583 rust_parser::lex_character ()
 584 {
 585   int is_byte = 0;
 586   uint32_t value;
 587
 588   if (pstate->lexptr[0] == 'b')
 589     {
 590       is_byte = 1;
 591       ++pstate->lexptr;
 592     }
 593   gdb_assert (pstate->lexptr[0] == '\'');
 594   ++pstate->lexptr;
 595   /* This should handle UTF-8 here.  */
 596   if (pstate->lexptr[0] == '\\')
 597     value = lex_escape (is_byte);
 598   else
 599     {
 600       value = pstate->lexptr[0] & 0xff;
 601       ++pstate->lexptr;
 602     }
 603
 604   if (pstate->lexptr[0] != '\'')
 605     error (_("Unterminated character literal"));
 606   ++pstate->lexptr;
 607
 608   current_int_val.val = value;
 609   current_int_val.type = get_type (is_byte ? "u8" : "char");
 610
 611   return INTEGER;
 612 }
 613
 614 /* Return the offset of the double quote if STR looks like the start
 615    of a raw string, or 0 if STR does not start a raw string.  */
 616
 617 static int
 618 starts_raw_string (const char *str)
 619 {
 620   const char *save = str;
 621
 622   if (str[0] != 'r')
 623     return 0;
 624   ++str;
 625   while (str[0] == '#')
 626     ++str;
 627   if (str[0] == '"')
 628     return str - save;
 629   return 0;
 630 }
 631
 632 /* Return true if STR looks like the end of a raw string that had N
 633    hashes at the start.  */
 634
 635 static bool
 636 ends_raw_string (const char *str, int n)
 637 {
 638   int i;
 639
 640   gdb_assert (str[0] == '"');
 641   for (i = 0; i < n; ++i)
 642     if (str[i + 1] != '#')
 643       return false;
 644   return true;
 645 }
 646
 647 /* Lex a string constant.  */
 648
 649 int
 650 rust_parser::lex_string ()
 651 {
 652   int is_byte = pstate->lexptr[0] == 'b';
 653   int raw_length;
 654
 655   if (is_byte)
 656     ++pstate->lexptr;
 657   raw_length = starts_raw_string (pstate->lexptr);
 658   pstate->lexptr += raw_length;
 659   gdb_assert (pstate->lexptr[0] == '"');
 660   ++pstate->lexptr;
 661
 662   while (1)
 663     {
 664       uint32_t value;
 665
 666       if (raw_length > 0)
 667         {
 668           if (pstate->lexptr[0] == '"' && ends_raw_string (pstate->lexptr,
 669                                                            raw_length - 1))
 670             {
 671               /* Exit with lexptr pointing after the final "#".  */
 672               pstate->lexptr += raw_length;
 673               break;
 674             }
 675           else if (pstate->lexptr[0] == '\0')
 676             error (_("Unexpected EOF in string"));
 677
 678           value = pstate->lexptr[0] & 0xff;
 679           if (is_byte && value > 127)
 680             error (_("Non-ASCII value in raw byte string"));
 681           obstack_1grow (&obstack, value);
 682
 683           ++pstate->lexptr;
 684         }
 685       else if (pstate->lexptr[0] == '"')
 686         {
 687           /* Make sure to skip the quote.  */
 688           ++pstate->lexptr;
 689           break;
 690         }
 691       else if (pstate->lexptr[0] == '\\')
 692         {
 693           value = lex_escape (is_byte);
 694
 695           if (is_byte)
 696             obstack_1grow (&obstack, value);
 697           else
 698             {
 699 #if WORDS_BIGENDIAN
 700 #define UTF32 "UTF-32BE"
 701 #else
 702 #define UTF32 "UTF-32LE"
 703 #endif
 704               convert_between_encodings (UTF32, "UTF-8", (gdb_byte *) &value,
 705                                          sizeof (value), sizeof (value),
 706                                          &obstack, translit_none);
 707             }
 708         }
 709       else if (pstate->lexptr[0] == '\0')
 710         error (_("Unexpected EOF in string"));
 711       else
 712         {
 713           value = pstate->lexptr[0] & 0xff;
 714           if (is_byte && value > 127)
 715             error (_("Non-ASCII value in byte string"));
 716           obstack_1grow (&obstack, value);
 717           ++pstate->lexptr;
 718         }
 719     }
 720
 721   current_string_val.length = obstack_object_size (&obstack);
 722   current_string_val.ptr = (const char *) obstack_finish (&obstack);
 723   return is_byte ? BYTESTRING : STRING;
 724 }
 725
 726 /* Return true if STRING starts with whitespace followed by a digit.  */
 727
 728 static bool
 729 space_then_number (const char *string)
 730 {
 731   const char *p = string;
 732
 733   while (p[0] == ' ' || p[0] == '\t')
 734     ++p;
 735   if (p == string)
 736     return false;
 737
 738   return *p >= '0' && *p <= '9';
 739 }
 740
 741 /* Return true if C can start an identifier.  */
 742
 743 static bool
 744 rust_identifier_start_p (char c)
 745 {
 746   return ((c >= 'a' && c <= 'z')
 747           || (c >= 'A' && c <= 'Z')
 748           || c == '_'
 749           || c == '$');
 750 }
 751
 752 /* Lex an identifier.  */
 753
 754 int
 755 rust_parser::lex_identifier ()
 756 {
 757   unsigned int length;
 758   const struct token_info *token;
 759   int is_gdb_var = pstate->lexptr[0] == '$';
 760
 761   bool is_raw = false;
 762   if (pstate->lexptr[0] == 'r'
 763       && pstate->lexptr[1] == '#'
 764       && rust_identifier_start_p (pstate->lexptr[2]))
 765     {
 766       is_raw = true;
 767       pstate->lexptr += 2;
 768     }
 769
 770   const char *start = pstate->lexptr;
 771   gdb_assert (rust_identifier_start_p (pstate->lexptr[0]));
 772
 773   ++pstate->lexptr;
 774
 775   /* For the time being this doesn't handle Unicode rules.  Non-ASCII
 776      identifiers are gated anyway.  */
 777   while ((pstate->lexptr[0] >= 'a' && pstate->lexptr[0] <= 'z')
 778          || (pstate->lexptr[0] >= 'A' && pstate->lexptr[0] <= 'Z')
 779          || pstate->lexptr[0] == '_'
 780          || (is_gdb_var && pstate->lexptr[0] == '$')
 781          || (pstate->lexptr[0] >= '0' && pstate->lexptr[0] <= '9'))
 782     ++pstate->lexptr;
 783
 784
 785   length = pstate->lexptr - start;
 786   token = NULL;
 787   if (!is_raw)
 788     {
 789       for (const auto &candidate : identifier_tokens)
 790         {
 791           if (length == strlen (candidate.name)
 792               && strncmp (candidate.name, start, length) == 0)
 793             {
 794               token = &candidate;
 795               break;
 796             }
 797         }
 798     }
 799
 800   if (token != NULL)
 801     {
 802       if (token->value == 0)
 803         {
 804           /* Leave the terminating token alone.  */
 805           pstate->lexptr = start;
 806           return 0;
 807         }
 808     }
 809   else if (token == NULL
 810            && !is_raw
 811            && (strncmp (start, "thread", length) == 0
 812                || strncmp (start, "task", length) == 0)
 813            && space_then_number (pstate->lexptr))
 814     {
 815       /* "task" or "thread" followed by a number terminates the
 816          parse, per gdb rules.  */
 817       pstate->lexptr = start;
 818       return 0;
 819     }
 820
 821   if (token == NULL || (pstate->parse_completion && pstate->lexptr[0] == '\0'))
 822     {
 823       current_string_val.length = length;
 824       current_string_val.ptr = start;
 825     }
 826
 827   if (pstate->parse_completion && pstate->lexptr[0] == '\0')
 828     {
 829       /* Prevent rustyylex from returning two COMPLETE tokens.  */
 830       pstate->prev_lexptr = pstate->lexptr;
 831       return COMPLETE;
 832     }
 833
 834   if (token != NULL)
 835     return token->value;
 836   if (is_gdb_var)
 837     return GDBVAR;
 838   return IDENT;
 839 }
 840
 841 /* Lex an operator.  */
 842
 843 int
 844 rust_parser::lex_operator ()
 845 {
 846   const struct token_info *token = NULL;
 847
 848   for (const auto &candidate : operator_tokens)
 849     {
 850       if (strncmp (candidate.name, pstate->lexptr,
 851                    strlen (candidate.name)) == 0)
 852         {
 853           pstate->lexptr += strlen (candidate.name);
 854           token = &candidate;
 855           break;
 856         }
 857     }
 858
 859   if (token != NULL)
 860     {
 861       current_opcode = token->opcode;
 862       return token->value;
 863     }
 864
 865   return *pstate->lexptr++;
 866 }
 867
 868 /* Lex a number.  */
 869
 870 int
 871 rust_parser::lex_number ()
 872 {
 873   regmatch_t subexps[NUM_SUBEXPRESSIONS];
 874   int match;
 875   int is_integer = 0;
 876   int could_be_decimal = 1;
 877   int implicit_i32 = 0;
 878   const char *type_name = NULL;
 879   struct type *type;
 880   int end_index;
 881   int type_index = -1;
 882   int i;
 883
 884   match = regexec (&number_regex, pstate->lexptr, ARRAY_SIZE (subexps),
 885                    subexps, 0);
 886   /* Failure means the regexp is broken.  */
 887   gdb_assert (match == 0);
 888
 889   if (subexps[INT_TEXT].rm_so != -1)
 890     {
 891       /* Integer part matched.  */
 892       is_integer = 1;
 893       end_index = subexps[INT_TEXT].rm_eo;
 894       if (subexps[INT_TYPE].rm_so == -1)
 895         {
 896           type_name = "i32";
 897           implicit_i32 = 1;
 898         }
 899       else
 900         {
 901           type_index = INT_TYPE;
 902           could_be_decimal = 0;
 903         }
 904     }
 905   else if (subexps[FLOAT_TYPE1].rm_so != -1)
 906     {
 907       /* Found floating point type suffix.  */
 908       end_index = subexps[FLOAT_TYPE1].rm_so;
 909       type_index = FLOAT_TYPE1;
 910     }
 911   else if (subexps[FLOAT_TYPE2].rm_so != -1)
 912     {
 913       /* Found floating point type suffix.  */
 914       end_index = subexps[FLOAT_TYPE2].rm_so;
 915       type_index = FLOAT_TYPE2;
 916     }
 917   else
 918     {
 919       /* Any other floating point match.  */
 920       end_index = subexps[0].rm_eo;
 921       type_name = "f64";
 922     }
 923
 924   /* We need a special case if the final character is ".".  In this
 925      case we might need to parse an integer.  For example, "23.f()" is
 926      a request for a trait method call, not a syntax error involving
 927      the floating point number "23.".  */
 928   gdb_assert (subexps[0].rm_eo > 0);
 929   if (pstate->lexptr[subexps[0].rm_eo - 1] == '.')
 930     {
 931       const char *next = skip_spaces (&pstate->lexptr[subexps[0].rm_eo]);
 932
 933       if (rust_identifier_start_p (*next) || *next == '.')
 934         {
 935           --subexps[0].rm_eo;
 936           is_integer = 1;
 937           end_index = subexps[0].rm_eo;
 938           type_name = "i32";
 939           could_be_decimal = 1;
 940           implicit_i32 = 1;
 941         }
 942     }
 943
 944   /* Compute the type name if we haven't already.  */
 945   std::string type_name_holder;
 946   if (type_name == NULL)
 947     {
 948       gdb_assert (type_index != -1);
 949       type_name_holder = std::string ((pstate->lexptr
 950                                        + subexps[type_index].rm_so),
 951                                       (subexps[type_index].rm_eo
 952                                        - subexps[type_index].rm_so));
 953       type_name = type_name_holder.c_str ();
 954     }
 955
 956   /* Look up the type.  */
 957   type = get_type (type_name);
 958
 959   /* Copy the text of the number and remove the "_"s.  */
 960   std::string number;
 961   for (i = 0; i < end_index && pstate->lexptr[i]; ++i)
 962     {
 963       if (pstate->lexptr[i] == '_')
 964         could_be_decimal = 0;
 965       else
 966         number.push_back (pstate->lexptr[i]);
 967     }
 968
 969   /* Advance past the match.  */
 970   pstate->lexptr += subexps[0].rm_eo;
 971
 972   /* Parse the number.  */
 973   if (is_integer)
 974     {
 975       uint64_t value;
 976       int radix = 10;
 977       int offset = 0;
 978
 979       if (number[0] == '0')
 980         {
 981           if (number[1] == 'x')
 982             radix = 16;
 983           else if (number[1] == 'o')
 984             radix = 8;
 985           else if (number[1] == 'b')
 986             radix = 2;
 987           if (radix != 10)
 988             {
 989               offset = 2;
 990               could_be_decimal = 0;
 991             }
 992         }
 993
 994       value = strtoulst (number.c_str () + offset, NULL, radix);
 995       if (implicit_i32 && value >= ((uint64_t) 1) << 31)
 996         type = get_type ("i64");
 997
 998       current_int_val.val = value;
 999       current_int_val.type = type;
1000     }
1001   else
1002     {
1003       current_float_val.type = type;
1004       bool parsed = parse_float (number.c_str (), number.length (),
1005                                  current_float_val.type,
1006                                  current_float_val.val.data ());
1007       gdb_assert (parsed);
1008     }
1009
1010   return is_integer ? (could_be_decimal ? DECIMAL_INTEGER : INTEGER) : FLOAT;
1011 }
1012
1013 /* The lexer.  */
1014
1015 int
1016 rust_parser::lex_one_token ()
1017 {
1018   /* Skip all leading whitespace.  */
1019   while (pstate->lexptr[0] == ' '
1020          || pstate->lexptr[0] == '\t'
1021          || pstate->lexptr[0] == '\r'
1022          || pstate->lexptr[0] == '\n')
1023     ++pstate->lexptr;
1024
1025   /* If we hit EOF and we're completing, then return COMPLETE -- maybe
1026      we're completing an empty string at the end of a field_expr.
1027      But, we don't want to return two COMPLETE tokens in a row.  */
1028   if (pstate->lexptr[0] == '\0' && pstate->lexptr == pstate->prev_lexptr)
1029     return 0;
1030   pstate->prev_lexptr = pstate->lexptr;
1031   if (pstate->lexptr[0] == '\0')
1032     {
1033       if (pstate->parse_completion)
1034         {
1035           current_string_val.length =0;
1036           current_string_val.ptr = "";
1037           return COMPLETE;
1038         }
1039       return 0;
1040     }
1041
1042   if (pstate->lexptr[0] >= '0' && pstate->lexptr[0] <= '9')
1043     return lex_number ();
1044   else if (pstate->lexptr[0] == 'b' && pstate->lexptr[1] == '\'')
1045     return lex_character ();
1046   else if (pstate->lexptr[0] == 'b' && pstate->lexptr[1] == '"')
1047     return lex_string ();
1048   else if (pstate->lexptr[0] == 'b' && starts_raw_string (pstate->lexptr + 1))
1049     return lex_string ();
1050   else if (starts_raw_string (pstate->lexptr))
1051     return lex_string ();
1052   else if (rust_identifier_start_p (pstate->lexptr[0]))
1053     return lex_identifier ();
1054   else if (pstate->lexptr[0] == '"')
1055     return lex_string ();
1056   else if (pstate->lexptr[0] == '\'')
1057     return lex_character ();
1058   else if (pstate->lexptr[0] == '}' || pstate->lexptr[0] == ']')
1059     {
1060       /* Falls through to lex_operator.  */
1061       --paren_depth;
1062     }
1063   else if (pstate->lexptr[0] == '(' || pstate->lexptr[0] == '{')
1064     {
1065       /* Falls through to lex_operator.  */
1066       ++paren_depth;
1067     }
1068   else if (pstate->lexptr[0] == ',' && pstate->comma_terminates
1069            && paren_depth == 0)
1070     return 0;
1071
1072   return lex_operator ();
1073 }
1074
1075 /* Push back a single character to be re-lexed.  */
1076
1077 void
1078 rust_parser::push_back (char c)
1079 {
1080   /* Can't be called before any lexing.  */
1081   gdb_assert (pstate->prev_lexptr != NULL);
1082
1083   --pstate->lexptr;
1084   gdb_assert (*pstate->lexptr == c);
1085 }
1086
1087 \f
1088
1089 /* Parse a tuple or paren expression.  */
1090
1091 operation_up
1092 rust_parser::parse_tuple ()
1093 {
1094   assume ('(');
1095
1096   if (current_token == ')')
1097     {
1098       lex ();
1099       struct type *unit = get_type ("()");
1100       return make_operation<long_const_operation> (unit, 0);
1101     }
1102
1103   operation_up expr = parse_expr ();
1104   if (current_token == ')')
1105     {
1106       /* Parenthesized expression.  */
1107       lex ();
1108       return expr;
1109     }
1110
1111   std::vector<operation_up> ops;
1112   ops.push_back (std::move (expr));
1113   while (current_token != ')')
1114     {
1115       if (current_token != ',')
1116         error (_("',' or ')' expected"));
1117       lex ();
1118
1119       /* A trailing "," is ok.  */
1120       if (current_token != ')')
1121         ops.push_back (parse_expr ());
1122     }
1123
1124   assume (')');
1125
1126   error (_("Tuple expressions not supported yet"));
1127 }
1128
1129 /* Parse an array expression.  */
1130
1131 operation_up
1132 rust_parser::parse_array ()
1133 {
1134   assume ('[');
1135
1136   if (current_token == KW_MUT)
1137     lex ();
1138
1139   operation_up result;
1140   operation_up expr = parse_expr ();
1141   if (current_token == ';')
1142     {
1143       lex ();
1144       operation_up rhs = parse_expr ();
1145       result = make_operation<rust_array_operation> (std::move (expr),
1146                                                      std::move (rhs));
1147     }
1148   else if (current_token == ',')
1149     {
1150       std::vector<operation_up> ops;
1151       ops.push_back (std::move (expr));
1152       while (current_token != ']')
1153         {
1154           if (current_token != ',')
1155             error (_("',' or ']' expected"));
1156           lex ();
1157           ops.push_back (parse_expr ());
1158         }
1159       ops.shrink_to_fit ();
1160       int len = ops.size () - 1;
1161       result = make_operation<array_operation> (0, len, std::move (ops));
1162     }
1163   else if (current_token != ']')
1164     error (_("',', ';', or ']' expected"));
1165
1166   require (']');
1167
1168   return result;
1169 }
1170
1171 /* Turn a name into an operation.  */
1172
1173 operation_up
1174 rust_parser::name_to_operation (const std::string &name)
1175 {
1176   struct block_symbol sym = lookup_symbol (name.c_str (),
1177                                            pstate->expression_context_block,
1178                                            VAR_DOMAIN);
1179   if (sym.symbol != nullptr && SYMBOL_CLASS (sym.symbol) != LOC_TYPEDEF)
1180     return make_operation<var_value_operation> (sym);
1181
1182   struct type *type = nullptr;
1183
1184   if (sym.symbol != nullptr)
1185     {
1186       gdb_assert (SYMBOL_CLASS (sym.symbol) == LOC_TYPEDEF);
1187       type = SYMBOL_TYPE (sym.symbol);
1188     }
1189   if (type == nullptr)
1190     type = rust_lookup_type (name.c_str ());
1191   if (type == nullptr)
1192     error (_("No symbol '%s' in current context"), name.c_str ());
1193
1194   if (type->code () == TYPE_CODE_STRUCT && type->num_fields () == 0)
1195     {
1196       /* A unit-like struct.  */
1197       operation_up result (new rust_aggregate_operation (type, {}, {}));
1198       return result;
1199     }
1200   else
1201     return make_operation<type_operation> (type);
1202 }
1203
1204 /* Parse a struct expression.  */
1205
1206 operation_up
1207 rust_parser::parse_struct_expr (struct type *type)
1208 {
1209   assume ('{');
1210
1211   if (type->code () != TYPE_CODE_STRUCT
1212       || rust_tuple_type_p (type)
1213       || rust_tuple_struct_type_p (type))
1214     error (_("Struct expression applied to non-struct type"));
1215
1216   std::vector<std::pair<std::string, operation_up>> field_v;
1217   while (current_token != '}' && current_token != DOTDOT)
1218     {
1219       if (current_token != IDENT)
1220         error (_("'}', '..', or identifier expected"));
1221
1222       std::string name = get_string ();
1223       lex ();
1224
1225       operation_up expr;
1226       if (current_token == ',' || current_token == '}'
1227           || current_token == DOTDOT)
1228         expr = name_to_operation (name);
1229       else
1230         {
1231           require (':');
1232           expr = parse_expr ();
1233         }
1234       field_v.emplace_back (std::move (name), std::move (expr));
1235
1236       /* A trailing "," is ok.  */
1237       if (current_token == ',')
1238         lex ();
1239     }
1240
1241   operation_up others;
1242   if (current_token == DOTDOT)
1243     {
1244       lex ();
1245       others = parse_expr ();
1246     }
1247
1248   require ('}');
1249
1250   return make_operation<rust_aggregate_operation> (type,
1251                                                    std::move (others),
1252                                                    std::move (field_v));
1253 }
1254
1255 /* Used by the operator precedence parser.  */
1256 struct rustop_item
1257 {
1258   rustop_item (int token_, int precedence_, enum exp_opcode opcode_,
1259                operation_up &&op_)
1260     : token (token_),
1261       precedence (precedence_),
1262       opcode (opcode_),
1263       op (std::move (op_))
1264   {
1265   }
1266
1267   /* The token value.  */
1268   int token;
1269   /* Precedence of this operator.  */
1270   int precedence;
1271   /* This is used only for assign-modify.  */
1272   enum exp_opcode opcode;
1273   /* The right hand side of this operation.  */
1274   operation_up op;
1275 };
1276
1277 /* An operator precedence parser for binary operations, including
1278    "as".  */
1279
1280 operation_up
1281 rust_parser::parse_binop (bool required)
1282 {
1283   /* All the binary  operators.  Each one is of the form
1284      OPERATION(TOKEN, PRECEDENCE, TYPE)
1285      TOKEN is the corresponding operator token.
1286      PRECEDENCE is a value indicating relative precedence.
1287      TYPE is the operation type corresponding to the operator.
1288      Assignment operations are handled specially, not via this
1289      table; they have precedence 0.  */
1290 #define ALL_OPS                                 \
1291   OPERATION ('*', 10, mul_operation)            \
1292   OPERATION ('/', 10, div_operation)            \
1293   OPERATION ('%', 10, rem_operation)            \
1294   OPERATION ('@', 9, repeat_operation)          \
1295   OPERATION ('+', 8, add_operation)             \
1296   OPERATION ('-', 8, sub_operation)             \
1297   OPERATION (LSH, 7, lsh_operation)             \
1298   OPERATION (RSH, 7, rsh_operation)             \
1299   OPERATION ('&', 6, bitwise_and_operation)     \
1300   OPERATION ('^', 5, bitwise_xor_operation)     \
1301   OPERATION ('|', 4, bitwise_ior_operation)     \
1302   OPERATION (EQEQ, 3, equal_operation)          \
1303   OPERATION (NOTEQ, 3, notequal_operation)      \
1304   OPERATION ('<', 3, less_operation)            \
1305   OPERATION (LTEQ, 3, leq_operation)            \
1306   OPERATION ('>', 3, gtr_operation)             \
1307   OPERATION (GTEQ, 3, geq_operation)            \
1308   OPERATION (ANDAND, 2, logical_and_operation)  \
1309   OPERATION (OROR, 1, logical_or_operation)
1310
1311   operation_up start = parse_atom (required);
1312   if (start == nullptr)
1313     {
1314       gdb_assert (!required);
1315       return start;
1316     }
1317
1318   std::vector<rustop_item> operator_stack;
1319   operator_stack.emplace_back (0, -1, OP_NULL, std::move (start));
1320
1321   while (true)
1322     {
1323       int this_token = current_token;
1324       enum exp_opcode compound_assign_op = OP_NULL;
1325       int precedence = -2;
1326
1327       switch (this_token)
1328         {
1329 #define OPERATION(TOKEN, PRECEDENCE, TYPE)              \
1330           case TOKEN:                           \
1331             precedence = PRECEDENCE;            \
1332             lex ();                             \
1333             break;
1334
1335           ALL_OPS
1336
1337 #undef OPERATION
1338
1339         case COMPOUND_ASSIGN:
1340           compound_assign_op = current_opcode;
1341           /* FALLTHROUGH */
1342         case '=':
1343           precedence = 0;
1344           lex ();
1345           break;
1346
1347           /* "as" must be handled specially.  */
1348         case KW_AS:
1349           {
1350             lex ();
1351             rustop_item &lhs = operator_stack.back ();
1352             struct type *type = parse_type ();
1353             lhs.op = make_operation<unop_cast_operation> (std::move (lhs.op),
1354                                                           type);
1355           }
1356           /* Bypass the rest of the loop.  */
1357           continue;
1358
1359         default:
1360           /* Arrange to pop the entire stack.  */
1361           precedence = -2;
1362           break;
1363         }
1364
1365       while (precedence < operator_stack.back ().precedence
1366              && operator_stack.size () > 1)
1367         {
1368           rustop_item rhs = std::move (operator_stack.back ());
1369           operator_stack.pop_back ();
1370
1371           rustop_item &lhs = operator_stack.back ();
1372
1373           switch (rhs.token)
1374             {
1375 #define OPERATION(TOKEN, PRECEDENCE, TYPE)                      \
1376           case TOKEN:                                           \
1377             lhs.op = make_operation<TYPE> (std::move (lhs.op),  \
1378                                            std::move (rhs.op)); \
1379             break;
1380
1381               ALL_OPS
1382
1383 #undef OPERATION
1384
1385             case '=':
1386             case COMPOUND_ASSIGN:
1387               {
1388                 if (rhs.token == '=')
1389                   lhs.op = (make_operation<assign_operation>
1390                             (std::move (lhs.op), std::move (rhs.op)));
1391                 else
1392                   lhs.op = (make_operation<assign_modify_operation>
1393                             (rhs.opcode, std::move (lhs.op),
1394                              std::move (rhs.op)));
1395
1396                 struct type *unit_type = get_type ("()");
1397
1398                 operation_up nil (new long_const_operation (unit_type, 0));
1399                 lhs.op = (make_operation<comma_operation>
1400                           (std::move (lhs.op), std::move (nil)));
1401               }
1402               break;
1403
1404             default:
1405               gdb_assert_not_reached ("bad binary operator");
1406             }
1407         }
1408
1409       if (precedence == -2)
1410         break;
1411
1412       operator_stack.emplace_back (this_token, precedence, compound_assign_op,
1413                                    parse_atom (true));
1414     }
1415
1416   gdb_assert (operator_stack.size () == 1);
1417   return std::move (operator_stack[0].op);
1418 #undef ALL_OPS
1419 }
1420
1421 /* Parse a range expression.  */
1422
1423 operation_up
1424 rust_parser::parse_range ()
1425 {
1426   enum range_flag kind = (RANGE_HIGH_BOUND_DEFAULT
1427                           | RANGE_LOW_BOUND_DEFAULT);
1428
1429   operation_up lhs;
1430   if (current_token != DOTDOT && current_token != DOTDOTEQ)
1431     {
1432       lhs = parse_binop (true);
1433       kind &= ~RANGE_LOW_BOUND_DEFAULT;
1434     }
1435
1436   if (current_token == DOTDOT)
1437     kind |= RANGE_HIGH_BOUND_EXCLUSIVE;
1438   else if (current_token != DOTDOTEQ)
1439     return lhs;
1440   lex ();
1441
1442   /* A "..=" range requires a high bound, but otherwise it is
1443      optional.  */
1444   operation_up rhs = parse_binop ((kind & RANGE_HIGH_BOUND_EXCLUSIVE) == 0);
1445   if (rhs != nullptr)
1446     kind &= ~RANGE_HIGH_BOUND_DEFAULT;
1447
1448   return make_operation<rust_range_operation> (kind,
1449                                                std::move (lhs),
1450                                                std::move (rhs));
1451 }
1452
1453 /* Parse an expression.  */
1454
1455 operation_up
1456 rust_parser::parse_expr ()
1457 {
1458   return parse_range ();
1459 }
1460
1461 /* Parse a sizeof expression.  */
1462
1463 operation_up
1464 rust_parser::parse_sizeof ()
1465 {
1466   assume (KW_SIZEOF);
1467
1468   require ('(');
1469   operation_up result = make_operation<unop_sizeof_operation> (parse_expr ());
1470   require (')');
1471   return result;
1472 }
1473
1474 /* Parse an address-of operation.  */
1475
1476 operation_up
1477 rust_parser::parse_addr ()
1478 {
1479   assume ('&');
1480
1481   if (current_token == KW_MUT)
1482     lex ();
1483
1484   return make_operation<rust_unop_addr_operation> (parse_atom (true));
1485 }
1486
1487 /* Parse a field expression.  */
1488
1489 operation_up
1490 rust_parser::parse_field (operation_up &&lhs)
1491 {
1492   assume ('.');
1493
1494   operation_up result;
1495   switch (current_token)
1496     {
1497     case IDENT:
1498     case COMPLETE:
1499       {
1500         bool is_complete = current_token == COMPLETE;
1501         auto struct_op = new rust_structop (std::move (lhs), get_string ());
1502         lex ();
1503         if (is_complete)
1504           {
1505             completion_op.reset (struct_op);
1506             pstate->mark_struct_expression (struct_op);
1507             /* Throw to the outermost level of the parser.  */
1508             error (_("not really an error"));
1509           }
1510         result.reset (struct_op);
1511       }
1512       break;
1513
1514     case DECIMAL_INTEGER:
1515       result = make_operation<rust_struct_anon> (current_int_val.val,
1516                                                  std::move (lhs));
1517       lex ();
1518       break;
1519
1520     case INTEGER:
1521       error (_("'_' not allowed in integers in anonymous field references"));
1522
1523     default:
1524       error (_("field name expected"));
1525     }
1526
1527   return result;
1528 }
1529
1530 /* Parse an index expression.  */
1531
1532 operation_up
1533 rust_parser::parse_index (operation_up &&lhs)
1534 {
1535   assume ('[');
1536   operation_up rhs = parse_expr ();
1537   require (']');
1538
1539   return make_operation<rust_subscript_operation> (std::move (lhs),
1540                                                    std::move (rhs));
1541 }
1542
1543 /* Parse a sequence of comma-separated expressions in parens.  */
1544
1545 std::vector<operation_up>
1546 rust_parser::parse_paren_args ()
1547 {
1548   assume ('(');
1549
1550   std::vector<operation_up> args;
1551   while (current_token != ')')
1552     {
1553       if (!args.empty ())
1554         {
1555           if (current_token != ',')
1556             error (_("',' or ')' expected"));
1557           lex ();
1558         }
1559
1560       args.push_back (parse_expr ());
1561     }
1562
1563   assume (')');
1564
1565   return args;
1566 }
1567
1568 /* Parse the parenthesized part of a function call.  */
1569
1570 operation_up
1571 rust_parser::parse_call (operation_up &&lhs)
1572 {
1573   std::vector<operation_up> args = parse_paren_args ();
1574
1575   return make_operation<funcall_operation> (std::move (lhs),
1576                                             std::move (args));
1577 }
1578
1579 /* Parse a list of types.  */
1580
1581 std::vector<struct type *>
1582 rust_parser::parse_type_list ()
1583 {
1584   std::vector<struct type *> result;
1585   result.push_back (parse_type ());
1586   while (current_token == ',')
1587     {
1588       lex ();
1589       result.push_back (parse_type ());
1590     }
1591   return result;
1592 }
1593
1594 /* Parse a possibly-empty list of types, surrounded in parens.  */
1595
1596 std::vector<struct type *>
1597 rust_parser::parse_maybe_type_list ()
1598 {
1599   assume ('(');
1600   std::vector<struct type *> types;
1601   if (current_token != ')')
1602     types = parse_type_list ();
1603   require (')');
1604   return types;
1605 }
1606
1607 /* Parse an array type.  */
1608
1609 struct type *
1610 rust_parser::parse_array_type ()
1611 {
1612   assume ('[');
1613   struct type *elt_type = parse_type ();
1614   require (';');
1615
1616   if (current_token != INTEGER && current_token != DECIMAL_INTEGER)
1617     error (_("integer expected"));
1618   ULONGEST val = current_int_val.val;
1619   lex ();
1620   require (']');
1621
1622   return lookup_array_range_type (elt_type, 0, val - 1);
1623 }
1624
1625 /* Parse a slice type.  */
1626
1627 struct type *
1628 rust_parser::parse_slice_type ()
1629 {
1630   assume ('&');
1631
1632   bool is_slice = current_token == '[';
1633   if (is_slice)
1634     lex ();
1635
1636   struct type *target = parse_type ();
1637
1638   if (is_slice)
1639     {
1640       require (']');
1641       return rust_slice_type ("&[*gdb*]", target, get_type ("usize"));
1642     }
1643
1644   /* For now we treat &x and *x identically.  */
1645   return lookup_pointer_type (target);
1646 }
1647
1648 /* Parse a pointer type.  */
1649
1650 struct type *
1651 rust_parser::parse_pointer_type ()
1652 {
1653   assume ('*');
1654
1655   if (current_token == KW_MUT || current_token == KW_CONST)
1656     lex ();
1657
1658   struct type *target = parse_type ();
1659   /* For the time being we ignore mut/const.  */
1660   return lookup_pointer_type (target);
1661 }
1662
1663 /* Parse a function type.  */
1664
1665 struct type *
1666 rust_parser::parse_function_type ()
1667 {
1668   assume (KW_FN);
1669
1670   if (current_token != '(')
1671     error (_("'(' expected"));
1672
1673   std::vector<struct type *> types = parse_maybe_type_list ();
1674
1675   if (current_token != ARROW)
1676     error (_("'->' expected"));
1677   lex ();
1678
1679   struct type *result_type = parse_type ();
1680
1681   struct type **argtypes = nullptr;
1682   if (!types.empty ())
1683     argtypes = types.data ();
1684
1685   result_type = lookup_function_type_with_arguments (result_type,
1686                                                      types.size (),
1687                                                      argtypes);
1688   return lookup_pointer_type (result_type);
1689 }
1690
1691 /* Parse a tuple type.  */
1692
1693 struct type *
1694 rust_parser::parse_tuple_type ()
1695 {
1696   std::vector<struct type *> types = parse_maybe_type_list ();
1697
1698   auto_obstack obstack;
1699   obstack_1grow (&obstack, '(');
1700   for (int i = 0; i < types.size (); ++i)
1701     {
1702       std::string type_name = type_to_string (types[i]);
1703
1704       if (i > 0)
1705         obstack_1grow (&obstack, ',');
1706       obstack_grow_str (&obstack, type_name.c_str ());
1707     }
1708
1709   obstack_grow_str0 (&obstack, ")");
1710   const char *name = (const char *) obstack_finish (&obstack);
1711
1712   /* We don't allow creating new tuple types (yet), but we do allow
1713      looking up existing tuple types.  */
1714   struct type *result = rust_lookup_type (name);
1715   if (result == nullptr)
1716     error (_("could not find tuple type '%s'"), name);
1717
1718   return result;
1719 }
1720
1721 /* Parse a type.  */
1722
1723 struct type *
1724 rust_parser::parse_type ()
1725 {
1726   switch (current_token)
1727     {
1728     case '[':
1729       return parse_array_type ();
1730     case '&':
1731       return parse_slice_type ();
1732     case '*':
1733       return parse_pointer_type ();
1734     case KW_FN:
1735       return parse_function_type ();
1736     case '(':
1737       return parse_tuple_type ();
1738     case KW_SELF:
1739     case KW_SUPER:
1740     case COLONCOLON:
1741     case KW_EXTERN:
1742     case IDENT:
1743       {
1744         std::string path = parse_path (false);
1745         struct type *result = rust_lookup_type (path.c_str ());
1746         if (result == nullptr)
1747           error (_("No type name '%s' in current context"), path.c_str ());
1748         return result;
1749       }
1750     default:
1751       error (_("type expected"));
1752     }
1753 }
1754
1755 /* Parse a path.  */
1756
1757 std::string
1758 rust_parser::parse_path (bool for_expr)
1759 {
1760   unsigned n_supers = 0;
1761   int first_token = current_token;
1762
1763   switch (current_token)
1764     {
1765     case KW_SELF:
1766       lex ();
1767       if (current_token != COLONCOLON)
1768         return "self";
1769       lex ();
1770       /* FALLTHROUGH */
1771     case KW_SUPER:
1772       while (current_token == KW_SUPER)
1773         {
1774           ++n_supers;
1775           lex ();
1776           if (current_token != COLONCOLON)
1777             error (_("'::' expected"));
1778           lex ();
1779         }
1780       break;
1781
1782     case COLONCOLON:
1783       lex ();
1784       break;
1785
1786     case KW_EXTERN:
1787       /* This is a gdb extension to make it possible to refer to items
1788          in other crates.  It just bypasses adding the current crate
1789          to the front of the name.  */
1790       lex ();
1791       break;
1792     }
1793
1794   if (current_token != IDENT)
1795     error (_("identifier expected"));
1796   std::string path = get_string ();
1797   bool saw_ident = true;
1798   lex ();
1799
1800   /* The condition here lets us enter the loop even if we see
1801      "ident<...>".  */
1802   while (current_token == COLONCOLON || current_token == '<')
1803     {
1804       if (current_token == COLONCOLON)
1805         {
1806           lex ();
1807           saw_ident = false;
1808
1809           if (current_token == IDENT)
1810             {
1811               path = path + "::" + get_string ();
1812               lex ();
1813               saw_ident = true;
1814             }
1815           else if (current_token == COLONCOLON)
1816             {
1817               /* The code below won't detect this scenario.  */
1818               error (_("unexpected '::'"));
1819             }
1820         }
1821
1822       if (current_token != '<')
1823         continue;
1824
1825       /* Expression use name::<...>, whereas types use name<...>.  */
1826       if (for_expr)
1827         {
1828           /* Expressions use "name::<...>", so if we saw an identifier
1829              after the "::", we ignore the "<" here.  */
1830           if (saw_ident)
1831             break;
1832         }
1833       else
1834         {
1835           /* Types use "name<...>", so we need to have seen the
1836              identifier.  */
1837           if (!saw_ident)
1838             break;
1839         }
1840
1841       lex ();
1842       std::vector<struct type *> types = parse_type_list ();
1843       if (current_token == '>')
1844         lex ();
1845       else if (current_token == RSH)
1846         {
1847           push_back ('>');
1848           lex ();
1849         }
1850       else
1851         error (_("'>' expected"));
1852
1853       path += "<";
1854       for (int i = 0; i < types.size (); ++i)
1855         {
1856           if (i > 0)
1857             path += ",";
1858           path += type_to_string (types[i]);
1859         }
1860       path += ">";
1861       break;
1862     }
1863
1864   switch (first_token)
1865     {
1866     case KW_SELF:
1867     case KW_SUPER:
1868       return super_name (path, n_supers);
1869
1870     case COLONCOLON:
1871       return crate_name (path);
1872
1873     case KW_EXTERN:
1874       return "::" + path;
1875
1876     case IDENT:
1877       return path;
1878
1879     default:
1880       gdb_assert_not_reached ("missing case in path parsing");
1881     }
1882 }
1883
1884 /* Handle the parsing for a string expression.  */
1885
1886 operation_up
1887 rust_parser::parse_string ()
1888 {
1889   gdb_assert (current_token == STRING);
1890
1891   /* Wrap the raw string in the &str struct.  */
1892   struct type *type = rust_lookup_type ("&str");
1893   if (type == nullptr)
1894     error (_("Could not find type '&str'"));
1895
1896   std::vector<std::pair<std::string, operation_up>> field_v;
1897
1898   size_t len = current_string_val.length;
1899   operation_up str = make_operation<string_operation> (get_string ());
1900   operation_up addr
1901     = make_operation<rust_unop_addr_operation> (std::move (str));
1902   field_v.emplace_back ("data_ptr", std::move (addr));
1903
1904   struct type *valtype = get_type ("usize");
1905   operation_up lenop = make_operation<long_const_operation> (valtype, len);
1906   field_v.emplace_back ("length", std::move (lenop));
1907
1908   return make_operation<rust_aggregate_operation> (type,
1909                                                    operation_up (),
1910                                                    std::move (field_v));
1911 }
1912
1913 /* Parse a tuple struct expression.  */
1914
1915 operation_up
1916 rust_parser::parse_tuple_struct (struct type *type)
1917 {
1918   std::vector<operation_up> args = parse_paren_args ();
1919
1920   std::vector<std::pair<std::string, operation_up>> field_v (args.size ());
1921   for (int i = 0; i < args.size (); ++i)
1922     field_v[i] = { string_printf ("__%d", i), std::move (args[i]) };
1923
1924   return (make_operation<rust_aggregate_operation>
1925           (type, operation_up (), std::move (field_v)));
1926 }
1927
1928 /* Parse a path expression.  */
1929
1930 operation_up
1931 rust_parser::parse_path_expr ()
1932 {
1933   std::string path = parse_path (true);
1934
1935   if (current_token == '{')
1936     {
1937       struct type *type = rust_lookup_type (path.c_str ());
1938       if (type == nullptr)
1939         error (_("Could not find type '%s'"), path.c_str ());
1940
1941       return parse_struct_expr (type);
1942     }
1943   else if (current_token == '(')
1944     {
1945       struct type *type = rust_lookup_type (path.c_str ());
1946       /* If this is actually a tuple struct expression, handle it
1947          here.  If it is a call, it will be handled elsewhere.  */
1948       if (type != nullptr)
1949         {
1950           if (!rust_tuple_struct_type_p (type))
1951             error (_("Type %s is not a tuple struct"), path.c_str ());
1952           return parse_tuple_struct (type);
1953         }
1954     }
1955
1956   return name_to_operation (path);
1957 }
1958
1959 /* Parse an atom.  "Atom" isn't a Rust term, but this refers to a
1960    single unitary item in the grammar; but here including some unary
1961    prefix and postfix expressions.  */
1962
1963 operation_up
1964 rust_parser::parse_atom (bool required)
1965 {
1966   operation_up result;
1967
1968   switch (current_token)
1969     {
1970     case '(':
1971       result = parse_tuple ();
1972       break;
1973
1974     case '[':
1975       result = parse_array ();
1976       break;
1977
1978     case INTEGER:
1979     case DECIMAL_INTEGER:
1980       result = make_operation<long_const_operation> (current_int_val.type,
1981                                                      current_int_val.val);
1982       lex ();
1983       break;
1984
1985     case FLOAT:
1986       result = make_operation<float_const_operation> (current_float_val.type,
1987                                                       current_float_val.val);
1988       lex ();
1989       break;
1990
1991     case STRING:
1992       result = parse_string ();
1993       break;
1994
1995     case BYTESTRING:
1996       result = make_operation<string_operation> (get_string ());
1997       lex ();
1998       break;
1999
2000     case KW_TRUE:
2001     case KW_FALSE:
2002       result = make_operation<bool_operation> (current_token == KW_TRUE);
2003       lex ();
2004       break;
2005
2006     case GDBVAR:
2007       /* This is kind of a hacky approach.  */
2008       {
2009         pstate->push_dollar (current_string_val);
2010         result = pstate->pop ();
2011         lex ();
2012       }
2013       break;
2014
2015     case KW_SELF:
2016     case KW_SUPER:
2017     case COLONCOLON:
2018     case KW_EXTERN:
2019     case IDENT:
2020       result = parse_path_expr ();
2021       break;
2022
2023     case '*':
2024       lex ();
2025       result = make_operation<rust_unop_ind_operation> (parse_atom (true));
2026       break;
2027     case '+':
2028       lex ();
2029       result = make_operation<unary_plus_operation> (parse_atom (true));
2030       break;
2031     case '-':
2032       lex ();
2033       result = make_operation<unary_neg_operation> (parse_atom (true));
2034       break;
2035     case '!':
2036       lex ();
2037       result = make_operation<rust_unop_compl_operation> (parse_atom (true));
2038       break;
2039     case KW_SIZEOF:
2040       result = parse_sizeof ();
2041       break;
2042     case '&':
2043       result = parse_addr ();
2044       break;
2045
2046     default:
2047       if (!required)
2048         return {};
2049       error (_("unexpected token"));
2050     }
2051
2052   /* Now parse suffixes.  */
2053   while (true)
2054     {
2055       switch (current_token)
2056         {
2057         case '.':
2058           result = parse_field (std::move (result));
2059           break;
2060
2061         case '[':
2062           result = parse_index (std::move (result));
2063           break;
2064
2065         case '(':
2066           result = parse_call (std::move (result));
2067           break;
2068
2069         default:
2070           return result;
2071         }
2072     }
2073 }
2074
2075 \f
2076
2077 /* The parser as exposed to gdb.  */
2078
2079 int
2080 rust_language::parser (struct parser_state *state) const
2081 {
2082   rust_parser parser (state);
2083
2084   operation_up result;
2085   try
2086     {
2087       result = parser.parse_entry_point ();
2088     }
2089   catch (const gdb_exception &exc)
2090     {
2091       if (state->parse_completion)
2092         {
2093           result = std::move (parser.completion_op);
2094           if (result == nullptr)
2095             throw;
2096         }
2097       else
2098         throw;
2099     }
2100
2101   state->set_operation (std::move (result));
2102
2103   return 0;
2104 }
2105
2106 \f
2107
2108 #if GDB_SELF_TEST
2109
2110 /* A test helper that lexes a string, expecting a single token.  */
2111
2112 static void
2113 rust_lex_test_one (rust_parser *parser, const char *input, int expected)
2114 {
2115   int token;
2116
2117   parser->reset (input);
2118
2119   token = parser->lex_one_token ();
2120   SELF_CHECK (token == expected);
2121
2122   if (token)
2123     {
2124       token = parser->lex_one_token ();
2125       SELF_CHECK (token == 0);
2126     }
2127 }
2128
2129 /* Test that INPUT lexes as the integer VALUE.  */
2130
2131 static void
2132 rust_lex_int_test (rust_parser *parser, const char *input,
2133                    ULONGEST value, int kind)
2134 {
2135   rust_lex_test_one (parser, input, kind);
2136   SELF_CHECK (parser->current_int_val.val == value);
2137 }
2138
2139 /* Test that INPUT throws an exception with text ERR.  */
2140
2141 static void
2142 rust_lex_exception_test (rust_parser *parser, const char *input,
2143                          const char *err)
2144 {
2145   try
2146     {
2147       /* The "kind" doesn't matter.  */
2148       rust_lex_test_one (parser, input, DECIMAL_INTEGER);
2149       SELF_CHECK (0);
2150     }
2151   catch (const gdb_exception_error &except)
2152     {
2153       SELF_CHECK (strcmp (except.what (), err) == 0);
2154     }
2155 }
2156
2157 /* Test that INPUT lexes as the identifier, string, or byte-string
2158    VALUE.  KIND holds the expected token kind.  */
2159
2160 static void
2161 rust_lex_stringish_test (rust_parser *parser, const char *input,
2162                          const char *value, int kind)
2163 {
2164   rust_lex_test_one (parser, input, kind);
2165   SELF_CHECK (parser->get_string () == value);
2166 }
2167
2168 /* Helper to test that a string parses as a given token sequence.  */
2169
2170 static void
2171 rust_lex_test_sequence (rust_parser *parser, const char *input, int len,
2172                         const int expected[])
2173 {
2174   int i;
2175
2176   parser->reset (input);
2177
2178   for (i = 0; i < len; ++i)
2179     {
2180       int token = parser->lex_one_token ();
2181       SELF_CHECK (token == expected[i]);
2182     }
2183 }
2184
2185 /* Tests for an integer-parsing corner case.  */
2186
2187 static void
2188 rust_lex_test_trailing_dot (rust_parser *parser)
2189 {
2190   const int expected1[] = { DECIMAL_INTEGER, '.', IDENT, '(', ')', 0 };
2191   const int expected2[] = { INTEGER, '.', IDENT, '(', ')', 0 };
2192   const int expected3[] = { FLOAT, EQEQ, '(', ')', 0 };
2193   const int expected4[] = { DECIMAL_INTEGER, DOTDOT, DECIMAL_INTEGER, 0 };
2194
2195   rust_lex_test_sequence (parser, "23.g()", ARRAY_SIZE (expected1), expected1);
2196   rust_lex_test_sequence (parser, "23_0.g()", ARRAY_SIZE (expected2),
2197                           expected2);
2198   rust_lex_test_sequence (parser, "23.==()", ARRAY_SIZE (expected3),
2199                           expected3);
2200   rust_lex_test_sequence (parser, "23..25", ARRAY_SIZE (expected4), expected4);
2201 }
2202
2203 /* Tests of completion.  */
2204
2205 static void
2206 rust_lex_test_completion (rust_parser *parser)
2207 {
2208   const int expected[] = { IDENT, '.', COMPLETE, 0 };
2209
2210   parser->pstate->parse_completion = 1;
2211
2212   rust_lex_test_sequence (parser, "something.wha", ARRAY_SIZE (expected),
2213                           expected);
2214   rust_lex_test_sequence (parser, "something.", ARRAY_SIZE (expected),
2215                           expected);
2216
2217   parser->pstate->parse_completion = 0;
2218 }
2219
2220 /* Test pushback.  */
2221
2222 static void
2223 rust_lex_test_push_back (rust_parser *parser)
2224 {
2225   int token;
2226
2227   parser->reset (">>=");
2228
2229   token = parser->lex_one_token ();
2230   SELF_CHECK (token == COMPOUND_ASSIGN);
2231   SELF_CHECK (parser->current_opcode == BINOP_RSH);
2232
2233   parser->push_back ('=');
2234
2235   token = parser->lex_one_token ();
2236   SELF_CHECK (token == '=');
2237
2238   token = parser->lex_one_token ();
2239   SELF_CHECK (token == 0);
2240 }
2241
2242 /* Unit test the lexer.  */
2243
2244 static void
2245 rust_lex_tests (void)
2246 {
2247   /* Set up dummy "parser", so that rust_type works.  */
2248   struct parser_state ps (language_def (language_rust), target_gdbarch (),
2249                           nullptr, 0, 0, nullptr, 0, nullptr, false);
2250   rust_parser parser (&ps);
2251
2252   rust_lex_test_one (&parser, "", 0);
2253   rust_lex_test_one (&parser, "    \t  \n \r  ", 0);
2254   rust_lex_test_one (&parser, "thread 23", 0);
2255   rust_lex_test_one (&parser, "task 23", 0);
2256   rust_lex_test_one (&parser, "th 104", 0);
2257   rust_lex_test_one (&parser, "ta 97", 0);
2258
2259   rust_lex_int_test (&parser, "'z'", 'z', INTEGER);
2260   rust_lex_int_test (&parser, "'\\xff'", 0xff, INTEGER);
2261   rust_lex_int_test (&parser, "'\\u{1016f}'", 0x1016f, INTEGER);
2262   rust_lex_int_test (&parser, "b'z'", 'z', INTEGER);
2263   rust_lex_int_test (&parser, "b'\\xfe'", 0xfe, INTEGER);
2264   rust_lex_int_test (&parser, "b'\\xFE'", 0xfe, INTEGER);
2265   rust_lex_int_test (&parser, "b'\\xfE'", 0xfe, INTEGER);
2266
2267   /* Test all escapes in both modes.  */
2268   rust_lex_int_test (&parser, "'\\n'", '\n', INTEGER);
2269   rust_lex_int_test (&parser, "'\\r'", '\r', INTEGER);
2270   rust_lex_int_test (&parser, "'\\t'", '\t', INTEGER);
2271   rust_lex_int_test (&parser, "'\\\\'", '\\', INTEGER);
2272   rust_lex_int_test (&parser, "'\\0'", '\0', INTEGER);
2273   rust_lex_int_test (&parser, "'\\''", '\'', INTEGER);
2274   rust_lex_int_test (&parser, "'\\\"'", '"', INTEGER);
2275
2276   rust_lex_int_test (&parser, "b'\\n'", '\n', INTEGER);
2277   rust_lex_int_test (&parser, "b'\\r'", '\r', INTEGER);
2278   rust_lex_int_test (&parser, "b'\\t'", '\t', INTEGER);
2279   rust_lex_int_test (&parser, "b'\\\\'", '\\', INTEGER);
2280   rust_lex_int_test (&parser, "b'\\0'", '\0', INTEGER);
2281   rust_lex_int_test (&parser, "b'\\''", '\'', INTEGER);
2282   rust_lex_int_test (&parser, "b'\\\"'", '"', INTEGER);
2283
2284   rust_lex_exception_test (&parser, "'z", "Unterminated character literal");
2285   rust_lex_exception_test (&parser, "b'\\x0'", "Not enough hex digits seen");
2286   rust_lex_exception_test (&parser, "b'\\u{0}'",
2287                            "Unicode escape in byte literal");
2288   rust_lex_exception_test (&parser, "'\\x0'", "Not enough hex digits seen");
2289   rust_lex_exception_test (&parser, "'\\u0'", "Missing '{' in Unicode escape");
2290   rust_lex_exception_test (&parser, "'\\u{0", "Missing '}' in Unicode escape");
2291   rust_lex_exception_test (&parser, "'\\u{0000007}", "Overlong hex escape");
2292   rust_lex_exception_test (&parser, "'\\u{}", "Not enough hex digits seen");
2293   rust_lex_exception_test (&parser, "'\\Q'", "Invalid escape \\Q in literal");
2294   rust_lex_exception_test (&parser, "b'\\Q'", "Invalid escape \\Q in literal");
2295
2296   rust_lex_int_test (&parser, "23", 23, DECIMAL_INTEGER);
2297   rust_lex_int_test (&parser, "2_344__29", 234429, INTEGER);
2298   rust_lex_int_test (&parser, "0x1f", 0x1f, INTEGER);
2299   rust_lex_int_test (&parser, "23usize", 23, INTEGER);
2300   rust_lex_int_test (&parser, "23i32", 23, INTEGER);
2301   rust_lex_int_test (&parser, "0x1_f", 0x1f, INTEGER);
2302   rust_lex_int_test (&parser, "0b1_101011__", 0x6b, INTEGER);
2303   rust_lex_int_test (&parser, "0o001177i64", 639, INTEGER);
2304   rust_lex_int_test (&parser, "0x123456789u64", 0x123456789ull, INTEGER);
2305
2306   rust_lex_test_trailing_dot (&parser);
2307
2308   rust_lex_test_one (&parser, "23.", FLOAT);
2309   rust_lex_test_one (&parser, "23.99f32", FLOAT);
2310   rust_lex_test_one (&parser, "23e7", FLOAT);
2311   rust_lex_test_one (&parser, "23E-7", FLOAT);
2312   rust_lex_test_one (&parser, "23e+7", FLOAT);
2313   rust_lex_test_one (&parser, "23.99e+7f64", FLOAT);
2314   rust_lex_test_one (&parser, "23.82f32", FLOAT);
2315
2316   rust_lex_stringish_test (&parser, "hibob", "hibob", IDENT);
2317   rust_lex_stringish_test (&parser, "hibob__93", "hibob__93", IDENT);
2318   rust_lex_stringish_test (&parser, "thread", "thread", IDENT);
2319   rust_lex_stringish_test (&parser, "r#true", "true", IDENT);
2320
2321   const int expected1[] = { IDENT, DECIMAL_INTEGER, 0 };
2322   rust_lex_test_sequence (&parser, "r#thread 23", ARRAY_SIZE (expected1),
2323                           expected1);
2324   const int expected2[] = { IDENT, '#', 0 };
2325   rust_lex_test_sequence (&parser, "r#", ARRAY_SIZE (expected2), expected2);
2326
2327   rust_lex_stringish_test (&parser, "\"string\"", "string", STRING);
2328   rust_lex_stringish_test (&parser, "\"str\\ting\"", "str\ting", STRING);
2329   rust_lex_stringish_test (&parser, "\"str\\\"ing\"", "str\"ing", STRING);
2330   rust_lex_stringish_test (&parser, "r\"str\\ing\"", "str\\ing", STRING);
2331   rust_lex_stringish_test (&parser, "r#\"str\\ting\"#", "str\\ting", STRING);
2332   rust_lex_stringish_test (&parser, "r###\"str\\\"ing\"###", "str\\\"ing",
2333                            STRING);
2334
2335   rust_lex_stringish_test (&parser, "b\"string\"", "string", BYTESTRING);
2336   rust_lex_stringish_test (&parser, "b\"\x73tring\"", "string", BYTESTRING);
2337   rust_lex_stringish_test (&parser, "b\"str\\\"ing\"", "str\"ing", BYTESTRING);
2338   rust_lex_stringish_test (&parser, "br####\"\\x73tring\"####", "\\x73tring",
2339                            BYTESTRING);
2340
2341   for (const auto &candidate : identifier_tokens)
2342     rust_lex_test_one (&parser, candidate.name, candidate.value);
2343
2344   for (const auto &candidate : operator_tokens)
2345     rust_lex_test_one (&parser, candidate.name, candidate.value);
2346
2347   rust_lex_test_completion (&parser);
2348   rust_lex_test_push_back (&parser);
2349 }
2350
2351 #endif /* GDB_SELF_TEST */
2352
2353 \f
2354
2355 void _initialize_rust_exp ();
2356 void
2357 _initialize_rust_exp ()
2358 {
2359   int code = regcomp (&number_regex, number_regex_text, REG_EXTENDED);
2360   /* If the regular expression was incorrect, it was a programming
2361      error.  */
2362   gdb_assert (code == 0);
2363
2364 #if GDB_SELF_TEST
2365   selftests::register_test ("rust-lex", rust_lex_tests);
2366 #endif
2367 }