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