1 /* Rust expression parsing for GDB, the GNU debugger.
3 Copyright (C) 2016-2021 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "cp-support.h"
25 #include "gdb_obstack.h"
26 #include "gdb_regex.h"
27 #include "rust-lang.h"
28 #include "parser-defs.h"
29 #include "gdbsupport/selftest.h"
36 /* A regular expression for matching Rust numbers. This is split up
37 since it is very long and this gives us a way to comment the
40 static const char number_regex_text
[] =
41 /* subexpression 1: allows use of alternation, otherwise uninteresting */
43 /* First comes floating point. */
44 /* Recognize number after the decimal point, with optional
45 exponent and optional type suffix.
46 subexpression 2: allows "?", otherwise uninteresting
47 subexpression 3: if present, type suffix
49 "[0-9][0-9_]*\\.[0-9][0-9_]*([eE][-+]?[0-9][0-9_]*)?(f32|f64)?"
52 /* Recognize exponent without decimal point, with optional type
54 subexpression 4: if present, type suffix
57 "[0-9][0-9_]*[eE][-+]?[0-9][0-9_]*(f32|f64)?"
59 /* "23." is a valid floating point number, but "23.e5" and
60 "23.f32" are not. So, handle the trailing-. case
64 /* Finally come integers.
65 subexpression 5: text of integer
66 subexpression 6: if present, type suffix
67 subexpression 7: allows use of alternation, otherwise uninteresting
71 "(0x[a-fA-F0-9_]+|0o[0-7_]+|0b[01_]+|[0-9][0-9_]*)"
72 "([iu](size|8|16|32|64))?"
74 /* The number of subexpressions to allocate space for, including the
75 "0th" whole match subexpression. */
76 #define NUM_SUBEXPRESSIONS 8
78 /* The compiled number-matching regex. */
80 static regex_t number_regex
;
82 /* The kinds of tokens. Note that single-character tokens are
83 represented by themselves, so for instance '[' is a token. */
86 /* Make sure to start after any ASCII character. */
110 /* Operator tokens. */
125 /* A typed integer constant. */
133 /* A typed floating point constant. */
135 struct typed_val_float
141 /* A struct of this type is used to describe a token. */
147 enum exp_opcode opcode
;
150 /* Identifier tokens. */
152 static const struct token_info identifier_tokens
[] =
154 { "as", KW_AS
, OP_NULL
},
155 { "false", KW_FALSE
, OP_NULL
},
156 { "if", 0, OP_NULL
},
157 { "mut", KW_MUT
, OP_NULL
},
158 { "const", KW_CONST
, OP_NULL
},
159 { "self", KW_SELF
, OP_NULL
},
160 { "super", KW_SUPER
, OP_NULL
},
161 { "true", KW_TRUE
, OP_NULL
},
162 { "extern", KW_EXTERN
, OP_NULL
},
163 { "fn", KW_FN
, OP_NULL
},
164 { "sizeof", KW_SIZEOF
, OP_NULL
},
167 /* Operator tokens, sorted longest first. */
169 static const struct token_info operator_tokens
[] =
171 { ">>=", COMPOUND_ASSIGN
, BINOP_RSH
},
172 { "<<=", COMPOUND_ASSIGN
, BINOP_LSH
},
174 { "<<", LSH
, OP_NULL
},
175 { ">>", RSH
, OP_NULL
},
176 { "&&", ANDAND
, OP_NULL
},
177 { "||", OROR
, OP_NULL
},
178 { "==", EQEQ
, OP_NULL
},
179 { "!=", NOTEQ
, OP_NULL
},
180 { "<=", LTEQ
, OP_NULL
},
181 { ">=", GTEQ
, OP_NULL
},
182 { "+=", COMPOUND_ASSIGN
, BINOP_ADD
},
183 { "-=", COMPOUND_ASSIGN
, BINOP_SUB
},
184 { "*=", COMPOUND_ASSIGN
, BINOP_MUL
},
185 { "/=", COMPOUND_ASSIGN
, BINOP_DIV
},
186 { "%=", COMPOUND_ASSIGN
, BINOP_REM
},
187 { "&=", COMPOUND_ASSIGN
, BINOP_BITWISE_AND
},
188 { "|=", COMPOUND_ASSIGN
, BINOP_BITWISE_IOR
},
189 { "^=", COMPOUND_ASSIGN
, BINOP_BITWISE_XOR
},
190 { "..=", DOTDOTEQ
, OP_NULL
},
192 { "::", COLONCOLON
, OP_NULL
},
193 { "..", DOTDOT
, OP_NULL
},
194 { "->", ARROW
, OP_NULL
}
197 /* An instance of this is created before parsing, and destroyed when
198 parsing is finished. */
202 explicit rust_parser (struct parser_state
*state
)
207 DISABLE_COPY_AND_ASSIGN (rust_parser
);
209 /* Return the parser's language. */
210 const struct language_defn
*language () const
212 return pstate
->language ();
215 /* Return the parser's gdbarch. */
216 struct gdbarch
*arch () const
218 return pstate
->gdbarch ();
221 /* A helper to look up a Rust type, or fail. This only works for
222 types defined by rust_language_arch_info. */
224 struct type
*get_type (const char *name
)
228 type
= language_lookup_primitive_type (language (), arch (), name
);
230 error (_("Could not find Rust type %s"), name
);
234 std::string
crate_name (const std::string
&name
);
235 std::string
super_name (const std::string
&ident
, unsigned int n_supers
);
237 int lex_character ();
240 int lex_identifier ();
241 uint32_t lex_hex (int min
, int max
);
242 uint32_t lex_escape (int is_byte
);
244 int lex_one_token ();
245 void push_back (char c
);
247 /* The main interface to lexing. Lexes one token and updates the
251 current_token
= lex_one_token ();
254 /* Assuming the current token is TYPE, lex the next token. */
255 void assume (int type
)
257 gdb_assert (current_token
== type
);
261 /* Require the single-character token C, and lex the next token; or
262 throw an exception. */
263 void require (char type
)
265 if (current_token
!= type
)
266 error (_("'%c' expected"), type
);
270 /* Entry point for all parsing. */
271 operation_up
parse_entry_point ()
274 return parse_expr ();
277 operation_up
parse_tuple ();
278 operation_up
parse_array ();
279 operation_up
name_to_operation (const std::string
&name
);
280 operation_up
parse_struct_expr (struct type
*type
);
281 operation_up
parse_binop (bool required
);
282 operation_up
parse_range ();
283 operation_up
parse_expr ();
284 operation_up
parse_sizeof ();
285 operation_up
parse_addr ();
286 operation_up
parse_field (operation_up
&&);
287 operation_up
parse_index (operation_up
&&);
288 std::vector
<operation_up
> parse_paren_args ();
289 operation_up
parse_call (operation_up
&&);
290 std::vector
<struct type
*> parse_type_list ();
291 std::vector
<struct type
*> parse_maybe_type_list ();
292 struct type
*parse_array_type ();
293 struct type
*parse_slice_type ();
294 struct type
*parse_pointer_type ();
295 struct type
*parse_function_type ();
296 struct type
*parse_tuple_type ();
297 struct type
*parse_type ();
298 std::string
parse_path (bool for_expr
);
299 operation_up
parse_string ();
300 operation_up
parse_tuple_struct (struct type
*type
);
301 operation_up
parse_path_expr ();
302 operation_up
parse_atom (bool required
);
304 void update_innermost_block (struct block_symbol sym
);
305 struct block_symbol
lookup_symbol (const char *name
,
306 const struct block
*block
,
307 const domain_enum domain
);
308 struct type
*rust_lookup_type (const char *name
);
310 /* Clear some state. This is only used for testing. */
312 void reset (const char *input
)
314 pstate
->prev_lexptr
= nullptr;
315 pstate
->lexptr
= input
;
318 current_int_val
= {};
319 current_float_val
= {};
320 current_string_val
= {};
321 current_opcode
= OP_NULL
;
323 #endif /* GDB_SELF_TEST */
325 /* Return the token's string value as a string. */
326 std::string
get_string () const
328 return std::string (current_string_val
.ptr
, current_string_val
.length
);
331 /* A pointer to this is installed globally. */
332 auto_obstack obstack
;
334 /* The parser state gdb gave us. */
335 struct parser_state
*pstate
;
337 /* Depth of parentheses. */
340 /* The current token's type. */
341 int current_token
= 0;
342 /* The current token's payload, if any. */
343 typed_val_int current_int_val
{};
344 typed_val_float current_float_val
{};
345 struct stoken current_string_val
{};
346 enum exp_opcode current_opcode
= OP_NULL
;
348 /* When completing, this may be set to the field operation to
350 operation_up completion_op
;
353 /* Return an string referring to NAME, but relative to the crate's
357 rust_parser::crate_name (const std::string
&name
)
359 std::string crate
= rust_crate_for_block (pstate
->expression_context_block
);
362 error (_("Could not find crate for current location"));
363 return "::" + crate
+ "::" + name
;
366 /* Return a string referring to a "super::" qualified name. IDENT is
367 the base name and N_SUPERS is how many "super::"s were provided.
368 N_SUPERS can be zero. */
371 rust_parser::super_name (const std::string
&ident
, unsigned int n_supers
)
373 const char *scope
= block_scope (pstate
->expression_context_block
);
376 if (scope
[0] == '\0')
377 error (_("Couldn't find namespace scope for self::"));
382 std::vector
<int> offsets
;
383 unsigned int current_len
;
385 current_len
= cp_find_first_component (scope
);
386 while (scope
[current_len
] != '\0')
388 offsets
.push_back (current_len
);
389 gdb_assert (scope
[current_len
] == ':');
392 current_len
+= cp_find_first_component (scope
396 len
= offsets
.size ();
398 error (_("Too many super:: uses from '%s'"), scope
);
400 offset
= offsets
[len
- n_supers
];
403 offset
= strlen (scope
);
405 return "::" + std::string (scope
, offset
) + "::" + ident
;
408 /* A helper to appropriately munge NAME and BLOCK depending on the
409 presence of a leading "::". */
412 munge_name_and_block (const char **name
, const struct block
**block
)
414 /* If it is a global reference, skip the current block in favor of
416 if (startswith (*name
, "::"))
419 *block
= block_static_block (*block
);
423 /* Like lookup_symbol, but handles Rust namespace conventions, and
424 doesn't require field_of_this_result. */
427 rust_parser::lookup_symbol (const char *name
, const struct block
*block
,
428 const domain_enum domain
)
430 struct block_symbol result
;
432 munge_name_and_block (&name
, &block
);
434 result
= ::lookup_symbol (name
, block
, domain
, NULL
);
435 if (result
.symbol
!= NULL
)
436 update_innermost_block (result
);
440 /* Look up a type, following Rust namespace conventions. */
443 rust_parser::rust_lookup_type (const char *name
)
445 struct block_symbol result
;
448 const struct block
*block
= pstate
->expression_context_block
;
449 munge_name_and_block (&name
, &block
);
451 result
= ::lookup_symbol (name
, block
, STRUCT_DOMAIN
, NULL
);
452 if (result
.symbol
!= NULL
)
454 update_innermost_block (result
);
455 return SYMBOL_TYPE (result
.symbol
);
458 type
= lookup_typename (language (), name
, NULL
, 1);
462 /* Last chance, try a built-in type. */
463 return language_lookup_primitive_type (language (), arch (), name
);
466 /* A helper that updates the innermost block as appropriate. */
469 rust_parser::update_innermost_block (struct block_symbol sym
)
471 if (symbol_read_needs_frame (sym
.symbol
))
472 pstate
->block_tracker
->update (sym
);
475 /* Lex a hex number with at least MIN digits and at most MAX
479 rust_parser::lex_hex (int min
, int max
)
483 /* We only want to stop at MAX if we're lexing a byte escape. */
484 int check_max
= min
== max
;
486 while ((check_max
? len
<= max
: 1)
487 && ((pstate
->lexptr
[0] >= 'a' && pstate
->lexptr
[0] <= 'f')
488 || (pstate
->lexptr
[0] >= 'A' && pstate
->lexptr
[0] <= 'F')
489 || (pstate
->lexptr
[0] >= '0' && pstate
->lexptr
[0] <= '9')))
492 if (pstate
->lexptr
[0] >= 'a' && pstate
->lexptr
[0] <= 'f')
493 result
= result
+ 10 + pstate
->lexptr
[0] - 'a';
494 else if (pstate
->lexptr
[0] >= 'A' && pstate
->lexptr
[0] <= 'F')
495 result
= result
+ 10 + pstate
->lexptr
[0] - 'A';
497 result
= result
+ pstate
->lexptr
[0] - '0';
503 error (_("Not enough hex digits seen"));
506 gdb_assert (min
!= max
);
507 error (_("Overlong hex escape"));
513 /* Lex an escape. IS_BYTE is true if we're lexing a byte escape;
514 otherwise we're lexing a character escape. */
517 rust_parser::lex_escape (int is_byte
)
521 gdb_assert (pstate
->lexptr
[0] == '\\');
523 switch (pstate
->lexptr
[0])
527 result
= lex_hex (2, 2);
532 error (_("Unicode escape in byte literal"));
534 if (pstate
->lexptr
[0] != '{')
535 error (_("Missing '{' in Unicode escape"));
537 result
= lex_hex (1, 6);
538 /* Could do range checks here. */
539 if (pstate
->lexptr
[0] != '}')
540 error (_("Missing '}' in Unicode escape"));
574 error (_("Invalid escape \\%c in literal"), pstate
->lexptr
[0]);
580 /* Lex a character constant. */
583 rust_parser::lex_character ()
588 if (pstate
->lexptr
[0] == 'b')
593 gdb_assert (pstate
->lexptr
[0] == '\'');
595 /* This should handle UTF-8 here. */
596 if (pstate
->lexptr
[0] == '\\')
597 value
= lex_escape (is_byte
);
600 value
= pstate
->lexptr
[0] & 0xff;
604 if (pstate
->lexptr
[0] != '\'')
605 error (_("Unterminated character literal"));
608 current_int_val
.val
= value
;
609 current_int_val
.type
= get_type (is_byte
? "u8" : "char");
614 /* Return the offset of the double quote if STR looks like the start
615 of a raw string, or 0 if STR does not start a raw string. */
618 starts_raw_string (const char *str
)
620 const char *save
= str
;
625 while (str
[0] == '#')
632 /* Return true if STR looks like the end of a raw string that had N
633 hashes at the start. */
636 ends_raw_string (const char *str
, int n
)
640 gdb_assert (str
[0] == '"');
641 for (i
= 0; i
< n
; ++i
)
642 if (str
[i
+ 1] != '#')
647 /* Lex a string constant. */
650 rust_parser::lex_string ()
652 int is_byte
= pstate
->lexptr
[0] == 'b';
657 raw_length
= starts_raw_string (pstate
->lexptr
);
658 pstate
->lexptr
+= raw_length
;
659 gdb_assert (pstate
->lexptr
[0] == '"');
668 if (pstate
->lexptr
[0] == '"' && ends_raw_string (pstate
->lexptr
,
671 /* Exit with lexptr pointing after the final "#". */
672 pstate
->lexptr
+= raw_length
;
675 else if (pstate
->lexptr
[0] == '\0')
676 error (_("Unexpected EOF in string"));
678 value
= pstate
->lexptr
[0] & 0xff;
679 if (is_byte
&& value
> 127)
680 error (_("Non-ASCII value in raw byte string"));
681 obstack_1grow (&obstack
, value
);
685 else if (pstate
->lexptr
[0] == '"')
687 /* Make sure to skip the quote. */
691 else if (pstate
->lexptr
[0] == '\\')
693 value
= lex_escape (is_byte
);
696 obstack_1grow (&obstack
, value
);
698 convert_between_encodings ("UTF-32", "UTF-8", (gdb_byte
*) &value
,
699 sizeof (value
), sizeof (value
),
700 &obstack
, translit_none
);
702 else if (pstate
->lexptr
[0] == '\0')
703 error (_("Unexpected EOF in string"));
706 value
= pstate
->lexptr
[0] & 0xff;
707 if (is_byte
&& value
> 127)
708 error (_("Non-ASCII value in byte string"));
709 obstack_1grow (&obstack
, value
);
714 current_string_val
.length
= obstack_object_size (&obstack
);
715 current_string_val
.ptr
= (const char *) obstack_finish (&obstack
);
716 return is_byte
? BYTESTRING
: STRING
;
719 /* Return true if STRING starts with whitespace followed by a digit. */
722 space_then_number (const char *string
)
724 const char *p
= string
;
726 while (p
[0] == ' ' || p
[0] == '\t')
731 return *p
>= '0' && *p
<= '9';
734 /* Return true if C can start an identifier. */
737 rust_identifier_start_p (char c
)
739 return ((c
>= 'a' && c
<= 'z')
740 || (c
>= 'A' && c
<= 'Z')
745 /* Lex an identifier. */
748 rust_parser::lex_identifier ()
751 const struct token_info
*token
;
753 int is_gdb_var
= pstate
->lexptr
[0] == '$';
756 if (pstate
->lexptr
[0] == 'r'
757 && pstate
->lexptr
[1] == '#'
758 && rust_identifier_start_p (pstate
->lexptr
[2]))
764 const char *start
= pstate
->lexptr
;
765 gdb_assert (rust_identifier_start_p (pstate
->lexptr
[0]));
769 /* For the time being this doesn't handle Unicode rules. Non-ASCII
770 identifiers are gated anyway. */
771 while ((pstate
->lexptr
[0] >= 'a' && pstate
->lexptr
[0] <= 'z')
772 || (pstate
->lexptr
[0] >= 'A' && pstate
->lexptr
[0] <= 'Z')
773 || pstate
->lexptr
[0] == '_'
774 || (is_gdb_var
&& pstate
->lexptr
[0] == '$')
775 || (pstate
->lexptr
[0] >= '0' && pstate
->lexptr
[0] <= '9'))
779 length
= pstate
->lexptr
- start
;
783 for (i
= 0; i
< ARRAY_SIZE (identifier_tokens
); ++i
)
785 if (length
== strlen (identifier_tokens
[i
].name
)
786 && strncmp (identifier_tokens
[i
].name
, start
, length
) == 0)
788 token
= &identifier_tokens
[i
];
796 if (token
->value
== 0)
798 /* Leave the terminating token alone. */
799 pstate
->lexptr
= start
;
803 else if (token
== NULL
805 && (strncmp (start
, "thread", length
) == 0
806 || strncmp (start
, "task", length
) == 0)
807 && space_then_number (pstate
->lexptr
))
809 /* "task" or "thread" followed by a number terminates the
810 parse, per gdb rules. */
811 pstate
->lexptr
= start
;
815 if (token
== NULL
|| (pstate
->parse_completion
&& pstate
->lexptr
[0] == '\0'))
817 current_string_val
.length
= length
;
818 current_string_val
.ptr
= start
;
821 if (pstate
->parse_completion
&& pstate
->lexptr
[0] == '\0')
823 /* Prevent rustyylex from returning two COMPLETE tokens. */
824 pstate
->prev_lexptr
= pstate
->lexptr
;
835 /* Lex an operator. */
838 rust_parser::lex_operator ()
840 const struct token_info
*token
= NULL
;
843 for (i
= 0; i
< ARRAY_SIZE (operator_tokens
); ++i
)
845 if (strncmp (operator_tokens
[i
].name
, pstate
->lexptr
,
846 strlen (operator_tokens
[i
].name
)) == 0)
848 pstate
->lexptr
+= strlen (operator_tokens
[i
].name
);
849 token
= &operator_tokens
[i
];
856 current_opcode
= token
->opcode
;
860 return *pstate
->lexptr
++;
866 rust_parser::lex_number ()
868 regmatch_t subexps
[NUM_SUBEXPRESSIONS
];
871 int could_be_decimal
= 1;
872 int implicit_i32
= 0;
873 const char *type_name
= NULL
;
879 match
= regexec (&number_regex
, pstate
->lexptr
, ARRAY_SIZE (subexps
),
881 /* Failure means the regexp is broken. */
882 gdb_assert (match
== 0);
884 if (subexps
[INT_TEXT
].rm_so
!= -1)
886 /* Integer part matched. */
888 end_index
= subexps
[INT_TEXT
].rm_eo
;
889 if (subexps
[INT_TYPE
].rm_so
== -1)
896 type_index
= INT_TYPE
;
897 could_be_decimal
= 0;
900 else if (subexps
[FLOAT_TYPE1
].rm_so
!= -1)
902 /* Found floating point type suffix. */
903 end_index
= subexps
[FLOAT_TYPE1
].rm_so
;
904 type_index
= FLOAT_TYPE1
;
906 else if (subexps
[FLOAT_TYPE2
].rm_so
!= -1)
908 /* Found floating point type suffix. */
909 end_index
= subexps
[FLOAT_TYPE2
].rm_so
;
910 type_index
= FLOAT_TYPE2
;
914 /* Any other floating point match. */
915 end_index
= subexps
[0].rm_eo
;
919 /* We need a special case if the final character is ".". In this
920 case we might need to parse an integer. For example, "23.f()" is
921 a request for a trait method call, not a syntax error involving
922 the floating point number "23.". */
923 gdb_assert (subexps
[0].rm_eo
> 0);
924 if (pstate
->lexptr
[subexps
[0].rm_eo
- 1] == '.')
926 const char *next
= skip_spaces (&pstate
->lexptr
[subexps
[0].rm_eo
]);
928 if (rust_identifier_start_p (*next
) || *next
== '.')
932 end_index
= subexps
[0].rm_eo
;
934 could_be_decimal
= 1;
939 /* Compute the type name if we haven't already. */
940 std::string type_name_holder
;
941 if (type_name
== NULL
)
943 gdb_assert (type_index
!= -1);
944 type_name_holder
= std::string ((pstate
->lexptr
945 + subexps
[type_index
].rm_so
),
946 (subexps
[type_index
].rm_eo
947 - subexps
[type_index
].rm_so
));
948 type_name
= type_name_holder
.c_str ();
951 /* Look up the type. */
952 type
= get_type (type_name
);
954 /* Copy the text of the number and remove the "_"s. */
956 for (i
= 0; i
< end_index
&& pstate
->lexptr
[i
]; ++i
)
958 if (pstate
->lexptr
[i
] == '_')
959 could_be_decimal
= 0;
961 number
.push_back (pstate
->lexptr
[i
]);
964 /* Advance past the match. */
965 pstate
->lexptr
+= subexps
[0].rm_eo
;
967 /* Parse the number. */
974 if (number
[0] == '0')
976 if (number
[1] == 'x')
978 else if (number
[1] == 'o')
980 else if (number
[1] == 'b')
985 could_be_decimal
= 0;
989 value
= strtoulst (number
.c_str () + offset
, NULL
, radix
);
990 if (implicit_i32
&& value
>= ((uint64_t) 1) << 31)
991 type
= get_type ("i64");
993 current_int_val
.val
= value
;
994 current_int_val
.type
= type
;
998 current_float_val
.type
= type
;
999 bool parsed
= parse_float (number
.c_str (), number
.length (),
1000 current_float_val
.type
,
1001 current_float_val
.val
.data ());
1002 gdb_assert (parsed
);
1005 return is_integer
? (could_be_decimal
? DECIMAL_INTEGER
: INTEGER
) : FLOAT
;
1011 rust_parser::lex_one_token ()
1013 /* Skip all leading whitespace. */
1014 while (pstate
->lexptr
[0] == ' '
1015 || pstate
->lexptr
[0] == '\t'
1016 || pstate
->lexptr
[0] == '\r'
1017 || pstate
->lexptr
[0] == '\n')
1020 /* If we hit EOF and we're completing, then return COMPLETE -- maybe
1021 we're completing an empty string at the end of a field_expr.
1022 But, we don't want to return two COMPLETE tokens in a row. */
1023 if (pstate
->lexptr
[0] == '\0' && pstate
->lexptr
== pstate
->prev_lexptr
)
1025 pstate
->prev_lexptr
= pstate
->lexptr
;
1026 if (pstate
->lexptr
[0] == '\0')
1028 if (pstate
->parse_completion
)
1030 current_string_val
.length
=0;
1031 current_string_val
.ptr
= "";
1037 if (pstate
->lexptr
[0] >= '0' && pstate
->lexptr
[0] <= '9')
1038 return lex_number ();
1039 else if (pstate
->lexptr
[0] == 'b' && pstate
->lexptr
[1] == '\'')
1040 return lex_character ();
1041 else if (pstate
->lexptr
[0] == 'b' && pstate
->lexptr
[1] == '"')
1042 return lex_string ();
1043 else if (pstate
->lexptr
[0] == 'b' && starts_raw_string (pstate
->lexptr
+ 1))
1044 return lex_string ();
1045 else if (starts_raw_string (pstate
->lexptr
))
1046 return lex_string ();
1047 else if (rust_identifier_start_p (pstate
->lexptr
[0]))
1048 return lex_identifier ();
1049 else if (pstate
->lexptr
[0] == '"')
1050 return lex_string ();
1051 else if (pstate
->lexptr
[0] == '\'')
1052 return lex_character ();
1053 else if (pstate
->lexptr
[0] == '}' || pstate
->lexptr
[0] == ']')
1055 /* Falls through to lex_operator. */
1058 else if (pstate
->lexptr
[0] == '(' || pstate
->lexptr
[0] == '{')
1060 /* Falls through to lex_operator. */
1063 else if (pstate
->lexptr
[0] == ',' && pstate
->comma_terminates
1064 && paren_depth
== 0)
1067 return lex_operator ();
1070 /* Push back a single character to be re-lexed. */
1073 rust_parser::push_back (char c
)
1075 /* Can't be called before any lexing. */
1076 gdb_assert (pstate
->prev_lexptr
!= NULL
);
1079 gdb_assert (*pstate
->lexptr
== c
);
1084 /* Parse a tuple or paren expression. */
1087 rust_parser::parse_tuple ()
1091 if (current_token
== ')')
1094 struct type
*unit
= get_type ("()");
1095 return make_operation
<long_const_operation
> (unit
, 0);
1098 operation_up expr
= parse_expr ();
1099 if (current_token
== ')')
1101 /* Parenthesized expression. */
1106 std::vector
<operation_up
> ops
;
1107 ops
.push_back (std::move (expr
));
1108 while (current_token
!= ')')
1110 if (current_token
!= ',')
1111 error (_("',' or ')' expected"));
1114 /* A trailing "," is ok. */
1115 if (current_token
!= ')')
1116 ops
.push_back (parse_expr ());
1121 error (_("Tuple expressions not supported yet"));
1124 /* Parse an array expression. */
1127 rust_parser::parse_array ()
1131 if (current_token
== KW_MUT
)
1134 operation_up result
;
1135 operation_up expr
= parse_expr ();
1136 if (current_token
== ';')
1139 operation_up rhs
= parse_expr ();
1140 result
= make_operation
<rust_array_operation
> (std::move (expr
),
1143 else if (current_token
== ',')
1145 std::vector
<operation_up
> ops
;
1146 ops
.push_back (std::move (expr
));
1147 while (current_token
!= ']')
1149 if (current_token
!= ',')
1150 error (_("',' or ']' expected"));
1152 ops
.push_back (parse_expr ());
1154 ops
.shrink_to_fit ();
1155 int len
= ops
.size () - 1;
1156 result
= make_operation
<array_operation
> (0, len
, std::move (ops
));
1158 else if (current_token
!= ']')
1159 error (_("',', ';', or ']' expected"));
1166 /* Turn a name into an operation. */
1169 rust_parser::name_to_operation (const std::string
&name
)
1171 struct block_symbol sym
= lookup_symbol (name
.c_str (),
1172 pstate
->expression_context_block
,
1174 if (sym
.symbol
!= nullptr && SYMBOL_CLASS (sym
.symbol
) != LOC_TYPEDEF
)
1175 return make_operation
<var_value_operation
> (sym
);
1177 struct type
*type
= nullptr;
1179 if (sym
.symbol
!= nullptr)
1181 gdb_assert (SYMBOL_CLASS (sym
.symbol
) == LOC_TYPEDEF
);
1182 type
= SYMBOL_TYPE (sym
.symbol
);
1184 if (type
== nullptr)
1185 type
= rust_lookup_type (name
.c_str ());
1186 if (type
== nullptr)
1187 error (_("No symbol '%s' in current context"), name
.c_str ());
1189 if (type
->code () == TYPE_CODE_STRUCT
&& type
->num_fields () == 0)
1191 /* A unit-like struct. */
1192 operation_up
result (new rust_aggregate_operation (type
, {}, {}));
1196 return make_operation
<type_operation
> (type
);
1199 /* Parse a struct expression. */
1202 rust_parser::parse_struct_expr (struct type
*type
)
1206 if (type
->code () != TYPE_CODE_STRUCT
1207 || rust_tuple_type_p (type
)
1208 || rust_tuple_struct_type_p (type
))
1209 error (_("Struct expression applied to non-struct type"));
1211 std::vector
<std::pair
<std::string
, operation_up
>> field_v
;
1212 while (current_token
!= '}' && current_token
!= DOTDOT
)
1214 if (current_token
!= IDENT
)
1215 error (_("'}', '..', or identifier expected"));
1217 std::string name
= get_string ();
1221 if (current_token
== ',' || current_token
== '}'
1222 || current_token
== DOTDOT
)
1223 expr
= name_to_operation (name
);
1227 expr
= parse_expr ();
1229 field_v
.emplace_back (std::move (name
), std::move (expr
));
1231 /* A trailing "," is ok. */
1232 if (current_token
== ',')
1236 operation_up others
;
1237 if (current_token
== DOTDOT
)
1240 others
= parse_expr ();
1245 return make_operation
<rust_aggregate_operation
> (type
,
1247 std::move (field_v
));
1250 /* Used by the operator precedence parser. */
1253 rustop_item (int token_
, int precedence_
, enum exp_opcode opcode_
,
1256 precedence (precedence_
),
1258 op (std::move (op_
))
1262 /* The token value. */
1264 /* Precedence of this operator. */
1266 /* This is used only for assign-modify. */
1267 enum exp_opcode opcode
;
1268 /* The right hand side of this operation. */
1272 /* An operator precedence parser for binary operations, including
1276 rust_parser::parse_binop (bool required
)
1278 /* All the binary operators. Each one is of the form
1279 OPERATION(TOKEN, PRECEDENCE, TYPE)
1280 TOKEN is the corresponding operator token.
1281 PRECEDENCE is a value indicating relative precedence.
1282 TYPE is the operation type corresponding to the operator.
1283 Assignment operations are handled specially, not via this
1284 table; they have precedence 0. */
1286 OPERATION ('*', 10, mul_operation) \
1287 OPERATION ('/', 10, div_operation) \
1288 OPERATION ('%', 10, rem_operation) \
1289 OPERATION ('@', 9, repeat_operation) \
1290 OPERATION ('+', 8, add_operation) \
1291 OPERATION ('-', 8, sub_operation) \
1292 OPERATION (LSH, 7, lsh_operation) \
1293 OPERATION (RSH, 7, rsh_operation) \
1294 OPERATION ('&', 6, bitwise_and_operation) \
1295 OPERATION ('^', 5, bitwise_xor_operation) \
1296 OPERATION ('|', 4, bitwise_ior_operation) \
1297 OPERATION (EQEQ, 3, equal_operation) \
1298 OPERATION (NOTEQ, 3, notequal_operation) \
1299 OPERATION ('<', 3, less_operation) \
1300 OPERATION (LTEQ, 3, leq_operation) \
1301 OPERATION ('>', 3, gtr_operation) \
1302 OPERATION (GTEQ, 3, geq_operation) \
1303 OPERATION (ANDAND, 2, logical_and_operation) \
1304 OPERATION (OROR, 1, logical_or_operation)
1306 operation_up start
= parse_atom (required
);
1307 if (start
== nullptr)
1309 gdb_assert (!required
);
1313 std::vector
<rustop_item
> operator_stack
;
1314 operator_stack
.emplace_back (0, -1, OP_NULL
, std::move (start
));
1318 int this_token
= current_token
;
1319 enum exp_opcode compound_assign_op
= OP_NULL
;
1320 int precedence
= -2;
1324 #define OPERATION(TOKEN, PRECEDENCE, TYPE) \
1326 precedence = PRECEDENCE; \
1334 case COMPOUND_ASSIGN
:
1335 compound_assign_op
= current_opcode
;
1342 /* "as" must be handled specially. */
1346 rustop_item
&lhs
= operator_stack
.back ();
1347 struct type
*type
= parse_type ();
1348 lhs
.op
= make_operation
<unop_cast_operation
> (std::move (lhs
.op
),
1351 /* Bypass the rest of the loop. */
1355 /* Arrange to pop the entire stack. */
1360 while (precedence
< operator_stack
.back ().precedence
1361 && operator_stack
.size () > 1)
1363 rustop_item rhs
= std::move (operator_stack
.back ());
1364 operator_stack
.pop_back ();
1366 rustop_item
&lhs
= operator_stack
.back ();
1370 #define OPERATION(TOKEN, PRECEDENCE, TYPE) \
1372 lhs.op = make_operation<TYPE> (std::move (lhs.op), \
1373 std::move (rhs.op)); \
1381 case COMPOUND_ASSIGN
:
1383 if (rhs
.token
== '=')
1384 lhs
.op
= (make_operation
<assign_operation
>
1385 (std::move (lhs
.op
), std::move (rhs
.op
)));
1387 lhs
.op
= (make_operation
<assign_modify_operation
>
1388 (rhs
.opcode
, std::move (lhs
.op
),
1389 std::move (rhs
.op
)));
1391 struct type
*unit_type
= get_type ("()");
1393 operation_up
nil (new long_const_operation (unit_type
, 0));
1394 lhs
.op
= (make_operation
<comma_operation
>
1395 (std::move (lhs
.op
), std::move (nil
)));
1400 gdb_assert_not_reached ("bad binary operator");
1404 if (precedence
== -2)
1407 operator_stack
.emplace_back (this_token
, precedence
, compound_assign_op
,
1411 gdb_assert (operator_stack
.size () == 1);
1412 return std::move (operator_stack
[0].op
);
1416 /* Parse a range expression. */
1419 rust_parser::parse_range ()
1421 enum range_flag kind
= (RANGE_HIGH_BOUND_DEFAULT
1422 | RANGE_LOW_BOUND_DEFAULT
);
1425 if (current_token
!= DOTDOT
&& current_token
!= DOTDOTEQ
)
1427 lhs
= parse_binop (true);
1428 kind
&= ~RANGE_LOW_BOUND_DEFAULT
;
1431 if (current_token
== DOTDOT
)
1432 kind
|= RANGE_HIGH_BOUND_EXCLUSIVE
;
1433 else if (current_token
!= DOTDOTEQ
)
1437 /* A "..=" range requires a high bound, but otherwise it is
1439 operation_up rhs
= parse_binop ((kind
& RANGE_HIGH_BOUND_EXCLUSIVE
) == 0);
1441 kind
&= ~RANGE_HIGH_BOUND_DEFAULT
;
1443 return make_operation
<rust_range_operation
> (kind
,
1448 /* Parse an expression. */
1451 rust_parser::parse_expr ()
1453 return parse_range ();
1456 /* Parse a sizeof expression. */
1459 rust_parser::parse_sizeof ()
1464 operation_up result
= make_operation
<unop_sizeof_operation
> (parse_expr ());
1469 /* Parse an address-of operation. */
1472 rust_parser::parse_addr ()
1476 if (current_token
== KW_MUT
)
1479 return make_operation
<rust_unop_addr_operation
> (parse_atom (true));
1482 /* Parse a field expression. */
1485 rust_parser::parse_field (operation_up
&&lhs
)
1489 operation_up result
;
1490 switch (current_token
)
1495 bool is_complete
= current_token
== COMPLETE
;
1496 auto struct_op
= new rust_structop (std::move (lhs
), get_string ());
1500 completion_op
.reset (struct_op
);
1501 pstate
->mark_struct_expression (struct_op
);
1502 /* Throw to the outermost level of the parser. */
1503 error (_("not really an error"));
1505 result
.reset (struct_op
);
1509 case DECIMAL_INTEGER
:
1510 result
= make_operation
<rust_struct_anon
> (current_int_val
.val
,
1516 error (_("'_' not allowed in integers in anonymous field references"));
1519 error (_("field name expected"));
1525 /* Parse an index expression. */
1528 rust_parser::parse_index (operation_up
&&lhs
)
1531 operation_up rhs
= parse_expr ();
1534 return make_operation
<rust_subscript_operation
> (std::move (lhs
),
1538 /* Parse a sequence of comma-separated expressions in parens. */
1540 std::vector
<operation_up
>
1541 rust_parser::parse_paren_args ()
1545 std::vector
<operation_up
> args
;
1546 while (current_token
!= ')')
1550 if (current_token
!= ',')
1551 error (_("',' or ')' expected"));
1555 args
.push_back (parse_expr ());
1563 /* Parse the parenthesized part of a function call. */
1566 rust_parser::parse_call (operation_up
&&lhs
)
1568 std::vector
<operation_up
> args
= parse_paren_args ();
1570 return make_operation
<funcall_operation
> (std::move (lhs
),
1574 /* Parse a list of types. */
1576 std::vector
<struct type
*>
1577 rust_parser::parse_type_list ()
1579 std::vector
<struct type
*> result
;
1580 result
.push_back (parse_type ());
1581 while (current_token
== ',')
1584 result
.push_back (parse_type ());
1589 /* Parse a possibly-empty list of types, surrounded in parens. */
1591 std::vector
<struct type
*>
1592 rust_parser::parse_maybe_type_list ()
1595 std::vector
<struct type
*> types
;
1596 if (current_token
!= ')')
1597 types
= parse_type_list ();
1602 /* Parse an array type. */
1605 rust_parser::parse_array_type ()
1608 struct type
*elt_type
= parse_type ();
1611 if (current_token
!= INTEGER
&& current_token
!= DECIMAL_INTEGER
)
1612 error (_("integer expected"));
1613 ULONGEST val
= current_int_val
.val
;
1617 return lookup_array_range_type (elt_type
, 0, val
- 1);
1620 /* Parse a slice type. */
1623 rust_parser::parse_slice_type ()
1627 bool is_slice
= current_token
== '[';
1631 struct type
*target
= parse_type ();
1636 return rust_slice_type ("&[*gdb*]", target
, get_type ("usize"));
1639 /* For now we treat &x and *x identically. */
1640 return lookup_pointer_type (target
);
1643 /* Parse a pointer type. */
1646 rust_parser::parse_pointer_type ()
1650 if (current_token
== KW_MUT
|| current_token
== KW_CONST
)
1653 struct type
*target
= parse_type ();
1654 /* For the time being we ignore mut/const. */
1655 return lookup_pointer_type (target
);
1658 /* Parse a function type. */
1661 rust_parser::parse_function_type ()
1665 if (current_token
!= '(')
1666 error (_("'(' expected"));
1668 std::vector
<struct type
*> types
= parse_maybe_type_list ();
1670 if (current_token
!= ARROW
)
1671 error (_("'->' expected"));
1674 struct type
*result_type
= parse_type ();
1676 struct type
**argtypes
= nullptr;
1677 if (!types
.empty ())
1678 argtypes
= types
.data ();
1680 result_type
= lookup_function_type_with_arguments (result_type
,
1683 return lookup_pointer_type (result_type
);
1686 /* Parse a tuple type. */
1689 rust_parser::parse_tuple_type ()
1691 std::vector
<struct type
*> types
= parse_maybe_type_list ();
1693 auto_obstack obstack
;
1694 obstack_1grow (&obstack
, '(');
1695 for (int i
= 0; i
< types
.size (); ++i
)
1697 std::string type_name
= type_to_string (types
[i
]);
1700 obstack_1grow (&obstack
, ',');
1701 obstack_grow_str (&obstack
, type_name
.c_str ());
1704 obstack_grow_str0 (&obstack
, ")");
1705 const char *name
= (const char *) obstack_finish (&obstack
);
1707 /* We don't allow creating new tuple types (yet), but we do allow
1708 looking up existing tuple types. */
1709 struct type
*result
= rust_lookup_type (name
);
1710 if (result
== nullptr)
1711 error (_("could not find tuple type '%s'"), name
);
1719 rust_parser::parse_type ()
1721 switch (current_token
)
1724 return parse_array_type ();
1726 return parse_slice_type ();
1728 return parse_pointer_type ();
1730 return parse_function_type ();
1732 return parse_tuple_type ();
1739 std::string path
= parse_path (false);
1740 struct type
*result
= rust_lookup_type (path
.c_str ());
1741 if (result
== nullptr)
1742 error (_("No type name '%s' in current context"), path
.c_str ());
1746 error (_("type expected"));
1753 rust_parser::parse_path (bool for_expr
)
1755 unsigned n_supers
= 0;
1756 int first_token
= current_token
;
1758 switch (current_token
)
1762 if (current_token
!= COLONCOLON
)
1767 while (current_token
== KW_SUPER
)
1771 if (current_token
!= COLONCOLON
)
1772 error (_("'::' expected"));
1782 /* This is a gdb extension to make it possible to refer to items
1783 in other crates. It just bypasses adding the current crate
1784 to the front of the name. */
1789 if (current_token
!= IDENT
)
1790 error (_("identifier expected"));
1791 std::string path
= get_string ();
1792 bool saw_ident
= true;
1795 /* The condition here lets us enter the loop even if we see
1797 while (current_token
== COLONCOLON
|| current_token
== '<')
1799 if (current_token
== COLONCOLON
)
1804 if (current_token
== IDENT
)
1806 path
= path
+ "::" + get_string ();
1810 else if (current_token
== COLONCOLON
)
1812 /* The code below won't detect this scenario. */
1813 error (_("unexpected '::'"));
1817 if (current_token
!= '<')
1820 /* Expression use name::<...>, whereas types use name<...>. */
1823 /* Expressions use "name::<...>", so if we saw an identifier
1824 after the "::", we ignore the "<" here. */
1830 /* Types use "name<...>", so we need to have seen the
1837 std::vector
<struct type
*> types
= parse_type_list ();
1838 if (current_token
== '>')
1840 else if (current_token
== RSH
)
1846 error (_("'>' expected"));
1849 for (int i
= 0; i
< types
.size (); ++i
)
1853 path
+= type_to_string (types
[i
]);
1859 switch (first_token
)
1863 return super_name (path
, n_supers
);
1866 return crate_name (path
);
1875 gdb_assert_not_reached ("missing case in path parsing");
1879 /* Handle the parsing for a string expression. */
1882 rust_parser::parse_string ()
1884 gdb_assert (current_token
== STRING
);
1886 /* Wrap the raw string in the &str struct. */
1887 struct type
*type
= rust_lookup_type ("&str");
1888 if (type
== nullptr)
1889 error (_("Could not find type '&str'"));
1891 std::vector
<std::pair
<std::string
, operation_up
>> field_v
;
1893 size_t len
= current_string_val
.length
;
1894 operation_up str
= make_operation
<string_operation
> (get_string ());
1896 = make_operation
<rust_unop_addr_operation
> (std::move (str
));
1897 field_v
.emplace_back ("data_ptr", std::move (addr
));
1899 struct type
*valtype
= get_type ("usize");
1900 operation_up lenop
= make_operation
<long_const_operation
> (valtype
, len
);
1901 field_v
.emplace_back ("length", std::move (lenop
));
1903 return make_operation
<rust_aggregate_operation
> (type
,
1905 std::move (field_v
));
1908 /* Parse a tuple struct expression. */
1911 rust_parser::parse_tuple_struct (struct type
*type
)
1913 std::vector
<operation_up
> args
= parse_paren_args ();
1915 std::vector
<std::pair
<std::string
, operation_up
>> field_v (args
.size ());
1916 for (int i
= 0; i
< args
.size (); ++i
)
1917 field_v
[i
] = { string_printf ("__%d", i
), std::move (args
[i
]) };
1919 return (make_operation
<rust_aggregate_operation
>
1920 (type
, operation_up (), std::move (field_v
)));
1923 /* Parse a path expression. */
1926 rust_parser::parse_path_expr ()
1928 std::string path
= parse_path (true);
1930 if (current_token
== '{')
1932 struct type
*type
= rust_lookup_type (path
.c_str ());
1933 if (type
== nullptr)
1934 error (_("Could not find type '%s'"), path
.c_str ());
1936 return parse_struct_expr (type
);
1938 else if (current_token
== '(')
1940 struct type
*type
= rust_lookup_type (path
.c_str ());
1941 /* If this is actually a tuple struct expression, handle it
1942 here. If it is a call, it will be handled elsewhere. */
1943 if (type
!= nullptr)
1945 if (!rust_tuple_struct_type_p (type
))
1946 error (_("Type %s is not a tuple struct"), path
.c_str ());
1947 return parse_tuple_struct (type
);
1951 return name_to_operation (path
);
1954 /* Parse an atom. "Atom" isn't a Rust term, but this refers to a
1955 single unitary item in the grammar; but here including some unary
1956 prefix and postfix expressions. */
1959 rust_parser::parse_atom (bool required
)
1961 operation_up result
;
1963 switch (current_token
)
1966 result
= parse_tuple ();
1970 result
= parse_array ();
1974 case DECIMAL_INTEGER
:
1975 result
= make_operation
<long_const_operation
> (current_int_val
.type
,
1976 current_int_val
.val
);
1981 result
= make_operation
<float_const_operation
> (current_float_val
.type
,
1982 current_float_val
.val
);
1987 result
= parse_string ();
1991 result
= make_operation
<string_operation
> (get_string ());
1997 result
= make_operation
<bool_operation
> (current_token
== KW_TRUE
);
2002 /* This is kind of a hacky approach. */
2004 pstate
->push_dollar (current_string_val
);
2005 result
= pstate
->pop ();
2015 result
= parse_path_expr ();
2020 result
= make_operation
<rust_unop_ind_operation
> (parse_atom (true));
2024 result
= make_operation
<unary_plus_operation
> (parse_atom (true));
2028 result
= make_operation
<unary_neg_operation
> (parse_atom (true));
2032 result
= make_operation
<rust_unop_compl_operation
> (parse_atom (true));
2035 result
= parse_sizeof ();
2038 result
= parse_addr ();
2044 error (_("unexpected token"));
2047 /* Now parse suffixes. */
2050 switch (current_token
)
2053 result
= parse_field (std::move (result
));
2057 result
= parse_index (std::move (result
));
2061 result
= parse_call (std::move (result
));
2072 /* The parser as exposed to gdb. */
2075 rust_language::parser (struct parser_state
*state
) const
2077 rust_parser
parser (state
);
2079 operation_up result
;
2082 result
= parser
.parse_entry_point ();
2084 catch (const gdb_exception
&exc
)
2086 if (state
->parse_completion
)
2088 result
= std::move (parser
.completion_op
);
2089 if (result
== nullptr)
2096 state
->set_operation (std::move (result
));
2105 /* A test helper that lexes a string, expecting a single token. */
2108 rust_lex_test_one (rust_parser
*parser
, const char *input
, int expected
)
2112 parser
->reset (input
);
2114 token
= parser
->lex_one_token ();
2115 SELF_CHECK (token
== expected
);
2119 token
= parser
->lex_one_token ();
2120 SELF_CHECK (token
== 0);
2124 /* Test that INPUT lexes as the integer VALUE. */
2127 rust_lex_int_test (rust_parser
*parser
, const char *input
,
2128 ULONGEST value
, int kind
)
2130 rust_lex_test_one (parser
, input
, kind
);
2131 SELF_CHECK (parser
->current_int_val
.val
== value
);
2134 /* Test that INPUT throws an exception with text ERR. */
2137 rust_lex_exception_test (rust_parser
*parser
, const char *input
,
2142 /* The "kind" doesn't matter. */
2143 rust_lex_test_one (parser
, input
, DECIMAL_INTEGER
);
2146 catch (const gdb_exception_error
&except
)
2148 SELF_CHECK (strcmp (except
.what (), err
) == 0);
2152 /* Test that INPUT lexes as the identifier, string, or byte-string
2153 VALUE. KIND holds the expected token kind. */
2156 rust_lex_stringish_test (rust_parser
*parser
, const char *input
,
2157 const char *value
, int kind
)
2159 rust_lex_test_one (parser
, input
, kind
);
2160 SELF_CHECK (parser
->get_string () == value
);
2163 /* Helper to test that a string parses as a given token sequence. */
2166 rust_lex_test_sequence (rust_parser
*parser
, const char *input
, int len
,
2167 const int expected
[])
2171 parser
->reset (input
);
2173 for (i
= 0; i
< len
; ++i
)
2175 int token
= parser
->lex_one_token ();
2176 SELF_CHECK (token
== expected
[i
]);
2180 /* Tests for an integer-parsing corner case. */
2183 rust_lex_test_trailing_dot (rust_parser
*parser
)
2185 const int expected1
[] = { DECIMAL_INTEGER
, '.', IDENT
, '(', ')', 0 };
2186 const int expected2
[] = { INTEGER
, '.', IDENT
, '(', ')', 0 };
2187 const int expected3
[] = { FLOAT
, EQEQ
, '(', ')', 0 };
2188 const int expected4
[] = { DECIMAL_INTEGER
, DOTDOT
, DECIMAL_INTEGER
, 0 };
2190 rust_lex_test_sequence (parser
, "23.g()", ARRAY_SIZE (expected1
), expected1
);
2191 rust_lex_test_sequence (parser
, "23_0.g()", ARRAY_SIZE (expected2
),
2193 rust_lex_test_sequence (parser
, "23.==()", ARRAY_SIZE (expected3
),
2195 rust_lex_test_sequence (parser
, "23..25", ARRAY_SIZE (expected4
), expected4
);
2198 /* Tests of completion. */
2201 rust_lex_test_completion (rust_parser
*parser
)
2203 const int expected
[] = { IDENT
, '.', COMPLETE
, 0 };
2205 parser
->pstate
->parse_completion
= 1;
2207 rust_lex_test_sequence (parser
, "something.wha", ARRAY_SIZE (expected
),
2209 rust_lex_test_sequence (parser
, "something.", ARRAY_SIZE (expected
),
2212 parser
->pstate
->parse_completion
= 0;
2215 /* Test pushback. */
2218 rust_lex_test_push_back (rust_parser
*parser
)
2222 parser
->reset (">>=");
2224 token
= parser
->lex_one_token ();
2225 SELF_CHECK (token
== COMPOUND_ASSIGN
);
2226 SELF_CHECK (parser
->current_opcode
== BINOP_RSH
);
2228 parser
->push_back ('=');
2230 token
= parser
->lex_one_token ();
2231 SELF_CHECK (token
== '=');
2233 token
= parser
->lex_one_token ();
2234 SELF_CHECK (token
== 0);
2237 /* Unit test the lexer. */
2240 rust_lex_tests (void)
2244 /* Set up dummy "parser", so that rust_type works. */
2245 struct parser_state
ps (language_def (language_rust
), target_gdbarch (),
2246 nullptr, 0, 0, nullptr, 0, nullptr, false);
2247 rust_parser
parser (&ps
);
2249 rust_lex_test_one (&parser
, "", 0);
2250 rust_lex_test_one (&parser
, " \t \n \r ", 0);
2251 rust_lex_test_one (&parser
, "thread 23", 0);
2252 rust_lex_test_one (&parser
, "task 23", 0);
2253 rust_lex_test_one (&parser
, "th 104", 0);
2254 rust_lex_test_one (&parser
, "ta 97", 0);
2256 rust_lex_int_test (&parser
, "'z'", 'z', INTEGER
);
2257 rust_lex_int_test (&parser
, "'\\xff'", 0xff, INTEGER
);
2258 rust_lex_int_test (&parser
, "'\\u{1016f}'", 0x1016f, INTEGER
);
2259 rust_lex_int_test (&parser
, "b'z'", 'z', INTEGER
);
2260 rust_lex_int_test (&parser
, "b'\\xfe'", 0xfe, INTEGER
);
2261 rust_lex_int_test (&parser
, "b'\\xFE'", 0xfe, INTEGER
);
2262 rust_lex_int_test (&parser
, "b'\\xfE'", 0xfe, INTEGER
);
2264 /* Test all escapes in both modes. */
2265 rust_lex_int_test (&parser
, "'\\n'", '\n', INTEGER
);
2266 rust_lex_int_test (&parser
, "'\\r'", '\r', INTEGER
);
2267 rust_lex_int_test (&parser
, "'\\t'", '\t', INTEGER
);
2268 rust_lex_int_test (&parser
, "'\\\\'", '\\', INTEGER
);
2269 rust_lex_int_test (&parser
, "'\\0'", '\0', INTEGER
);
2270 rust_lex_int_test (&parser
, "'\\''", '\'', INTEGER
);
2271 rust_lex_int_test (&parser
, "'\\\"'", '"', INTEGER
);
2273 rust_lex_int_test (&parser
, "b'\\n'", '\n', INTEGER
);
2274 rust_lex_int_test (&parser
, "b'\\r'", '\r', INTEGER
);
2275 rust_lex_int_test (&parser
, "b'\\t'", '\t', INTEGER
);
2276 rust_lex_int_test (&parser
, "b'\\\\'", '\\', INTEGER
);
2277 rust_lex_int_test (&parser
, "b'\\0'", '\0', INTEGER
);
2278 rust_lex_int_test (&parser
, "b'\\''", '\'', INTEGER
);
2279 rust_lex_int_test (&parser
, "b'\\\"'", '"', INTEGER
);
2281 rust_lex_exception_test (&parser
, "'z", "Unterminated character literal");
2282 rust_lex_exception_test (&parser
, "b'\\x0'", "Not enough hex digits seen");
2283 rust_lex_exception_test (&parser
, "b'\\u{0}'",
2284 "Unicode escape in byte literal");
2285 rust_lex_exception_test (&parser
, "'\\x0'", "Not enough hex digits seen");
2286 rust_lex_exception_test (&parser
, "'\\u0'", "Missing '{' in Unicode escape");
2287 rust_lex_exception_test (&parser
, "'\\u{0", "Missing '}' in Unicode escape");
2288 rust_lex_exception_test (&parser
, "'\\u{0000007}", "Overlong hex escape");
2289 rust_lex_exception_test (&parser
, "'\\u{}", "Not enough hex digits seen");
2290 rust_lex_exception_test (&parser
, "'\\Q'", "Invalid escape \\Q in literal");
2291 rust_lex_exception_test (&parser
, "b'\\Q'", "Invalid escape \\Q in literal");
2293 rust_lex_int_test (&parser
, "23", 23, DECIMAL_INTEGER
);
2294 rust_lex_int_test (&parser
, "2_344__29", 234429, INTEGER
);
2295 rust_lex_int_test (&parser
, "0x1f", 0x1f, INTEGER
);
2296 rust_lex_int_test (&parser
, "23usize", 23, INTEGER
);
2297 rust_lex_int_test (&parser
, "23i32", 23, INTEGER
);
2298 rust_lex_int_test (&parser
, "0x1_f", 0x1f, INTEGER
);
2299 rust_lex_int_test (&parser
, "0b1_101011__", 0x6b, INTEGER
);
2300 rust_lex_int_test (&parser
, "0o001177i64", 639, INTEGER
);
2301 rust_lex_int_test (&parser
, "0x123456789u64", 0x123456789ull
, INTEGER
);
2303 rust_lex_test_trailing_dot (&parser
);
2305 rust_lex_test_one (&parser
, "23.", FLOAT
);
2306 rust_lex_test_one (&parser
, "23.99f32", FLOAT
);
2307 rust_lex_test_one (&parser
, "23e7", FLOAT
);
2308 rust_lex_test_one (&parser
, "23E-7", FLOAT
);
2309 rust_lex_test_one (&parser
, "23e+7", FLOAT
);
2310 rust_lex_test_one (&parser
, "23.99e+7f64", FLOAT
);
2311 rust_lex_test_one (&parser
, "23.82f32", FLOAT
);
2313 rust_lex_stringish_test (&parser
, "hibob", "hibob", IDENT
);
2314 rust_lex_stringish_test (&parser
, "hibob__93", "hibob__93", IDENT
);
2315 rust_lex_stringish_test (&parser
, "thread", "thread", IDENT
);
2316 rust_lex_stringish_test (&parser
, "r#true", "true", IDENT
);
2318 const int expected1
[] = { IDENT
, DECIMAL_INTEGER
, 0 };
2319 rust_lex_test_sequence (&parser
, "r#thread 23", ARRAY_SIZE (expected1
),
2321 const int expected2
[] = { IDENT
, '#', 0 };
2322 rust_lex_test_sequence (&parser
, "r#", ARRAY_SIZE (expected2
), expected2
);
2324 rust_lex_stringish_test (&parser
, "\"string\"", "string", STRING
);
2325 rust_lex_stringish_test (&parser
, "\"str\\ting\"", "str\ting", STRING
);
2326 rust_lex_stringish_test (&parser
, "\"str\\\"ing\"", "str\"ing", STRING
);
2327 rust_lex_stringish_test (&parser
, "r\"str\\ing\"", "str\\ing", STRING
);
2328 rust_lex_stringish_test (&parser
, "r#\"str\\ting\"#", "str\\ting", STRING
);
2329 rust_lex_stringish_test (&parser
, "r###\"str\\\"ing\"###", "str\\\"ing",
2332 rust_lex_stringish_test (&parser
, "b\"string\"", "string", BYTESTRING
);
2333 rust_lex_stringish_test (&parser
, "b\"\x73tring\"", "string", BYTESTRING
);
2334 rust_lex_stringish_test (&parser
, "b\"str\\\"ing\"", "str\"ing", BYTESTRING
);
2335 rust_lex_stringish_test (&parser
, "br####\"\\x73tring\"####", "\\x73tring",
2338 for (i
= 0; i
< ARRAY_SIZE (identifier_tokens
); ++i
)
2339 rust_lex_test_one (&parser
, identifier_tokens
[i
].name
,
2340 identifier_tokens
[i
].value
);
2342 for (i
= 0; i
< ARRAY_SIZE (operator_tokens
); ++i
)
2343 rust_lex_test_one (&parser
, operator_tokens
[i
].name
,
2344 operator_tokens
[i
].value
);
2346 rust_lex_test_completion (&parser
);
2347 rust_lex_test_push_back (&parser
);
2350 #endif /* GDB_SELF_TEST */
2354 void _initialize_rust_exp ();
2356 _initialize_rust_exp ()
2358 int code
= regcomp (&number_regex
, number_regex_text
, REG_EXTENDED
);
2359 /* If the regular expression was incorrect, it was a programming
2361 gdb_assert (code
== 0);
2364 selftests::register_test ("rust-lex", rust_lex_tests
);