gdb/rust-parse.c

   1 /* Rust expression parsing for GDB, the GNU debugger.
   2
   3    Copyright (C) 2016-2021 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 "gdb_obstack.h"
  26 #include "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             convert_between_encodings ("UTF-32", "UTF-8", (gdb_byte *) &value,
 699                                        sizeof (value), sizeof (value),
 700                                        &obstack, translit_none);
 701         }
 702       else if (pstate->lexptr[0] == '\0')
 703         error (_("Unexpected EOF in string"));
 704       else
 705         {
 706           value = pstate->lexptr[0] & 0xff;
 707           if (is_byte && value > 127)
 708             error (_("Non-ASCII value in byte string"));
 709           obstack_1grow (&obstack, value);
 710           ++pstate->lexptr;
 711         }
 712     }
 713
 714   current_string_val.length = obstack_object_size (&obstack);
 715   current_string_val.ptr = (const char *) obstack_finish (&obstack);
 716   return is_byte ? BYTESTRING : STRING;
 717 }
 718
 719 /* Return true if STRING starts with whitespace followed by a digit.  */
 720
 721 static bool
 722 space_then_number (const char *string)
 723 {
 724   const char *p = string;
 725
 726   while (p[0] == ' ' || p[0] == '\t')
 727     ++p;
 728   if (p == string)
 729     return false;
 730
 731   return *p >= '0' && *p <= '9';
 732 }
 733
 734 /* Return true if C can start an identifier.  */
 735
 736 static bool
 737 rust_identifier_start_p (char c)
 738 {
 739   return ((c >= 'a' && c <= 'z')
 740           || (c >= 'A' && c <= 'Z')
 741           || c == '_'
 742           || c == '$');
 743 }
 744
 745 /* Lex an identifier.  */
 746
 747 int
 748 rust_parser::lex_identifier ()
 749 {
 750   const char *start = pstate->lexptr;
 751   unsigned int length;
 752   const struct token_info *token;
 753   int i;
 754   int is_gdb_var = pstate->lexptr[0] == '$';
 755
 756   gdb_assert (rust_identifier_start_p (pstate->lexptr[0]));
 757
 758   ++pstate->lexptr;
 759
 760   /* For the time being this doesn't handle Unicode rules.  Non-ASCII
 761      identifiers are gated anyway.  */
 762   while ((pstate->lexptr[0] >= 'a' && pstate->lexptr[0] <= 'z')
 763          || (pstate->lexptr[0] >= 'A' && pstate->lexptr[0] <= 'Z')
 764          || pstate->lexptr[0] == '_'
 765          || (is_gdb_var && pstate->lexptr[0] == '$')
 766          || (pstate->lexptr[0] >= '0' && pstate->lexptr[0] <= '9'))
 767     ++pstate->lexptr;
 768
 769
 770   length = pstate->lexptr - start;
 771   token = NULL;
 772   for (i = 0; i < ARRAY_SIZE (identifier_tokens); ++i)
 773     {
 774       if (length == strlen (identifier_tokens[i].name)
 775           && strncmp (identifier_tokens[i].name, start, length) == 0)
 776         {
 777           token = &identifier_tokens[i];
 778           break;
 779         }
 780     }
 781
 782   if (token != NULL)
 783     {
 784       if (token->value == 0)
 785         {
 786           /* Leave the terminating token alone.  */
 787           pstate->lexptr = start;
 788           return 0;
 789         }
 790     }
 791   else if (token == NULL
 792            && (strncmp (start, "thread", length) == 0
 793                || strncmp (start, "task", length) == 0)
 794            && space_then_number (pstate->lexptr))
 795     {
 796       /* "task" or "thread" followed by a number terminates the
 797          parse, per gdb rules.  */
 798       pstate->lexptr = start;
 799       return 0;
 800     }
 801
 802   if (token == NULL || (pstate->parse_completion && pstate->lexptr[0] == '\0'))
 803     {
 804       current_string_val.length = length;
 805       current_string_val.ptr = start;
 806     }
 807
 808   if (pstate->parse_completion && pstate->lexptr[0] == '\0')
 809     {
 810       /* Prevent rustyylex from returning two COMPLETE tokens.  */
 811       pstate->prev_lexptr = pstate->lexptr;
 812       return COMPLETE;
 813     }
 814
 815   if (token != NULL)
 816     return token->value;
 817   if (is_gdb_var)
 818     return GDBVAR;
 819   return IDENT;
 820 }
 821
 822 /* Lex an operator.  */
 823
 824 int
 825 rust_parser::lex_operator ()
 826 {
 827   const struct token_info *token = NULL;
 828   int i;
 829
 830   for (i = 0; i < ARRAY_SIZE (operator_tokens); ++i)
 831     {
 832       if (strncmp (operator_tokens[i].name, pstate->lexptr,
 833                    strlen (operator_tokens[i].name)) == 0)
 834         {
 835           pstate->lexptr += strlen (operator_tokens[i].name);
 836           token = &operator_tokens[i];
 837           break;
 838         }
 839     }
 840
 841   if (token != NULL)
 842     {
 843       current_opcode = token->opcode;
 844       return token->value;
 845     }
 846
 847   return *pstate->lexptr++;
 848 }
 849
 850 /* Lex a number.  */
 851
 852 int
 853 rust_parser::lex_number ()
 854 {
 855   regmatch_t subexps[NUM_SUBEXPRESSIONS];
 856   int match;
 857   int is_integer = 0;
 858   int could_be_decimal = 1;
 859   int implicit_i32 = 0;
 860   const char *type_name = NULL;
 861   struct type *type;
 862   int end_index;
 863   int type_index = -1;
 864   int i;
 865
 866   match = regexec (&number_regex, pstate->lexptr, ARRAY_SIZE (subexps),
 867                    subexps, 0);
 868   /* Failure means the regexp is broken.  */
 869   gdb_assert (match == 0);
 870
 871   if (subexps[INT_TEXT].rm_so != -1)
 872     {
 873       /* Integer part matched.  */
 874       is_integer = 1;
 875       end_index = subexps[INT_TEXT].rm_eo;
 876       if (subexps[INT_TYPE].rm_so == -1)
 877         {
 878           type_name = "i32";
 879           implicit_i32 = 1;
 880         }
 881       else
 882         {
 883           type_index = INT_TYPE;
 884           could_be_decimal = 0;
 885         }
 886     }
 887   else if (subexps[FLOAT_TYPE1].rm_so != -1)
 888     {
 889       /* Found floating point type suffix.  */
 890       end_index = subexps[FLOAT_TYPE1].rm_so;
 891       type_index = FLOAT_TYPE1;
 892     }
 893   else if (subexps[FLOAT_TYPE2].rm_so != -1)
 894     {
 895       /* Found floating point type suffix.  */
 896       end_index = subexps[FLOAT_TYPE2].rm_so;
 897       type_index = FLOAT_TYPE2;
 898     }
 899   else
 900     {
 901       /* Any other floating point match.  */
 902       end_index = subexps[0].rm_eo;
 903       type_name = "f64";
 904     }
 905
 906   /* We need a special case if the final character is ".".  In this
 907      case we might need to parse an integer.  For example, "23.f()" is
 908      a request for a trait method call, not a syntax error involving
 909      the floating point number "23.".  */
 910   gdb_assert (subexps[0].rm_eo > 0);
 911   if (pstate->lexptr[subexps[0].rm_eo - 1] == '.')
 912     {
 913       const char *next = skip_spaces (&pstate->lexptr[subexps[0].rm_eo]);
 914
 915       if (rust_identifier_start_p (*next) || *next == '.')
 916         {
 917           --subexps[0].rm_eo;
 918           is_integer = 1;
 919           end_index = subexps[0].rm_eo;
 920           type_name = "i32";
 921           could_be_decimal = 1;
 922           implicit_i32 = 1;
 923         }
 924     }
 925
 926   /* Compute the type name if we haven't already.  */
 927   std::string type_name_holder;
 928   if (type_name == NULL)
 929     {
 930       gdb_assert (type_index != -1);
 931       type_name_holder = std::string ((pstate->lexptr
 932                                        + subexps[type_index].rm_so),
 933                                       (subexps[type_index].rm_eo
 934                                        - subexps[type_index].rm_so));
 935       type_name = type_name_holder.c_str ();
 936     }
 937
 938   /* Look up the type.  */
 939   type = get_type (type_name);
 940
 941   /* Copy the text of the number and remove the "_"s.  */
 942   std::string number;
 943   for (i = 0; i < end_index && pstate->lexptr[i]; ++i)
 944     {
 945       if (pstate->lexptr[i] == '_')
 946         could_be_decimal = 0;
 947       else
 948         number.push_back (pstate->lexptr[i]);
 949     }
 950
 951   /* Advance past the match.  */
 952   pstate->lexptr += subexps[0].rm_eo;
 953
 954   /* Parse the number.  */
 955   if (is_integer)
 956     {
 957       uint64_t value;
 958       int radix = 10;
 959       int offset = 0;
 960
 961       if (number[0] == '0')
 962         {
 963           if (number[1] == 'x')
 964             radix = 16;
 965           else if (number[1] == 'o')
 966             radix = 8;
 967           else if (number[1] == 'b')
 968             radix = 2;
 969           if (radix != 10)
 970             {
 971               offset = 2;
 972               could_be_decimal = 0;
 973             }
 974         }
 975
 976       value = strtoulst (number.c_str () + offset, NULL, radix);
 977       if (implicit_i32 && value >= ((uint64_t) 1) << 31)
 978         type = get_type ("i64");
 979
 980       current_int_val.val = value;
 981       current_int_val.type = type;
 982     }
 983   else
 984     {
 985       current_float_val.type = type;
 986       bool parsed = parse_float (number.c_str (), number.length (),
 987                                  current_float_val.type,
 988                                  current_float_val.val.data ());
 989       gdb_assert (parsed);
 990     }
 991
 992   return is_integer ? (could_be_decimal ? DECIMAL_INTEGER : INTEGER) : FLOAT;
 993 }
 994
 995 /* The lexer.  */
 996
 997 int
 998 rust_parser::lex_one_token ()
 999 {
1000   /* Skip all leading whitespace.  */
1001   while (pstate->lexptr[0] == ' '
1002          || pstate->lexptr[0] == '\t'
1003          || pstate->lexptr[0] == '\r'
1004          || pstate->lexptr[0] == '\n')
1005     ++pstate->lexptr;
1006
1007   /* If we hit EOF and we're completing, then return COMPLETE -- maybe
1008      we're completing an empty string at the end of a field_expr.
1009      But, we don't want to return two COMPLETE tokens in a row.  */
1010   if (pstate->lexptr[0] == '\0' && pstate->lexptr == pstate->prev_lexptr)
1011     return 0;
1012   pstate->prev_lexptr = pstate->lexptr;
1013   if (pstate->lexptr[0] == '\0')
1014     {
1015       if (pstate->parse_completion)
1016         {
1017           current_string_val.length =0;
1018           current_string_val.ptr = "";
1019           return COMPLETE;
1020         }
1021       return 0;
1022     }
1023
1024   if (pstate->lexptr[0] >= '0' && pstate->lexptr[0] <= '9')
1025     return lex_number ();
1026   else if (pstate->lexptr[0] == 'b' && pstate->lexptr[1] == '\'')
1027     return lex_character ();
1028   else if (pstate->lexptr[0] == 'b' && pstate->lexptr[1] == '"')
1029     return lex_string ();
1030   else if (pstate->lexptr[0] == 'b' && starts_raw_string (pstate->lexptr + 1))
1031     return lex_string ();
1032   else if (starts_raw_string (pstate->lexptr))
1033     return lex_string ();
1034   else if (rust_identifier_start_p (pstate->lexptr[0]))
1035     return lex_identifier ();
1036   else if (pstate->lexptr[0] == '"')
1037     return lex_string ();
1038   else if (pstate->lexptr[0] == '\'')
1039     return lex_character ();
1040   else if (pstate->lexptr[0] == '}' || pstate->lexptr[0] == ']')
1041     {
1042       /* Falls through to lex_operator.  */
1043       --paren_depth;
1044     }
1045   else if (pstate->lexptr[0] == '(' || pstate->lexptr[0] == '{')
1046     {
1047       /* Falls through to lex_operator.  */
1048       ++paren_depth;
1049     }
1050   else if (pstate->lexptr[0] == ',' && pstate->comma_terminates
1051            && paren_depth == 0)
1052     return 0;
1053
1054   return lex_operator ();
1055 }
1056
1057 /* Push back a single character to be re-lexed.  */
1058
1059 void
1060 rust_parser::push_back (char c)
1061 {
1062   /* Can't be called before any lexing.  */
1063   gdb_assert (pstate->prev_lexptr != NULL);
1064
1065   --pstate->lexptr;
1066   gdb_assert (*pstate->lexptr == c);
1067 }
1068
1069 \f
1070
1071 /* Parse a tuple or paren expression.  */
1072
1073 operation_up
1074 rust_parser::parse_tuple ()
1075 {
1076   assume ('(');
1077
1078   if (current_token == ')')
1079     {
1080       lex ();
1081       struct type *unit = get_type ("()");
1082       return make_operation<long_const_operation> (unit, 0);
1083     }
1084
1085   operation_up expr = parse_expr ();
1086   if (current_token == ')')
1087     {
1088       /* Parenthesized expression.  */
1089       lex ();
1090       return expr;
1091     }
1092
1093   std::vector<operation_up> ops;
1094   ops.push_back (std::move (expr));
1095   while (current_token != ')')
1096     {
1097       if (current_token != ',')
1098         error (_("',' or ')' expected"));
1099       lex ();
1100
1101       /* A trailing "," is ok.  */
1102       if (current_token != ')')
1103         ops.push_back (parse_expr ());
1104     }
1105
1106   assume (')');
1107
1108   error (_("Tuple expressions not supported yet"));
1109 }
1110
1111 /* Parse an array expression.  */
1112
1113 operation_up
1114 rust_parser::parse_array ()
1115 {
1116   assume ('[');
1117
1118   if (current_token == KW_MUT)
1119     lex ();
1120
1121   operation_up result;
1122   operation_up expr = parse_expr ();
1123   if (current_token == ';')
1124     {
1125       lex ();
1126       operation_up rhs = parse_expr ();
1127       result = make_operation<rust_array_operation> (std::move (expr),
1128                                                      std::move (rhs));
1129     }
1130   else if (current_token == ',')
1131     {
1132       std::vector<operation_up> ops;
1133       ops.push_back (std::move (expr));
1134       while (current_token != ']')
1135         {
1136           if (current_token != ',')
1137             error (_("',' or ']' expected"));
1138           lex ();
1139           ops.push_back (parse_expr ());
1140         }
1141       ops.shrink_to_fit ();
1142       int len = ops.size () - 1;
1143       result = make_operation<array_operation> (0, len, std::move (ops));
1144     }
1145   else if (current_token != ']')
1146     error (_("',', ';', or ']' expected"));
1147
1148   require (']');
1149
1150   return result;
1151 }
1152
1153 /* Turn a name into an operation.  */
1154
1155 operation_up
1156 rust_parser::name_to_operation (const std::string &name)
1157 {
1158   struct block_symbol sym = lookup_symbol (name.c_str (),
1159                                            pstate->expression_context_block,
1160                                            VAR_DOMAIN);
1161   if (sym.symbol != nullptr && SYMBOL_CLASS (sym.symbol) != LOC_TYPEDEF)
1162     return make_operation<var_value_operation> (sym);
1163
1164   struct type *type = nullptr;
1165
1166   if (sym.symbol != nullptr)
1167     {
1168       gdb_assert (SYMBOL_CLASS (sym.symbol) == LOC_TYPEDEF);
1169       type = SYMBOL_TYPE (sym.symbol);
1170     }
1171   if (type == nullptr)
1172     type = rust_lookup_type (name.c_str ());
1173   if (type == nullptr)
1174     error (_("No symbol '%s' in current context"), name.c_str ());
1175
1176   if (type->code () == TYPE_CODE_STRUCT && type->num_fields () == 0)
1177     {
1178       /* A unit-like struct.  */
1179       operation_up result (new rust_aggregate_operation (type, {}, {}));
1180       return result;
1181     }
1182   else
1183     return make_operation<type_operation> (type);
1184 }
1185
1186 /* Parse a struct expression.  */
1187
1188 operation_up
1189 rust_parser::parse_struct_expr (struct type *type)
1190 {
1191   assume ('{');
1192
1193   if (type->code () != TYPE_CODE_STRUCT
1194       || rust_tuple_type_p (type)
1195       || rust_tuple_struct_type_p (type))
1196     error (_("Struct expression applied to non-struct type"));
1197
1198   std::vector<std::pair<std::string, operation_up>> field_v;
1199   while (current_token != '}' && current_token != DOTDOT)
1200     {
1201       if (current_token != IDENT)
1202         error (_("'}', '..', or identifier expected"));
1203
1204       std::string name = get_string ();
1205       lex ();
1206
1207       operation_up expr;
1208       if (current_token == ',' || current_token == '}'
1209           || current_token == DOTDOT)
1210         expr = name_to_operation (name);
1211       else
1212         {
1213           require (':');
1214           expr = parse_expr ();
1215         }
1216       field_v.emplace_back (std::move (name), std::move (expr));
1217
1218       /* A trailing "," is ok.  */
1219       if (current_token == ',')
1220         lex ();
1221     }
1222
1223   operation_up others;
1224   if (current_token == DOTDOT)
1225     {
1226       lex ();
1227       others = parse_expr ();
1228     }
1229
1230   require ('}');
1231
1232   return make_operation<rust_aggregate_operation> (type,
1233                                                    std::move (others),
1234                                                    std::move (field_v));
1235 }
1236
1237 /* Used by the operator precedence parser.  */
1238 struct rustop_item
1239 {
1240   rustop_item (int token_, int precedence_, enum exp_opcode opcode_,
1241                operation_up &&op_)
1242     : token (token_),
1243       precedence (precedence_),
1244       opcode (opcode_),
1245       op (std::move (op_))
1246   {
1247   }
1248
1249   /* The token value.  */
1250   int token;
1251   /* Precedence of this operator.  */
1252   int precedence;
1253   /* This is used only for assign-modify.  */
1254   enum exp_opcode opcode;
1255   /* The right hand side of this operation.  */
1256   operation_up op;
1257 };
1258
1259 /* An operator precedence parser for binary operations, including
1260    "as".  */
1261
1262 operation_up
1263 rust_parser::parse_binop (bool required)
1264 {
1265   /* All the binary  operators.  Each one is of the form
1266      OPERATION(TOKEN, PRECEDENCE, TYPE)
1267      TOKEN is the corresponding operator token.
1268      PRECEDENCE is a value indicating relative precedence.
1269      TYPE is the operation type corresponding to the operator.
1270      Assignment operations are handled specially, not via this
1271      table; they have precedence 0.  */
1272 #define ALL_OPS                                 \
1273   OPERATION ('*', 10, mul_operation)            \
1274   OPERATION ('/', 10, div_operation)            \
1275   OPERATION ('%', 10, rem_operation)            \
1276   OPERATION ('@', 9, repeat_operation)          \
1277   OPERATION ('+', 8, add_operation)             \
1278   OPERATION ('-', 8, sub_operation)             \
1279   OPERATION (LSH, 7, lsh_operation)             \
1280   OPERATION (RSH, 7, rsh_operation)             \
1281   OPERATION ('&', 6, bitwise_and_operation)     \
1282   OPERATION ('^', 5, bitwise_xor_operation)     \
1283   OPERATION ('|', 4, bitwise_ior_operation)     \
1284   OPERATION (EQEQ, 3, equal_operation)          \
1285   OPERATION (NOTEQ, 3, notequal_operation)      \
1286   OPERATION ('<', 3, less_operation)            \
1287   OPERATION (LTEQ, 3, leq_operation)            \
1288   OPERATION ('>', 3, gtr_operation)             \
1289   OPERATION (GTEQ, 3, geq_operation)            \
1290   OPERATION (ANDAND, 2, logical_and_operation)  \
1291   OPERATION (OROR, 1, logical_or_operation)
1292
1293   operation_up start = parse_atom (required);
1294   if (start == nullptr)
1295     {
1296       gdb_assert (!required);
1297       return start;
1298     }
1299
1300   std::vector<rustop_item> operator_stack;
1301   operator_stack.emplace_back (0, -1, OP_NULL, std::move (start));
1302
1303   while (true)
1304     {
1305       int this_token = current_token;
1306       enum exp_opcode compound_assign_op = OP_NULL;
1307       int precedence = -2;
1308
1309       switch (this_token)
1310         {
1311 #define OPERATION(TOKEN, PRECEDENCE, TYPE)              \
1312           case TOKEN:                           \
1313             precedence = PRECEDENCE;            \
1314             lex ();                             \
1315             break;
1316
1317           ALL_OPS
1318
1319 #undef OPERATION
1320
1321         case COMPOUND_ASSIGN:
1322           compound_assign_op = current_opcode;
1323           /* FALLTHROUGH */
1324         case '=':
1325           precedence = 0;
1326           lex ();
1327           break;
1328
1329           /* "as" must be handled specially.  */
1330         case KW_AS:
1331           {
1332             lex ();
1333             rustop_item &lhs = operator_stack.back ();
1334             struct type *type = parse_type ();
1335             lhs.op = make_operation<unop_cast_operation> (std::move (lhs.op),
1336                                                           type);
1337           }
1338           /* Bypass the rest of the loop.  */
1339           continue;
1340
1341         default:
1342           /* Arrange to pop the entire stack.  */
1343           precedence = -2;
1344           break;
1345         }
1346
1347       while (precedence < operator_stack.back ().precedence
1348              && operator_stack.size () > 1)
1349         {
1350           rustop_item rhs = std::move (operator_stack.back ());
1351           operator_stack.pop_back ();
1352
1353           rustop_item &lhs = operator_stack.back ();
1354
1355           switch (rhs.token)
1356             {
1357 #define OPERATION(TOKEN, PRECEDENCE, TYPE)                      \
1358           case TOKEN:                                           \
1359             lhs.op = make_operation<TYPE> (std::move (lhs.op),  \
1360                                            std::move (rhs.op)); \
1361             break;
1362
1363               ALL_OPS
1364
1365 #undef OPERATION
1366
1367             case '=':
1368             case COMPOUND_ASSIGN:
1369               {
1370                 if (rhs.token == '=')
1371                   lhs.op = (make_operation<assign_operation>
1372                             (std::move (lhs.op), std::move (rhs.op)));
1373                 else
1374                   lhs.op = (make_operation<assign_modify_operation>
1375                             (rhs.opcode, std::move (lhs.op),
1376                              std::move (rhs.op)));
1377
1378                 struct type *unit_type = get_type ("()");
1379
1380                 operation_up nil (new long_const_operation (unit_type, 0));
1381                 lhs.op = (make_operation<comma_operation>
1382                           (std::move (lhs.op), std::move (nil)));
1383               }
1384               break;
1385
1386             default:
1387               gdb_assert_not_reached ("bad binary operator");
1388             }
1389         }
1390
1391       if (precedence == -2)
1392         break;
1393
1394       operator_stack.emplace_back (this_token, precedence, compound_assign_op,
1395                                    parse_atom (true));
1396     }
1397
1398   gdb_assert (operator_stack.size () == 1);
1399   return std::move (operator_stack[0].op);
1400 #undef ALL_OPS
1401 }
1402
1403 /* Parse a range expression.  */
1404
1405 operation_up
1406 rust_parser::parse_range ()
1407 {
1408   enum range_flag kind = (RANGE_HIGH_BOUND_DEFAULT
1409                           | RANGE_LOW_BOUND_DEFAULT);
1410
1411   operation_up lhs;
1412   if (current_token != DOTDOT && current_token != DOTDOTEQ)
1413     {
1414       lhs = parse_binop (true);
1415       kind &= ~RANGE_LOW_BOUND_DEFAULT;
1416     }
1417
1418   if (current_token == DOTDOT)
1419     kind |= RANGE_HIGH_BOUND_EXCLUSIVE;
1420   else if (current_token != DOTDOTEQ)
1421     return lhs;
1422   lex ();
1423
1424   /* A "..=" range requires a high bound, but otherwise it is
1425      optional.  */
1426   operation_up rhs = parse_binop ((kind & RANGE_HIGH_BOUND_EXCLUSIVE) == 0);
1427   if (rhs != nullptr)
1428     kind &= ~RANGE_HIGH_BOUND_DEFAULT;
1429
1430   return make_operation<rust_range_operation> (kind,
1431                                                std::move (lhs),
1432                                                std::move (rhs));
1433 }
1434
1435 /* Parse an expression.  */
1436
1437 operation_up
1438 rust_parser::parse_expr ()
1439 {
1440   return parse_range ();
1441 }
1442
1443 /* Parse a sizeof expression.  */
1444
1445 operation_up
1446 rust_parser::parse_sizeof ()
1447 {
1448   assume (KW_SIZEOF);
1449
1450   require ('(');
1451   operation_up result = make_operation<unop_sizeof_operation> (parse_expr ());
1452   require (')');
1453   return result;
1454 }
1455
1456 /* Parse an address-of operation.  */
1457
1458 operation_up
1459 rust_parser::parse_addr ()
1460 {
1461   assume ('&');
1462
1463   if (current_token == KW_MUT)
1464     lex ();
1465
1466   return make_operation<rust_unop_addr_operation> (parse_atom (true));
1467 }
1468
1469 /* Parse a field expression.  */
1470
1471 operation_up
1472 rust_parser::parse_field (operation_up &&lhs)
1473 {
1474   assume ('.');
1475
1476   operation_up result;
1477   switch (current_token)
1478     {
1479     case IDENT:
1480     case COMPLETE:
1481       {
1482         bool is_complete = current_token == COMPLETE;
1483         auto struct_op = new rust_structop (std::move (lhs), get_string ());
1484         lex ();
1485         if (is_complete)
1486           {
1487             completion_op.reset (struct_op);
1488             pstate->mark_struct_expression (struct_op);
1489             /* Throw to the outermost level of the parser.  */
1490             error (_("not really an error"));
1491           }
1492         result.reset (struct_op);
1493       }
1494       break;
1495
1496     case DECIMAL_INTEGER:
1497       result = make_operation<rust_struct_anon> (current_int_val.val,
1498                                                  std::move (lhs));
1499       lex ();
1500       break;
1501
1502     case INTEGER:
1503       error (_("'_' not allowed in integers in anonymous field references"));
1504
1505     default:
1506       error (_("field name expected"));
1507     }
1508
1509   return result;
1510 }
1511
1512 /* Parse an index expression.  */
1513
1514 operation_up
1515 rust_parser::parse_index (operation_up &&lhs)
1516 {
1517   assume ('[');
1518   operation_up rhs = parse_expr ();
1519   require (']');
1520
1521   return make_operation<rust_subscript_operation> (std::move (lhs),
1522                                                    std::move (rhs));
1523 }
1524
1525 /* Parse a sequence of comma-separated expressions in parens.  */
1526
1527 std::vector<operation_up>
1528 rust_parser::parse_paren_args ()
1529 {
1530   assume ('(');
1531
1532   std::vector<operation_up> args;
1533   while (current_token != ')')
1534     {
1535       if (!args.empty ())
1536         {
1537           if (current_token != ',')
1538             error (_("',' or ')' expected"));
1539           lex ();
1540         }
1541
1542       args.push_back (parse_expr ());
1543     }
1544
1545   assume (')');
1546
1547   return args;
1548 }
1549
1550 /* Parse the parenthesized part of a function call.  */
1551
1552 operation_up
1553 rust_parser::parse_call (operation_up &&lhs)
1554 {
1555   std::vector<operation_up> args = parse_paren_args ();
1556
1557   return make_operation<funcall_operation> (std::move (lhs),
1558                                             std::move (args));
1559 }
1560
1561 /* Parse a list of types.  */
1562
1563 std::vector<struct type *>
1564 rust_parser::parse_type_list ()
1565 {
1566   std::vector<struct type *> result;
1567   result.push_back (parse_type ());
1568   while (current_token == ',')
1569     {
1570       lex ();
1571       result.push_back (parse_type ());
1572     }
1573   return result;
1574 }
1575
1576 /* Parse a possibly-empty list of types, surrounded in parens.  */
1577
1578 std::vector<struct type *>
1579 rust_parser::parse_maybe_type_list ()
1580 {
1581   assume ('(');
1582   std::vector<struct type *> types;
1583   if (current_token != ')')
1584     types = parse_type_list ();
1585   require (')');
1586   return types;
1587 }
1588
1589 /* Parse an array type.  */
1590
1591 struct type *
1592 rust_parser::parse_array_type ()
1593 {
1594   assume ('[');
1595   struct type *elt_type = parse_type ();
1596   require (';');
1597
1598   if (current_token != INTEGER && current_token != DECIMAL_INTEGER)
1599     error (_("integer expected"));
1600   ULONGEST val = current_int_val.val;
1601   lex ();
1602   require (']');
1603
1604   return lookup_array_range_type (elt_type, 0, val - 1);
1605 }
1606
1607 /* Parse a slice type.  */
1608
1609 struct type *
1610 rust_parser::parse_slice_type ()
1611 {
1612   assume ('&');
1613
1614   bool is_slice = current_token == '[';
1615   if (is_slice)
1616     lex ();
1617
1618   struct type *target = parse_type ();
1619
1620   if (is_slice)
1621     {
1622       require (']');
1623       return rust_slice_type ("&[*gdb*]", target, get_type ("usize"));
1624     }
1625
1626   /* For now we treat &x and *x identically.  */
1627   return lookup_pointer_type (target);
1628 }
1629
1630 /* Parse a pointer type.  */
1631
1632 struct type *
1633 rust_parser::parse_pointer_type ()
1634 {
1635   assume ('*');
1636
1637   if (current_token == KW_MUT || current_token == KW_CONST)
1638     lex ();
1639
1640   struct type *target = parse_type ();
1641   /* For the time being we ignore mut/const.  */
1642   return lookup_pointer_type (target);
1643 }
1644
1645 /* Parse a function type.  */
1646
1647 struct type *
1648 rust_parser::parse_function_type ()
1649 {
1650   assume (KW_FN);
1651
1652   if (current_token != '(')
1653     error (_("'(' expected"));
1654
1655   std::vector<struct type *> types = parse_maybe_type_list ();
1656
1657   if (current_token != ARROW)
1658     error (_("'->' expected"));
1659   lex ();
1660
1661   struct type *result_type = parse_type ();
1662
1663   struct type **argtypes = nullptr;
1664   if (!types.empty ())
1665     argtypes = types.data ();
1666
1667   result_type = lookup_function_type_with_arguments (result_type,
1668                                                      types.size (),
1669                                                      argtypes);
1670   return lookup_pointer_type (result_type);
1671 }
1672
1673 /* Parse a tuple type.  */
1674
1675 struct type *
1676 rust_parser::parse_tuple_type ()
1677 {
1678   std::vector<struct type *> types = parse_maybe_type_list ();
1679
1680   auto_obstack obstack;
1681   obstack_1grow (&obstack, '(');
1682   for (int i = 0; i < types.size (); ++i)
1683     {
1684       std::string type_name = type_to_string (types[i]);
1685
1686       if (i > 0)
1687         obstack_1grow (&obstack, ',');
1688       obstack_grow_str (&obstack, type_name.c_str ());
1689     }
1690
1691   obstack_grow_str0 (&obstack, ")");
1692   const char *name = (const char *) obstack_finish (&obstack);
1693
1694   /* We don't allow creating new tuple types (yet), but we do allow
1695      looking up existing tuple types.  */
1696   struct type *result = rust_lookup_type (name);
1697   if (result == nullptr)
1698     error (_("could not find tuple type '%s'"), name);
1699
1700   return result;
1701 }
1702
1703 /* Parse a type.  */
1704
1705 struct type *
1706 rust_parser::parse_type ()
1707 {
1708   switch (current_token)
1709     {
1710     case '[':
1711       return parse_array_type ();
1712     case '&':
1713       return parse_slice_type ();
1714     case '*':
1715       return parse_pointer_type ();
1716     case KW_FN:
1717       return parse_function_type ();
1718     case '(':
1719       return parse_tuple_type ();
1720     case KW_SELF:
1721     case KW_SUPER:
1722     case COLONCOLON:
1723     case KW_EXTERN:
1724     case IDENT:
1725       {
1726         std::string path = parse_path (false);
1727         struct type *result = rust_lookup_type (path.c_str ());
1728         if (result == nullptr)
1729           error (_("No type name '%s' in current context"), path.c_str ());
1730         return result;
1731       }
1732     default:
1733       error (_("type expected"));
1734     }
1735 }
1736
1737 /* Parse a path.  */
1738
1739 std::string
1740 rust_parser::parse_path (bool for_expr)
1741 {
1742   unsigned n_supers = 0;
1743   int first_token = current_token;
1744
1745   switch (current_token)
1746     {
1747     case KW_SELF:
1748       lex ();
1749       if (current_token != COLONCOLON)
1750         return "self";
1751       lex ();
1752       /* FALLTHROUGH */
1753     case KW_SUPER:
1754       while (current_token == KW_SUPER)
1755         {
1756           ++n_supers;
1757           lex ();
1758           if (current_token != COLONCOLON)
1759             error (_("'::' expected"));
1760           lex ();
1761         }
1762       break;
1763
1764     case COLONCOLON:
1765       lex ();
1766       break;
1767
1768     case KW_EXTERN:
1769       /* This is a gdb extension to make it possible to refer to items
1770          in other crates.  It just bypasses adding the current crate
1771          to the front of the name.  */
1772       lex ();
1773       break;
1774     }
1775
1776   if (current_token != IDENT)
1777     error (_("identifier expected"));
1778   std::string path = get_string ();
1779   bool saw_ident = true;
1780   lex ();
1781
1782   /* The condition here lets us enter the loop even if we see
1783      "ident<...>".  */
1784   while (current_token == COLONCOLON || current_token == '<')
1785     {
1786       if (current_token == COLONCOLON)
1787         {
1788           lex ();
1789           saw_ident = false;
1790
1791           if (current_token == IDENT)
1792             {
1793               path = path + "::" + get_string ();
1794               lex ();
1795               saw_ident = true;
1796             }
1797           else if (current_token == COLONCOLON)
1798             {
1799               /* The code below won't detect this scenario.  */
1800               error (_("unexpected '::'"));
1801             }
1802         }
1803
1804       if (current_token != '<')
1805         continue;
1806
1807       /* Expression use name::<...>, whereas types use name<...>.  */
1808       if (for_expr)
1809         {
1810           /* Expressions use "name::<...>", so if we saw an identifier
1811              after the "::", we ignore the "<" here.  */
1812           if (saw_ident)
1813             break;
1814         }
1815       else
1816         {
1817           /* Types use "name<...>", so we need to have seen the
1818              identifier.  */
1819           if (!saw_ident)
1820             break;
1821         }
1822
1823       lex ();
1824       std::vector<struct type *> types = parse_type_list ();
1825       if (current_token == '>')
1826         lex ();
1827       else if (current_token == RSH)
1828         {
1829           push_back ('>');
1830           lex ();
1831         }
1832       else
1833         error (_("'>' expected"));
1834
1835       path += "<";
1836       for (int i = 0; i < types.size (); ++i)
1837         {
1838           if (i > 0)
1839             path += ",";
1840           path += type_to_string (types[i]);
1841         }
1842       path += ">";
1843       break;
1844     }
1845
1846   switch (first_token)
1847     {
1848     case KW_SELF:
1849     case KW_SUPER:
1850       return super_name (path, n_supers);
1851
1852     case COLONCOLON:
1853       return crate_name (path);
1854
1855     case KW_EXTERN:
1856       return "::" + path;
1857
1858     case IDENT:
1859       return path;
1860
1861     default:
1862       gdb_assert_not_reached ("missing case in path parsing");
1863     }
1864 }
1865
1866 /* Handle the parsing for a string expression.  */
1867
1868 operation_up
1869 rust_parser::parse_string ()
1870 {
1871   gdb_assert (current_token == STRING);
1872
1873   /* Wrap the raw string in the &str struct.  */
1874   struct type *type = rust_lookup_type ("&str");
1875   if (type == nullptr)
1876     error (_("Could not find type '&str'"));
1877
1878   std::vector<std::pair<std::string, operation_up>> field_v;
1879
1880   size_t len = current_string_val.length;
1881   operation_up str = make_operation<string_operation> (get_string ());
1882   operation_up addr
1883     = make_operation<rust_unop_addr_operation> (std::move (str));
1884   field_v.emplace_back ("data_ptr", std::move (addr));
1885
1886   struct type *valtype = get_type ("usize");
1887   operation_up lenop = make_operation<long_const_operation> (valtype, len);
1888   field_v.emplace_back ("length", std::move (lenop));
1889
1890   return make_operation<rust_aggregate_operation> (type,
1891                                                    operation_up (),
1892                                                    std::move (field_v));
1893 }
1894
1895 /* Parse a tuple struct expression.  */
1896
1897 operation_up
1898 rust_parser::parse_tuple_struct (struct type *type)
1899 {
1900   std::vector<operation_up> args = parse_paren_args ();
1901
1902   std::vector<std::pair<std::string, operation_up>> field_v (args.size ());
1903   for (int i = 0; i < args.size (); ++i)
1904     field_v[i] = { string_printf ("__%d", i), std::move (args[i]) };
1905
1906   return (make_operation<rust_aggregate_operation>
1907           (type, operation_up (), std::move (field_v)));
1908 }
1909
1910 /* Parse a path expression.  */
1911
1912 operation_up
1913 rust_parser::parse_path_expr ()
1914 {
1915   std::string path = parse_path (true);
1916
1917   if (current_token == '{')
1918     {
1919       struct type *type = rust_lookup_type (path.c_str ());
1920       if (type == nullptr)
1921         error (_("Could not find type '%s'"), path.c_str ());
1922
1923       return parse_struct_expr (type);
1924     }
1925   else if (current_token == '(')
1926     {
1927       struct type *type = rust_lookup_type (path.c_str ());
1928       /* If this is actually a tuple struct expression, handle it
1929          here.  If it is a call, it will be handled elsewhere.  */
1930       if (type != nullptr)
1931         {
1932           if (!rust_tuple_struct_type_p (type))
1933             error (_("Type %s is not a tuple struct"), path.c_str ());
1934           return parse_tuple_struct (type);
1935         }
1936     }
1937
1938   return name_to_operation (path);
1939 }
1940
1941 /* Parse an atom.  "Atom" isn't a Rust term, but this refers to a
1942    single unitary item in the grammar; but here including some unary
1943    prefix and postfix expressions.  */
1944
1945 operation_up
1946 rust_parser::parse_atom (bool required)
1947 {
1948   operation_up result;
1949
1950   switch (current_token)
1951     {
1952     case '(':
1953       result = parse_tuple ();
1954       break;
1955
1956     case '[':
1957       result = parse_array ();
1958       break;
1959
1960     case INTEGER:
1961     case DECIMAL_INTEGER:
1962       result = make_operation<long_const_operation> (current_int_val.type,
1963                                                      current_int_val.val);
1964       lex ();
1965       break;
1966
1967     case FLOAT:
1968       result = make_operation<float_const_operation> (current_float_val.type,
1969                                                       current_float_val.val);
1970       lex ();
1971       break;
1972
1973     case STRING:
1974       result = parse_string ();
1975       break;
1976
1977     case BYTESTRING:
1978       result = make_operation<string_operation> (get_string ());
1979       lex ();
1980       break;
1981
1982     case KW_TRUE:
1983     case KW_FALSE:
1984       result = make_operation<bool_operation> (current_token == KW_TRUE);
1985       lex ();
1986       break;
1987
1988     case GDBVAR:
1989       /* This is kind of a hacky approach.  */
1990       {
1991         pstate->push_dollar (current_string_val);
1992         result = pstate->pop ();
1993         lex ();
1994       }
1995       break;
1996
1997     case KW_SELF:
1998     case KW_SUPER:
1999     case COLONCOLON:
2000     case KW_EXTERN:
2001     case IDENT:
2002       result = parse_path_expr ();
2003       break;
2004
2005     case '*':
2006       lex ();
2007       result = make_operation<rust_unop_ind_operation> (parse_atom (true));
2008       break;
2009     case '+':
2010       lex ();
2011       result = make_operation<unary_plus_operation> (parse_atom (true));
2012       break;
2013     case '-':
2014       lex ();
2015       result = make_operation<unary_neg_operation> (parse_atom (true));
2016       break;
2017     case '!':
2018       lex ();
2019       result = make_operation<rust_unop_compl_operation> (parse_atom (true));
2020       break;
2021     case KW_SIZEOF:
2022       result = parse_sizeof ();
2023       break;
2024     case '&':
2025       result = parse_addr ();
2026       break;
2027
2028     default:
2029       if (!required)
2030         return {};
2031       error (_("unexpected token"));
2032     }
2033
2034   /* Now parse suffixes.  */
2035   while (true)
2036     {
2037       switch (current_token)
2038         {
2039         case '.':
2040           result = parse_field (std::move (result));
2041           break;
2042
2043         case '[':
2044           result = parse_index (std::move (result));
2045           break;
2046
2047         case '(':
2048           result = parse_call (std::move (result));
2049           break;
2050
2051         default:
2052           return result;
2053         }
2054     }
2055 }
2056
2057 \f
2058
2059 /* The parser as exposed to gdb.  */
2060
2061 int
2062 rust_language::parser (struct parser_state *state) const
2063 {
2064   rust_parser parser (state);
2065
2066   operation_up result;
2067   try
2068     {
2069       result = parser.parse_entry_point ();
2070     }
2071   catch (const gdb_exception &exc)
2072     {
2073       if (state->parse_completion)
2074         {
2075           result = std::move (parser.completion_op);
2076           if (result == nullptr)
2077             throw;
2078         }
2079       else
2080         throw;
2081     }
2082
2083   state->set_operation (std::move (result));
2084
2085   return 0;
2086 }
2087
2088 \f
2089
2090 #if GDB_SELF_TEST
2091
2092 /* A test helper that lexes a string, expecting a single token.  */
2093
2094 static void
2095 rust_lex_test_one (rust_parser *parser, const char *input, int expected)
2096 {
2097   int token;
2098
2099   parser->reset (input);
2100
2101   token = parser->lex_one_token ();
2102   SELF_CHECK (token == expected);
2103
2104   if (token)
2105     {
2106       token = parser->lex_one_token ();
2107       SELF_CHECK (token == 0);
2108     }
2109 }
2110
2111 /* Test that INPUT lexes as the integer VALUE.  */
2112
2113 static void
2114 rust_lex_int_test (rust_parser *parser, const char *input,
2115                    ULONGEST value, int kind)
2116 {
2117   rust_lex_test_one (parser, input, kind);
2118   SELF_CHECK (parser->current_int_val.val == value);
2119 }
2120
2121 /* Test that INPUT throws an exception with text ERR.  */
2122
2123 static void
2124 rust_lex_exception_test (rust_parser *parser, const char *input,
2125                          const char *err)
2126 {
2127   try
2128     {
2129       /* The "kind" doesn't matter.  */
2130       rust_lex_test_one (parser, input, DECIMAL_INTEGER);
2131       SELF_CHECK (0);
2132     }
2133   catch (const gdb_exception_error &except)
2134     {
2135       SELF_CHECK (strcmp (except.what (), err) == 0);
2136     }
2137 }
2138
2139 /* Test that INPUT lexes as the identifier, string, or byte-string
2140    VALUE.  KIND holds the expected token kind.  */
2141
2142 static void
2143 rust_lex_stringish_test (rust_parser *parser, const char *input,
2144                          const char *value, int kind)
2145 {
2146   rust_lex_test_one (parser, input, kind);
2147   SELF_CHECK (parser->get_string () == value);
2148 }
2149
2150 /* Helper to test that a string parses as a given token sequence.  */
2151
2152 static void
2153 rust_lex_test_sequence (rust_parser *parser, const char *input, int len,
2154                         const int expected[])
2155 {
2156   int i;
2157
2158   parser->reset (input);
2159
2160   for (i = 0; i < len; ++i)
2161     {
2162       int token = parser->lex_one_token ();
2163       SELF_CHECK (token == expected[i]);
2164     }
2165 }
2166
2167 /* Tests for an integer-parsing corner case.  */
2168
2169 static void
2170 rust_lex_test_trailing_dot (rust_parser *parser)
2171 {
2172   const int expected1[] = { DECIMAL_INTEGER, '.', IDENT, '(', ')', 0 };
2173   const int expected2[] = { INTEGER, '.', IDENT, '(', ')', 0 };
2174   const int expected3[] = { FLOAT, EQEQ, '(', ')', 0 };
2175   const int expected4[] = { DECIMAL_INTEGER, DOTDOT, DECIMAL_INTEGER, 0 };
2176
2177   rust_lex_test_sequence (parser, "23.g()", ARRAY_SIZE (expected1), expected1);
2178   rust_lex_test_sequence (parser, "23_0.g()", ARRAY_SIZE (expected2),
2179                           expected2);
2180   rust_lex_test_sequence (parser, "23.==()", ARRAY_SIZE (expected3),
2181                           expected3);
2182   rust_lex_test_sequence (parser, "23..25", ARRAY_SIZE (expected4), expected4);
2183 }
2184
2185 /* Tests of completion.  */
2186
2187 static void
2188 rust_lex_test_completion (rust_parser *parser)
2189 {
2190   const int expected[] = { IDENT, '.', COMPLETE, 0 };
2191
2192   parser->pstate->parse_completion = 1;
2193
2194   rust_lex_test_sequence (parser, "something.wha", ARRAY_SIZE (expected),
2195                           expected);
2196   rust_lex_test_sequence (parser, "something.", ARRAY_SIZE (expected),
2197                           expected);
2198
2199   parser->pstate->parse_completion = 0;
2200 }
2201
2202 /* Test pushback.  */
2203
2204 static void
2205 rust_lex_test_push_back (rust_parser *parser)
2206 {
2207   int token;
2208
2209   parser->reset (">>=");
2210
2211   token = parser->lex_one_token ();
2212   SELF_CHECK (token == COMPOUND_ASSIGN);
2213   SELF_CHECK (parser->current_opcode == BINOP_RSH);
2214
2215   parser->push_back ('=');
2216
2217   token = parser->lex_one_token ();
2218   SELF_CHECK (token == '=');
2219
2220   token = parser->lex_one_token ();
2221   SELF_CHECK (token == 0);
2222 }
2223
2224 /* Unit test the lexer.  */
2225
2226 static void
2227 rust_lex_tests (void)
2228 {
2229   int i;
2230
2231   /* Set up dummy "parser", so that rust_type works.  */
2232   struct parser_state ps (language_def (language_rust), target_gdbarch (),
2233                           nullptr, 0, 0, nullptr, 0, nullptr, false);
2234   rust_parser parser (&ps);
2235
2236   rust_lex_test_one (&parser, "", 0);
2237   rust_lex_test_one (&parser, "    \t  \n \r  ", 0);
2238   rust_lex_test_one (&parser, "thread 23", 0);
2239   rust_lex_test_one (&parser, "task 23", 0);
2240   rust_lex_test_one (&parser, "th 104", 0);
2241   rust_lex_test_one (&parser, "ta 97", 0);
2242
2243   rust_lex_int_test (&parser, "'z'", 'z', INTEGER);
2244   rust_lex_int_test (&parser, "'\\xff'", 0xff, INTEGER);
2245   rust_lex_int_test (&parser, "'\\u{1016f}'", 0x1016f, INTEGER);
2246   rust_lex_int_test (&parser, "b'z'", 'z', INTEGER);
2247   rust_lex_int_test (&parser, "b'\\xfe'", 0xfe, INTEGER);
2248   rust_lex_int_test (&parser, "b'\\xFE'", 0xfe, INTEGER);
2249   rust_lex_int_test (&parser, "b'\\xfE'", 0xfe, INTEGER);
2250
2251   /* Test all escapes in both modes.  */
2252   rust_lex_int_test (&parser, "'\\n'", '\n', INTEGER);
2253   rust_lex_int_test (&parser, "'\\r'", '\r', INTEGER);
2254   rust_lex_int_test (&parser, "'\\t'", '\t', INTEGER);
2255   rust_lex_int_test (&parser, "'\\\\'", '\\', INTEGER);
2256   rust_lex_int_test (&parser, "'\\0'", '\0', INTEGER);
2257   rust_lex_int_test (&parser, "'\\''", '\'', INTEGER);
2258   rust_lex_int_test (&parser, "'\\\"'", '"', INTEGER);
2259
2260   rust_lex_int_test (&parser, "b'\\n'", '\n', INTEGER);
2261   rust_lex_int_test (&parser, "b'\\r'", '\r', INTEGER);
2262   rust_lex_int_test (&parser, "b'\\t'", '\t', INTEGER);
2263   rust_lex_int_test (&parser, "b'\\\\'", '\\', INTEGER);
2264   rust_lex_int_test (&parser, "b'\\0'", '\0', INTEGER);
2265   rust_lex_int_test (&parser, "b'\\''", '\'', INTEGER);
2266   rust_lex_int_test (&parser, "b'\\\"'", '"', INTEGER);
2267
2268   rust_lex_exception_test (&parser, "'z", "Unterminated character literal");
2269   rust_lex_exception_test (&parser, "b'\\x0'", "Not enough hex digits seen");
2270   rust_lex_exception_test (&parser, "b'\\u{0}'",
2271                            "Unicode escape in byte literal");
2272   rust_lex_exception_test (&parser, "'\\x0'", "Not enough hex digits seen");
2273   rust_lex_exception_test (&parser, "'\\u0'", "Missing '{' in Unicode escape");
2274   rust_lex_exception_test (&parser, "'\\u{0", "Missing '}' in Unicode escape");
2275   rust_lex_exception_test (&parser, "'\\u{0000007}", "Overlong hex escape");
2276   rust_lex_exception_test (&parser, "'\\u{}", "Not enough hex digits seen");
2277   rust_lex_exception_test (&parser, "'\\Q'", "Invalid escape \\Q in literal");
2278   rust_lex_exception_test (&parser, "b'\\Q'", "Invalid escape \\Q in literal");
2279
2280   rust_lex_int_test (&parser, "23", 23, DECIMAL_INTEGER);
2281   rust_lex_int_test (&parser, "2_344__29", 234429, INTEGER);
2282   rust_lex_int_test (&parser, "0x1f", 0x1f, INTEGER);
2283   rust_lex_int_test (&parser, "23usize", 23, INTEGER);
2284   rust_lex_int_test (&parser, "23i32", 23, INTEGER);
2285   rust_lex_int_test (&parser, "0x1_f", 0x1f, INTEGER);
2286   rust_lex_int_test (&parser, "0b1_101011__", 0x6b, INTEGER);
2287   rust_lex_int_test (&parser, "0o001177i64", 639, INTEGER);
2288   rust_lex_int_test (&parser, "0x123456789u64", 0x123456789ull, INTEGER);
2289
2290   rust_lex_test_trailing_dot (&parser);
2291
2292   rust_lex_test_one (&parser, "23.", FLOAT);
2293   rust_lex_test_one (&parser, "23.99f32", FLOAT);
2294   rust_lex_test_one (&parser, "23e7", FLOAT);
2295   rust_lex_test_one (&parser, "23E-7", FLOAT);
2296   rust_lex_test_one (&parser, "23e+7", FLOAT);
2297   rust_lex_test_one (&parser, "23.99e+7f64", FLOAT);
2298   rust_lex_test_one (&parser, "23.82f32", FLOAT);
2299
2300   rust_lex_stringish_test (&parser, "hibob", "hibob", IDENT);
2301   rust_lex_stringish_test (&parser, "hibob__93", "hibob__93", IDENT);
2302   rust_lex_stringish_test (&parser, "thread", "thread", IDENT);
2303
2304   rust_lex_stringish_test (&parser, "\"string\"", "string", STRING);
2305   rust_lex_stringish_test (&parser, "\"str\\ting\"", "str\ting", STRING);
2306   rust_lex_stringish_test (&parser, "\"str\\\"ing\"", "str\"ing", STRING);
2307   rust_lex_stringish_test (&parser, "r\"str\\ing\"", "str\\ing", STRING);
2308   rust_lex_stringish_test (&parser, "r#\"str\\ting\"#", "str\\ting", STRING);
2309   rust_lex_stringish_test (&parser, "r###\"str\\\"ing\"###", "str\\\"ing",
2310                            STRING);
2311
2312   rust_lex_stringish_test (&parser, "b\"string\"", "string", BYTESTRING);
2313   rust_lex_stringish_test (&parser, "b\"\x73tring\"", "string", BYTESTRING);
2314   rust_lex_stringish_test (&parser, "b\"str\\\"ing\"", "str\"ing", BYTESTRING);
2315   rust_lex_stringish_test (&parser, "br####\"\\x73tring\"####", "\\x73tring",
2316                            BYTESTRING);
2317
2318   for (i = 0; i < ARRAY_SIZE (identifier_tokens); ++i)
2319     rust_lex_test_one (&parser, identifier_tokens[i].name,
2320                        identifier_tokens[i].value);
2321
2322   for (i = 0; i < ARRAY_SIZE (operator_tokens); ++i)
2323     rust_lex_test_one (&parser, operator_tokens[i].name,
2324                        operator_tokens[i].value);
2325
2326   rust_lex_test_completion (&parser);
2327   rust_lex_test_push_back (&parser);
2328 }
2329
2330 #endif /* GDB_SELF_TEST */
2331
2332 \f
2333
2334 void _initialize_rust_exp ();
2335 void
2336 _initialize_rust_exp ()
2337 {
2338   int code = regcomp (&number_regex, number_regex_text, REG_EXTENDED);
2339   /* If the regular expression was incorrect, it was a programming
2340      error.  */
2341   gdb_assert (code == 0);
2342
2343 #if GDB_SELF_TEST
2344   selftests::register_test ("rust-lex", rust_lex_tests);
2345 #endif
2346 }