]> Git Repo - binutils.git/blob - gdb/rust-parse.c
Fix Rust lex selftest when using libiconv
[binutils.git] / 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 }
This page took 0.166841 seconds and 4 git commands to generate.