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