| /* Rust expression parsing for GDB, the GNU debugger. |
| |
| Copyright (C) 2016-2021 Free Software Foundation, Inc. |
| |
| This file is part of GDB. |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 3 of the License, or |
| (at your option) any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
| |
| #include "defs.h" |
| |
| #include "block.h" |
| #include "charset.h" |
| #include "cp-support.h" |
| #include "gdb_obstack.h" |
| #include "gdb_regex.h" |
| #include "rust-lang.h" |
| #include "parser-defs.h" |
| #include "gdbsupport/selftest.h" |
| #include "value.h" |
| #include "gdbarch.h" |
| #include "rust-exp.h" |
| |
| using namespace expr; |
| |
| /* A regular expression for matching Rust numbers. This is split up |
| since it is very long and this gives us a way to comment the |
| sections. */ |
| |
| static const char number_regex_text[] = |
| /* subexpression 1: allows use of alternation, otherwise uninteresting */ |
| "^(" |
| /* First comes floating point. */ |
| /* Recognize number after the decimal point, with optional |
| exponent and optional type suffix. |
| subexpression 2: allows "?", otherwise uninteresting |
| subexpression 3: if present, type suffix |
| */ |
| "[0-9][0-9_]*\\.[0-9][0-9_]*([eE][-+]?[0-9][0-9_]*)?(f32|f64)?" |
| #define FLOAT_TYPE1 3 |
| "|" |
| /* Recognize exponent without decimal point, with optional type |
| suffix. |
| subexpression 4: if present, type suffix |
| */ |
| #define FLOAT_TYPE2 4 |
| "[0-9][0-9_]*[eE][-+]?[0-9][0-9_]*(f32|f64)?" |
| "|" |
| /* "23." is a valid floating point number, but "23.e5" and |
| "23.f32" are not. So, handle the trailing-. case |
| separately. */ |
| "[0-9][0-9_]*\\." |
| "|" |
| /* Finally come integers. |
| subexpression 5: text of integer |
| subexpression 6: if present, type suffix |
| subexpression 7: allows use of alternation, otherwise uninteresting |
| */ |
| #define INT_TEXT 5 |
| #define INT_TYPE 6 |
| "(0x[a-fA-F0-9_]+|0o[0-7_]+|0b[01_]+|[0-9][0-9_]*)" |
| "([iu](size|8|16|32|64))?" |
| ")"; |
| /* The number of subexpressions to allocate space for, including the |
| "0th" whole match subexpression. */ |
| #define NUM_SUBEXPRESSIONS 8 |
| |
| /* The compiled number-matching regex. */ |
| |
| static regex_t number_regex; |
| |
| /* The kinds of tokens. Note that single-character tokens are |
| represented by themselves, so for instance '[' is a token. */ |
| enum token_type : int |
| { |
| /* Make sure to start after any ASCII character. */ |
| GDBVAR = 256, |
| IDENT, |
| COMPLETE, |
| INTEGER, |
| DECIMAL_INTEGER, |
| STRING, |
| BYTESTRING, |
| FLOAT, |
| COMPOUND_ASSIGN, |
| |
| /* Keyword tokens. */ |
| KW_AS, |
| KW_IF, |
| KW_TRUE, |
| KW_FALSE, |
| KW_SUPER, |
| KW_SELF, |
| KW_MUT, |
| KW_EXTERN, |
| KW_CONST, |
| KW_FN, |
| KW_SIZEOF, |
| |
| /* Operator tokens. */ |
| DOTDOT, |
| DOTDOTEQ, |
| OROR, |
| ANDAND, |
| EQEQ, |
| NOTEQ, |
| LTEQ, |
| GTEQ, |
| LSH, |
| RSH, |
| COLONCOLON, |
| ARROW, |
| }; |
| |
| /* A typed integer constant. */ |
| |
| struct typed_val_int |
| { |
| ULONGEST val; |
| struct type *type; |
| }; |
| |
| /* A typed floating point constant. */ |
| |
| struct typed_val_float |
| { |
| float_data val; |
| struct type *type; |
| }; |
| |
| /* A struct of this type is used to describe a token. */ |
| |
| struct token_info |
| { |
| const char *name; |
| int value; |
| enum exp_opcode opcode; |
| }; |
| |
| /* Identifier tokens. */ |
| |
| static const struct token_info identifier_tokens[] = |
| { |
| { "as", KW_AS, OP_NULL }, |
| { "false", KW_FALSE, OP_NULL }, |
| { "if", 0, OP_NULL }, |
| { "mut", KW_MUT, OP_NULL }, |
| { "const", KW_CONST, OP_NULL }, |
| { "self", KW_SELF, OP_NULL }, |
| { "super", KW_SUPER, OP_NULL }, |
| { "true", KW_TRUE, OP_NULL }, |
| { "extern", KW_EXTERN, OP_NULL }, |
| { "fn", KW_FN, OP_NULL }, |
| { "sizeof", KW_SIZEOF, OP_NULL }, |
| }; |
| |
| /* Operator tokens, sorted longest first. */ |
| |
| static const struct token_info operator_tokens[] = |
| { |
| { ">>=", COMPOUND_ASSIGN, BINOP_RSH }, |
| { "<<=", COMPOUND_ASSIGN, BINOP_LSH }, |
| |
| { "<<", LSH, OP_NULL }, |
| { ">>", RSH, OP_NULL }, |
| { "&&", ANDAND, OP_NULL }, |
| { "||", OROR, OP_NULL }, |
| { "==", EQEQ, OP_NULL }, |
| { "!=", NOTEQ, OP_NULL }, |
| { "<=", LTEQ, OP_NULL }, |
| { ">=", GTEQ, OP_NULL }, |
| { "+=", COMPOUND_ASSIGN, BINOP_ADD }, |
| { "-=", COMPOUND_ASSIGN, BINOP_SUB }, |
| { "*=", COMPOUND_ASSIGN, BINOP_MUL }, |
| { "/=", COMPOUND_ASSIGN, BINOP_DIV }, |
| { "%=", COMPOUND_ASSIGN, BINOP_REM }, |
| { "&=", COMPOUND_ASSIGN, BINOP_BITWISE_AND }, |
| { "|=", COMPOUND_ASSIGN, BINOP_BITWISE_IOR }, |
| { "^=", COMPOUND_ASSIGN, BINOP_BITWISE_XOR }, |
| { "..=", DOTDOTEQ, OP_NULL }, |
| |
| { "::", COLONCOLON, OP_NULL }, |
| { "..", DOTDOT, OP_NULL }, |
| { "->", ARROW, OP_NULL } |
| }; |
| |
| /* An instance of this is created before parsing, and destroyed when |
| parsing is finished. */ |
| |
| struct rust_parser |
| { |
| explicit rust_parser (struct parser_state *state) |
| : pstate (state) |
| { |
| } |
| |
| DISABLE_COPY_AND_ASSIGN (rust_parser); |
| |
| /* Return the parser's language. */ |
| const struct language_defn *language () const |
| { |
| return pstate->language (); |
| } |
| |
| /* Return the parser's gdbarch. */ |
| struct gdbarch *arch () const |
| { |
| return pstate->gdbarch (); |
| } |
| |
| /* A helper to look up a Rust type, or fail. This only works for |
| types defined by rust_language_arch_info. */ |
| |
| struct type *get_type (const char *name) |
| { |
| struct type *type; |
| |
| type = language_lookup_primitive_type (language (), arch (), name); |
| if (type == NULL) |
| error (_("Could not find Rust type %s"), name); |
| return type; |
| } |
| |
| std::string crate_name (const std::string &name); |
| std::string super_name (const std::string &ident, unsigned int n_supers); |
| |
| int lex_character (); |
| int lex_number (); |
| int lex_string (); |
| int lex_identifier (); |
| uint32_t lex_hex (int min, int max); |
| uint32_t lex_escape (int is_byte); |
| int lex_operator (); |
| int lex_one_token (); |
| void push_back (char c); |
| |
| /* The main interface to lexing. Lexes one token and updates the |
| internal state. */ |
| void lex () |
| { |
| current_token = lex_one_token (); |
| } |
| |
| /* Assuming the current token is TYPE, lex the next token. */ |
| void assume (int type) |
| { |
| gdb_assert (current_token == type); |
| lex (); |
| } |
| |
| /* Require the single-character token C, and lex the next token; or |
| throw an exception. */ |
| void require (char type) |
| { |
| if (current_token != type) |
| error (_("'%c' expected"), type); |
| lex (); |
| } |
| |
| /* Entry point for all parsing. */ |
| operation_up parse_entry_point () |
| { |
| lex (); |
| return parse_expr (); |
| } |
| |
| operation_up parse_tuple (); |
| operation_up parse_array (); |
| operation_up name_to_operation (const std::string &name); |
| operation_up parse_struct_expr (struct type *type); |
| operation_up parse_binop (bool required); |
| operation_up parse_range (); |
| operation_up parse_expr (); |
| operation_up parse_sizeof (); |
| operation_up parse_addr (); |
| operation_up parse_field (operation_up &&); |
| operation_up parse_index (operation_up &&); |
| std::vector<operation_up> parse_paren_args (); |
| operation_up parse_call (operation_up &&); |
| std::vector<struct type *> parse_type_list (); |
| std::vector<struct type *> parse_maybe_type_list (); |
| struct type *parse_array_type (); |
| struct type *parse_slice_type (); |
| struct type *parse_pointer_type (); |
| struct type *parse_function_type (); |
| struct type *parse_tuple_type (); |
| struct type *parse_type (); |
| std::string parse_path (bool for_expr); |
| operation_up parse_string (); |
| operation_up parse_tuple_struct (struct type *type); |
| operation_up parse_path_expr (); |
| operation_up parse_atom (bool required); |
| |
| void update_innermost_block (struct block_symbol sym); |
| struct block_symbol lookup_symbol (const char *name, |
| const struct block *block, |
| const domain_enum domain); |
| struct type *rust_lookup_type (const char *name); |
| |
| /* Clear some state. This is only used for testing. */ |
| #if GDB_SELF_TEST |
| void reset (const char *input) |
| { |
| pstate->prev_lexptr = nullptr; |
| pstate->lexptr = input; |
| paren_depth = 0; |
| current_token = 0; |
| current_int_val = {}; |
| current_float_val = {}; |
| current_string_val = {}; |
| current_opcode = OP_NULL; |
| } |
| #endif /* GDB_SELF_TEST */ |
| |
| /* Return the token's string value as a string. */ |
| std::string get_string () const |
| { |
| return std::string (current_string_val.ptr, current_string_val.length); |
| } |
| |
| /* A pointer to this is installed globally. */ |
| auto_obstack obstack; |
| |
| /* The parser state gdb gave us. */ |
| struct parser_state *pstate; |
| |
| /* Depth of parentheses. */ |
| int paren_depth = 0; |
| |
| /* The current token's type. */ |
| int current_token = 0; |
| /* The current token's payload, if any. */ |
| typed_val_int current_int_val {}; |
| typed_val_float current_float_val {}; |
| struct stoken current_string_val {}; |
| enum exp_opcode current_opcode = OP_NULL; |
| |
| /* When completing, this may be set to the field operation to |
| complete. */ |
| operation_up completion_op; |
| }; |
| |
| /* Return an string referring to NAME, but relative to the crate's |
| name. */ |
| |
| std::string |
| rust_parser::crate_name (const std::string &name) |
| { |
| std::string crate = rust_crate_for_block (pstate->expression_context_block); |
| |
| if (crate.empty ()) |
| error (_("Could not find crate for current location")); |
| return "::" + crate + "::" + name; |
| } |
| |
| /* Return a string referring to a "super::" qualified name. IDENT is |
| the base name and N_SUPERS is how many "super::"s were provided. |
| N_SUPERS can be zero. */ |
| |
| std::string |
| rust_parser::super_name (const std::string &ident, unsigned int n_supers) |
| { |
| const char *scope = block_scope (pstate->expression_context_block); |
| int offset; |
| |
| if (scope[0] == '\0') |
| error (_("Couldn't find namespace scope for self::")); |
| |
| if (n_supers > 0) |
| { |
| int len; |
| std::vector<int> offsets; |
| unsigned int current_len; |
| |
| current_len = cp_find_first_component (scope); |
| while (scope[current_len] != '\0') |
| { |
| offsets.push_back (current_len); |
| gdb_assert (scope[current_len] == ':'); |
| /* The "::". */ |
| current_len += 2; |
| current_len += cp_find_first_component (scope |
| + current_len); |
| } |
| |
| len = offsets.size (); |
| if (n_supers >= len) |
| error (_("Too many super:: uses from '%s'"), scope); |
| |
| offset = offsets[len - n_supers]; |
| } |
| else |
| offset = strlen (scope); |
| |
| return "::" + std::string (scope, offset) + "::" + ident; |
| } |
| |
| /* A helper to appropriately munge NAME and BLOCK depending on the |
| presence of a leading "::". */ |
| |
| static void |
| munge_name_and_block (const char **name, const struct block **block) |
| { |
| /* If it is a global reference, skip the current block in favor of |
| the static block. */ |
| if (startswith (*name, "::")) |
| { |
| *name += 2; |
| *block = block_static_block (*block); |
| } |
| } |
| |
| /* Like lookup_symbol, but handles Rust namespace conventions, and |
| doesn't require field_of_this_result. */ |
| |
| struct block_symbol |
| rust_parser::lookup_symbol (const char *name, const struct block *block, |
| const domain_enum domain) |
| { |
| struct block_symbol result; |
| |
| munge_name_and_block (&name, &block); |
| |
| result = ::lookup_symbol (name, block, domain, NULL); |
| if (result.symbol != NULL) |
| update_innermost_block (result); |
| return result; |
| } |
| |
| /* Look up a type, following Rust namespace conventions. */ |
| |
| struct type * |
| rust_parser::rust_lookup_type (const char *name) |
| { |
| struct block_symbol result; |
| struct type *type; |
| |
| const struct block *block = pstate->expression_context_block; |
| munge_name_and_block (&name, &block); |
| |
| result = ::lookup_symbol (name, block, STRUCT_DOMAIN, NULL); |
| if (result.symbol != NULL) |
| { |
| update_innermost_block (result); |
| return SYMBOL_TYPE (result.symbol); |
| } |
| |
| type = lookup_typename (language (), name, NULL, 1); |
| if (type != NULL) |
| return type; |
| |
| /* Last chance, try a built-in type. */ |
| return language_lookup_primitive_type (language (), arch (), name); |
| } |
| |
| /* A helper that updates the innermost block as appropriate. */ |
| |
| void |
| rust_parser::update_innermost_block (struct block_symbol sym) |
| { |
| if (symbol_read_needs_frame (sym.symbol)) |
| pstate->block_tracker->update (sym); |
| } |
| |
| /* Lex a hex number with at least MIN digits and at most MAX |
| digits. */ |
| |
| uint32_t |
| rust_parser::lex_hex (int min, int max) |
| { |
| uint32_t result = 0; |
| int len = 0; |
| /* We only want to stop at MAX if we're lexing a byte escape. */ |
| int check_max = min == max; |
| |
| while ((check_max ? len <= max : 1) |
| && ((pstate->lexptr[0] >= 'a' && pstate->lexptr[0] <= 'f') |
| || (pstate->lexptr[0] >= 'A' && pstate->lexptr[0] <= 'F') |
| || (pstate->lexptr[0] >= '0' && pstate->lexptr[0] <= '9'))) |
| { |
| result *= 16; |
| if (pstate->lexptr[0] >= 'a' && pstate->lexptr[0] <= 'f') |
| result = result + 10 + pstate->lexptr[0] - 'a'; |
| else if (pstate->lexptr[0] >= 'A' && pstate->lexptr[0] <= 'F') |
| result = result + 10 + pstate->lexptr[0] - 'A'; |
| else |
| result = result + pstate->lexptr[0] - '0'; |
| ++pstate->lexptr; |
| ++len; |
| } |
| |
| if (len < min) |
| error (_("Not enough hex digits seen")); |
| if (len > max) |
| { |
| gdb_assert (min != max); |
| error (_("Overlong hex escape")); |
| } |
| |
| return result; |
| } |
| |
| /* Lex an escape. IS_BYTE is true if we're lexing a byte escape; |
| otherwise we're lexing a character escape. */ |
| |
| uint32_t |
| rust_parser::lex_escape (int is_byte) |
| { |
| uint32_t result; |
| |
| gdb_assert (pstate->lexptr[0] == '\\'); |
| ++pstate->lexptr; |
| switch (pstate->lexptr[0]) |
| { |
| case 'x': |
| ++pstate->lexptr; |
| result = lex_hex (2, 2); |
| break; |
| |
| case 'u': |
| if (is_byte) |
| error (_("Unicode escape in byte literal")); |
| ++pstate->lexptr; |
| if (pstate->lexptr[0] != '{') |
| error (_("Missing '{' in Unicode escape")); |
| ++pstate->lexptr; |
| result = lex_hex (1, 6); |
| /* Could do range checks here. */ |
| if (pstate->lexptr[0] != '}') |
| error (_("Missing '}' in Unicode escape")); |
| ++pstate->lexptr; |
| break; |
| |
| case 'n': |
| result = '\n'; |
| ++pstate->lexptr; |
| break; |
| case 'r': |
| result = '\r'; |
| ++pstate->lexptr; |
| break; |
| case 't': |
| result = '\t'; |
| ++pstate->lexptr; |
| break; |
| case '\\': |
| result = '\\'; |
| ++pstate->lexptr; |
| break; |
| case '0': |
| result = '\0'; |
| ++pstate->lexptr; |
| break; |
| case '\'': |
| result = '\''; |
| ++pstate->lexptr; |
| break; |
| case '"': |
| result = '"'; |
| ++pstate->lexptr; |
| break; |
| |
| default: |
| error (_("Invalid escape \\%c in literal"), pstate->lexptr[0]); |
| } |
| |
| return result; |
| } |
| |
| /* Lex a character constant. */ |
| |
| int |
| rust_parser::lex_character () |
| { |
| int is_byte = 0; |
| uint32_t value; |
| |
| if (pstate->lexptr[0] == 'b') |
| { |
| is_byte = 1; |
| ++pstate->lexptr; |
| } |
| gdb_assert (pstate->lexptr[0] == '\''); |
| ++pstate->lexptr; |
| /* This should handle UTF-8 here. */ |
| if (pstate->lexptr[0] == '\\') |
| value = lex_escape (is_byte); |
| else |
| { |
| value = pstate->lexptr[0] & 0xff; |
| ++pstate->lexptr; |
| } |
| |
| if (pstate->lexptr[0] != '\'') |
| error (_("Unterminated character literal")); |
| ++pstate->lexptr; |
| |
| current_int_val.val = value; |
| current_int_val.type = get_type (is_byte ? "u8" : "char"); |
| |
| return INTEGER; |
| } |
| |
| /* Return the offset of the double quote if STR looks like the start |
| of a raw string, or 0 if STR does not start a raw string. */ |
| |
| static int |
| starts_raw_string (const char *str) |
| { |
| const char *save = str; |
| |
| if (str[0] != 'r') |
| return 0; |
| ++str; |
| while (str[0] == '#') |
| ++str; |
| if (str[0] == '"') |
| return str - save; |
| return 0; |
| } |
| |
| /* Return true if STR looks like the end of a raw string that had N |
| hashes at the start. */ |
| |
| static bool |
| ends_raw_string (const char *str, int n) |
| { |
| int i; |
| |
| gdb_assert (str[0] == '"'); |
| for (i = 0; i < n; ++i) |
| if (str[i + 1] != '#') |
| return false; |
| return true; |
| } |
| |
| /* Lex a string constant. */ |
| |
| int |
| rust_parser::lex_string () |
| { |
| int is_byte = pstate->lexptr[0] == 'b'; |
| int raw_length; |
| |
| if (is_byte) |
| ++pstate->lexptr; |
| raw_length = starts_raw_string (pstate->lexptr); |
| pstate->lexptr += raw_length; |
| gdb_assert (pstate->lexptr[0] == '"'); |
| ++pstate->lexptr; |
| |
| while (1) |
| { |
| uint32_t value; |
| |
| if (raw_length > 0) |
| { |
| if (pstate->lexptr[0] == '"' && ends_raw_string (pstate->lexptr, |
| raw_length - 1)) |
| { |
| /* Exit with lexptr pointing after the final "#". */ |
| pstate->lexptr += raw_length; |
| break; |
| } |
| else if (pstate->lexptr[0] == '\0') |
| error (_("Unexpected EOF in string")); |
| |
| value = pstate->lexptr[0] & 0xff; |
| if (is_byte && value > 127) |
| error (_("Non-ASCII value in raw byte string")); |
| obstack_1grow (&obstack, value); |
| |
| ++pstate->lexptr; |
| } |
| else if (pstate->lexptr[0] == '"') |
| { |
| /* Make sure to skip the quote. */ |
| ++pstate->lexptr; |
| break; |
| } |
| else if (pstate->lexptr[0] == '\\') |
| { |
| value = lex_escape (is_byte); |
| |
| if (is_byte) |
| obstack_1grow (&obstack, value); |
| else |
| convert_between_encodings ("UTF-32", "UTF-8", (gdb_byte *) &value, |
| sizeof (value), sizeof (value), |
| &obstack, translit_none); |
| } |
| else if (pstate->lexptr[0] == '\0') |
| error (_("Unexpected EOF in string")); |
| else |
| { |
| value = pstate->lexptr[0] & 0xff; |
| if (is_byte && value > 127) |
| error (_("Non-ASCII value in byte string")); |
| obstack_1grow (&obstack, value); |
| ++pstate->lexptr; |
| } |
| } |
| |
| current_string_val.length = obstack_object_size (&obstack); |
| current_string_val.ptr = (const char *) obstack_finish (&obstack); |
| return is_byte ? BYTESTRING : STRING; |
| } |
| |
| /* Return true if STRING starts with whitespace followed by a digit. */ |
| |
| static bool |
| space_then_number (const char *string) |
| { |
| const char *p = string; |
| |
| while (p[0] == ' ' || p[0] == '\t') |
| ++p; |
| if (p == string) |
| return false; |
| |
| return *p >= '0' && *p <= '9'; |
| } |
| |
| /* Return true if C can start an identifier. */ |
| |
| static bool |
| rust_identifier_start_p (char c) |
| { |
| return ((c >= 'a' && c <= 'z') |
| || (c >= 'A' && c <= 'Z') |
| || c == '_' |
| || c == '$'); |
| } |
| |
| /* Lex an identifier. */ |
| |
| int |
| rust_parser::lex_identifier () |
| { |
| unsigned int length; |
| const struct token_info *token; |
| int i; |
| int is_gdb_var = pstate->lexptr[0] == '$'; |
| |
| bool is_raw = false; |
| if (pstate->lexptr[0] == 'r' |
| && pstate->lexptr[1] == '#' |
| && rust_identifier_start_p (pstate->lexptr[2])) |
| { |
| is_raw = true; |
| pstate->lexptr += 2; |
| } |
| |
| const char *start = pstate->lexptr; |
| gdb_assert (rust_identifier_start_p (pstate->lexptr[0])); |
| |
| ++pstate->lexptr; |
| |
| /* For the time being this doesn't handle Unicode rules. Non-ASCII |
| identifiers are gated anyway. */ |
| while ((pstate->lexptr[0] >= 'a' && pstate->lexptr[0] <= 'z') |
| || (pstate->lexptr[0] >= 'A' && pstate->lexptr[0] <= 'Z') |
| || pstate->lexptr[0] == '_' |
| || (is_gdb_var && pstate->lexptr[0] == '$') |
| || (pstate->lexptr[0] >= '0' && pstate->lexptr[0] <= '9')) |
| ++pstate->lexptr; |
| |
| |
| length = pstate->lexptr - start; |
| token = NULL; |
| if (!is_raw) |
| { |
| for (i = 0; i < ARRAY_SIZE (identifier_tokens); ++i) |
| { |
| if (length == strlen (identifier_tokens[i].name) |
| && strncmp (identifier_tokens[i].name, start, length) == 0) |
| { |
| token = &identifier_tokens[i]; |
| break; |
| } |
| } |
| } |
| |
| if (token != NULL) |
| { |
| if (token->value == 0) |
| { |
| /* Leave the terminating token alone. */ |
| pstate->lexptr = start; |
| return 0; |
| } |
| } |
| else if (token == NULL |
| && !is_raw |
| && (strncmp (start, "thread", length) == 0 |
| || strncmp (start, "task", length) == 0) |
| && space_then_number (pstate->lexptr)) |
| { |
| /* "task" or "thread" followed by a number terminates the |
| parse, per gdb rules. */ |
| pstate->lexptr = start; |
| return 0; |
| } |
| |
| if (token == NULL || (pstate->parse_completion && pstate->lexptr[0] == '\0')) |
| { |
| current_string_val.length = length; |
| current_string_val.ptr = start; |
| } |
| |
| if (pstate->parse_completion && pstate->lexptr[0] == '\0') |
| { |
| /* Prevent rustyylex from returning two COMPLETE tokens. */ |
| pstate->prev_lexptr = pstate->lexptr; |
| return COMPLETE; |
| } |
| |
| if (token != NULL) |
| return token->value; |
| if (is_gdb_var) |
| return GDBVAR; |
| return IDENT; |
| } |
| |
| /* Lex an operator. */ |
| |
| int |
| rust_parser::lex_operator () |
| { |
| const struct token_info *token = NULL; |
| int i; |
| |
| for (i = 0; i < ARRAY_SIZE (operator_tokens); ++i) |
| { |
| if (strncmp (operator_tokens[i].name, pstate->lexptr, |
| strlen (operator_tokens[i].name)) == 0) |
| { |
| pstate->lexptr += strlen (operator_tokens[i].name); |
| token = &operator_tokens[i]; |
| break; |
| } |
| } |
| |
| if (token != NULL) |
| { |
| current_opcode = token->opcode; |
| return token->value; |
| } |
| |
| return *pstate->lexptr++; |
| } |
| |
| /* Lex a number. */ |
| |
| int |
| rust_parser::lex_number () |
| { |
| regmatch_t subexps[NUM_SUBEXPRESSIONS]; |
| int match; |
| int is_integer = 0; |
| int could_be_decimal = 1; |
| int implicit_i32 = 0; |
| const char *type_name = NULL; |
| struct type *type; |
| int end_index; |
| int type_index = -1; |
| int i; |
| |
| match = regexec (&number_regex, pstate->lexptr, ARRAY_SIZE (subexps), |
| subexps, 0); |
| /* Failure means the regexp is broken. */ |
| gdb_assert (match == 0); |
| |
| if (subexps[INT_TEXT].rm_so != -1) |
| { |
| /* Integer part matched. */ |
| is_integer = 1; |
| end_index = subexps[INT_TEXT].rm_eo; |
| if (subexps[INT_TYPE].rm_so == -1) |
| { |
| type_name = "i32"; |
| implicit_i32 = 1; |
| } |
| else |
| { |
| type_index = INT_TYPE; |
| could_be_decimal = 0; |
| } |
| } |
| else if (subexps[FLOAT_TYPE1].rm_so != -1) |
| { |
| /* Found floating point type suffix. */ |
| end_index = subexps[FLOAT_TYPE1].rm_so; |
| type_index = FLOAT_TYPE1; |
| } |
| else if (subexps[FLOAT_TYPE2].rm_so != -1) |
| { |
| /* Found floating point type suffix. */ |
| end_index = subexps[FLOAT_TYPE2].rm_so; |
| type_index = FLOAT_TYPE2; |
| } |
| else |
| { |
| /* Any other floating point match. */ |
| end_index = subexps[0].rm_eo; |
| type_name = "f64"; |
| } |
| |
| /* We need a special case if the final character is ".". In this |
| case we might need to parse an integer. For example, "23.f()" is |
| a request for a trait method call, not a syntax error involving |
| the floating point number "23.". */ |
| gdb_assert (subexps[0].rm_eo > 0); |
| if (pstate->lexptr[subexps[0].rm_eo - 1] == '.') |
| { |
| const char *next = skip_spaces (&pstate->lexptr[subexps[0].rm_eo]); |
| |
| if (rust_identifier_start_p (*next) || *next == '.') |
| { |
| --subexps[0].rm_eo; |
| is_integer = 1; |
| end_index = subexps[0].rm_eo; |
| type_name = "i32"; |
| could_be_decimal = 1; |
| implicit_i32 = 1; |
| } |
| } |
| |
| /* Compute the type name if we haven't already. */ |
| std::string type_name_holder; |
| if (type_name == NULL) |
| { |
| gdb_assert (type_index != -1); |
| type_name_holder = std::string ((pstate->lexptr |
| + subexps[type_index].rm_so), |
| (subexps[type_index].rm_eo |
| - subexps[type_index].rm_so)); |
| type_name = type_name_holder.c_str (); |
| } |
| |
| /* Look up the type. */ |
| type = get_type (type_name); |
| |
| /* Copy the text of the number and remove the "_"s. */ |
| std::string number; |
| for (i = 0; i < end_index && pstate->lexptr[i]; ++i) |
| { |
| if (pstate->lexptr[i] == '_') |
| could_be_decimal = 0; |
| else |
| number.push_back (pstate->lexptr[i]); |
| } |
| |
| /* Advance past the match. */ |
| pstate->lexptr += subexps[0].rm_eo; |
| |
| /* Parse the number. */ |
| if (is_integer) |
| { |
| uint64_t value; |
| int radix = 10; |
| int offset = 0; |
| |
| if (number[0] == '0') |
| { |
| if (number[1] == 'x') |
| radix = 16; |
| else if (number[1] == 'o') |
| radix = 8; |
| else if (number[1] == 'b') |
| radix = 2; |
| if (radix != 10) |
| { |
| offset = 2; |
| could_be_decimal = 0; |
| } |
| } |
| |
| value = strtoulst (number.c_str () + offset, NULL, radix); |
| if (implicit_i32 && value >= ((uint64_t) 1) << 31) |
| type = get_type ("i64"); |
| |
| current_int_val.val = value; |
| current_int_val.type = type; |
| } |
| else |
| { |
| current_float_val.type = type; |
| bool parsed = parse_float (number.c_str (), number.length (), |
| current_float_val.type, |
| current_float_val.val.data ()); |
| gdb_assert (parsed); |
| } |
| |
| return is_integer ? (could_be_decimal ? DECIMAL_INTEGER : INTEGER) : FLOAT; |
| } |
| |
| /* The lexer. */ |
| |
| int |
| rust_parser::lex_one_token () |
| { |
| /* Skip all leading whitespace. */ |
| while (pstate->lexptr[0] == ' ' |
| || pstate->lexptr[0] == '\t' |
| || pstate->lexptr[0] == '\r' |
| || pstate->lexptr[0] == '\n') |
| ++pstate->lexptr; |
| |
| /* If we hit EOF and we're completing, then return COMPLETE -- maybe |
| we're completing an empty string at the end of a field_expr. |
| But, we don't want to return two COMPLETE tokens in a row. */ |
| if (pstate->lexptr[0] == '\0' && pstate->lexptr == pstate->prev_lexptr) |
| return 0; |
| pstate->prev_lexptr = pstate->lexptr; |
| if (pstate->lexptr[0] == '\0') |
| { |
| if (pstate->parse_completion) |
| { |
| current_string_val.length =0; |
| current_string_val.ptr = ""; |
| return COMPLETE; |
| } |
| return 0; |
| } |
| |
| if (pstate->lexptr[0] >= '0' && pstate->lexptr[0] <= '9') |
| return lex_number (); |
| else if (pstate->lexptr[0] == 'b' && pstate->lexptr[1] == '\'') |
| return lex_character (); |
| else if (pstate->lexptr[0] == 'b' && pstate->lexptr[1] == '"') |
| return lex_string (); |
| else if (pstate->lexptr[0] == 'b' && starts_raw_string (pstate->lexptr + 1)) |
| return lex_string (); |
| else if (starts_raw_string (pstate->lexptr)) |
| return lex_string (); |
| else if (rust_identifier_start_p (pstate->lexptr[0])) |
| return lex_identifier (); |
| else if (pstate->lexptr[0] == '"') |
| return lex_string (); |
| else if (pstate->lexptr[0] == '\'') |
| return lex_character (); |
| else if (pstate->lexptr[0] == '}' || pstate->lexptr[0] == ']') |
| { |
| /* Falls through to lex_operator. */ |
| --paren_depth; |
| } |
| else if (pstate->lexptr[0] == '(' || pstate->lexptr[0] == '{') |
| { |
| /* Falls through to lex_operator. */ |
| ++paren_depth; |
| } |
| else if (pstate->lexptr[0] == ',' && pstate->comma_terminates |
| && paren_depth == 0) |
| return 0; |
| |
| return lex_operator (); |
| } |
| |
| /* Push back a single character to be re-lexed. */ |
| |
| void |
| rust_parser::push_back (char c) |
| { |
| /* Can't be called before any lexing. */ |
| gdb_assert (pstate->prev_lexptr != NULL); |
| |
| --pstate->lexptr; |
| gdb_assert (*pstate->lexptr == c); |
| } |
| |
| |
| |
| /* Parse a tuple or paren expression. */ |
| |
| operation_up |
| rust_parser::parse_tuple () |
| { |
| assume ('('); |
| |
| if (current_token == ')') |
| { |
| lex (); |
| struct type *unit = get_type ("()"); |
| return make_operation<long_const_operation> (unit, 0); |
| } |
| |
| operation_up expr = parse_expr (); |
| if (current_token == ')') |
| { |
| /* Parenthesized expression. */ |
| lex (); |
| return expr; |
| } |
| |
| std::vector<operation_up> ops; |
| ops.push_back (std::move (expr)); |
| while (current_token != ')') |
| { |
| if (current_token != ',') |
| error (_("',' or ')' expected")); |
| lex (); |
| |
| /* A trailing "," is ok. */ |
| if (current_token != ')') |
| ops.push_back (parse_expr ()); |
| } |
| |
| assume (')'); |
| |
| error (_("Tuple expressions not supported yet")); |
| } |
| |
| /* Parse an array expression. */ |
| |
| operation_up |
| rust_parser::parse_array () |
| { |
| assume ('['); |
| |
| if (current_token == KW_MUT) |
| lex (); |
| |
| operation_up result; |
| operation_up expr = parse_expr (); |
| if (current_token == ';') |
| { |
| lex (); |
| operation_up rhs = parse_expr (); |
| result = make_operation<rust_array_operation> (std::move (expr), |
| std::move (rhs)); |
| } |
| else if (current_token == ',') |
| { |
| std::vector<operation_up> ops; |
| ops.push_back (std::move (expr)); |
| while (current_token != ']') |
| { |
| if (current_token != ',') |
| error (_("',' or ']' expected")); |
| lex (); |
| ops.push_back (parse_expr ()); |
| } |
| ops.shrink_to_fit (); |
| int len = ops.size () - 1; |
| result = make_operation<array_operation> (0, len, std::move (ops)); |
| } |
| else if (current_token != ']') |
| error (_("',', ';', or ']' expected")); |
| |
| require (']'); |
| |
| return result; |
| } |
| |
| /* Turn a name into an operation. */ |
| |
| operation_up |
| rust_parser::name_to_operation (const std::string &name) |
| { |
| struct block_symbol sym = lookup_symbol (name.c_str (), |
| pstate->expression_context_block, |
| VAR_DOMAIN); |
| if (sym.symbol != nullptr && SYMBOL_CLASS (sym.symbol) != LOC_TYPEDEF) |
| return make_operation<var_value_operation> (sym); |
| |
| struct type *type = nullptr; |
| |
| if (sym.symbol != nullptr) |
| { |
| gdb_assert (SYMBOL_CLASS (sym.symbol) == LOC_TYPEDEF); |
| type = SYMBOL_TYPE (sym.symbol); |
| } |
| if (type == nullptr) |
| type = rust_lookup_type (name.c_str ()); |
| if (type == nullptr) |
| error (_("No symbol '%s' in current context"), name.c_str ()); |
| |
| if (type->code () == TYPE_CODE_STRUCT && type->num_fields () == 0) |
| { |
| /* A unit-like struct. */ |
| operation_up result (new rust_aggregate_operation (type, {}, {})); |
| return result; |
| } |
| else |
| return make_operation<type_operation> (type); |
| } |
| |
| /* Parse a struct expression. */ |
| |
| operation_up |
| rust_parser::parse_struct_expr (struct type *type) |
| { |
| assume ('{'); |
| |
| if (type->code () != TYPE_CODE_STRUCT |
| || rust_tuple_type_p (type) |
| || rust_tuple_struct_type_p (type)) |
| error (_("Struct expression applied to non-struct type")); |
| |
| std::vector<std::pair<std::string, operation_up>> field_v; |
| while (current_token != '}' && current_token != DOTDOT) |
| { |
| if (current_token != IDENT) |
| error (_("'}', '..', or identifier expected")); |
| |
| std::string name = get_string (); |
| lex (); |
| |
| operation_up expr; |
| if (current_token == ',' || current_token == '}' |
| || current_token == DOTDOT) |
| expr = name_to_operation (name); |
| else |
| { |
| require (':'); |
| expr = parse_expr (); |
| } |
| field_v.emplace_back (std::move (name), std::move (expr)); |
| |
| /* A trailing "," is ok. */ |
| if (current_token == ',') |
| lex (); |
| } |
| |
| operation_up others; |
| if (current_token == DOTDOT) |
| { |
| lex (); |
| others = parse_expr (); |
| } |
| |
| require ('}'); |
| |
| return make_operation<rust_aggregate_operation> (type, |
| std::move (others), |
| std::move (field_v)); |
| } |
| |
| /* Used by the operator precedence parser. */ |
| struct rustop_item |
| { |
| rustop_item (int token_, int precedence_, enum exp_opcode opcode_, |
| operation_up &&op_) |
| : token (token_), |
| precedence (precedence_), |
| opcode (opcode_), |
| op (std::move (op_)) |
| { |
| } |
| |
| /* The token value. */ |
| int token; |
| /* Precedence of this operator. */ |
| int precedence; |
| /* This is used only for assign-modify. */ |
| enum exp_opcode opcode; |
| /* The right hand side of this operation. */ |
| operation_up op; |
| }; |
| |
| /* An operator precedence parser for binary operations, including |
| "as". */ |
| |
| operation_up |
| rust_parser::parse_binop (bool required) |
| { |
| /* All the binary operators. Each one is of the form |
| OPERATION(TOKEN, PRECEDENCE, TYPE) |
| TOKEN is the corresponding operator token. |
| PRECEDENCE is a value indicating relative precedence. |
| TYPE is the operation type corresponding to the operator. |
| Assignment operations are handled specially, not via this |
| table; they have precedence 0. */ |
| #define ALL_OPS \ |
| OPERATION ('*', 10, mul_operation) \ |
| OPERATION ('/', 10, div_operation) \ |
| OPERATION ('%', 10, rem_operation) \ |
| OPERATION ('@', 9, repeat_operation) \ |
| OPERATION ('+', 8, add_operation) \ |
| OPERATION ('-', 8, sub_operation) \ |
| OPERATION (LSH, 7, lsh_operation) \ |
| OPERATION (RSH, 7, rsh_operation) \ |
| OPERATION ('&', 6, bitwise_and_operation) \ |
| OPERATION ('^', 5, bitwise_xor_operation) \ |
| OPERATION ('|', 4, bitwise_ior_operation) \ |
| OPERATION (EQEQ, 3, equal_operation) \ |
| OPERATION (NOTEQ, 3, notequal_operation) \ |
| OPERATION ('<', 3, less_operation) \ |
| OPERATION (LTEQ, 3, leq_operation) \ |
| OPERATION ('>', 3, gtr_operation) \ |
| OPERATION (GTEQ, 3, geq_operation) \ |
| OPERATION (ANDAND, 2, logical_and_operation) \ |
| OPERATION (OROR, 1, logical_or_operation) |
| |
| operation_up start = parse_atom (required); |
| if (start == nullptr) |
| { |
| gdb_assert (!required); |
| return start; |
| } |
| |
| std::vector<rustop_item> operator_stack; |
| operator_stack.emplace_back (0, -1, OP_NULL, std::move (start)); |
| |
| while (true) |
| { |
| int this_token = current_token; |
| enum exp_opcode compound_assign_op = OP_NULL; |
| int precedence = -2; |
| |
| switch (this_token) |
| { |
| #define OPERATION(TOKEN, PRECEDENCE, TYPE) \ |
| case TOKEN: \ |
| precedence = PRECEDENCE; \ |
| lex (); \ |
| break; |
| |
| ALL_OPS |
| |
| #undef OPERATION |
| |
| case COMPOUND_ASSIGN: |
| compound_assign_op = current_opcode; |
| /* FALLTHROUGH */ |
| case '=': |
| precedence = 0; |
| lex (); |
| break; |
| |
| /* "as" must be handled specially. */ |
| case KW_AS: |
| { |
| lex (); |
| rustop_item &lhs = operator_stack.back (); |
| struct type *type = parse_type (); |
| lhs.op = make_operation<unop_cast_operation> (std::move (lhs.op), |
| type); |
| } |
| /* Bypass the rest of the loop. */ |
| continue; |
| |
| default: |
| /* Arrange to pop the entire stack. */ |
| precedence = -2; |
| break; |
| } |
| |
| while (precedence < operator_stack.back ().precedence |
| && operator_stack.size () > 1) |
| { |
| rustop_item rhs = std::move (operator_stack.back ()); |
| operator_stack.pop_back (); |
| |
| rustop_item &lhs = operator_stack.back (); |
| |
| switch (rhs.token) |
| { |
| #define OPERATION(TOKEN, PRECEDENCE, TYPE) \ |
| case TOKEN: \ |
| lhs.op = make_operation<TYPE> (std::move (lhs.op), \ |
| std::move (rhs.op)); \ |
| break; |
| |
| ALL_OPS |
| |
| #undef OPERATION |
| |
| case '=': |
| case COMPOUND_ASSIGN: |
| { |
| if (rhs.token == '=') |
| lhs.op = (make_operation<assign_operation> |
| (std::move (lhs.op), std::move (rhs.op))); |
| else |
| lhs.op = (make_operation<assign_modify_operation> |
| (rhs.opcode, std::move (lhs.op), |
| std::move (rhs.op))); |
| |
| struct type *unit_type = get_type ("()"); |
| |
| operation_up nil (new long_const_operation (unit_type, 0)); |
| lhs.op = (make_operation<comma_operation> |
| (std::move (lhs.op), std::move (nil))); |
| } |
| break; |
| |
| default: |
| gdb_assert_not_reached ("bad binary operator"); |
| } |
| } |
| |
| if (precedence == -2) |
| break; |
| |
| operator_stack.emplace_back (this_token, precedence, compound_assign_op, |
| parse_atom (true)); |
| } |
| |
| gdb_assert (operator_stack.size () == 1); |
| return std::move (operator_stack[0].op); |
| #undef ALL_OPS |
| } |
| |
| /* Parse a range expression. */ |
| |
| operation_up |
| rust_parser::parse_range () |
| { |
| enum range_flag kind = (RANGE_HIGH_BOUND_DEFAULT |
| | RANGE_LOW_BOUND_DEFAULT); |
| |
| operation_up lhs; |
| if (current_token != DOTDOT && current_token != DOTDOTEQ) |
| { |
| lhs = parse_binop (true); |
| kind &= ~RANGE_LOW_BOUND_DEFAULT; |
| } |
| |
| if (current_token == DOTDOT) |
| kind |= RANGE_HIGH_BOUND_EXCLUSIVE; |
| else if (current_token != DOTDOTEQ) |
| return lhs; |
| lex (); |
| |
| /* A "..=" range requires a high bound, but otherwise it is |
| optional. */ |
| operation_up rhs = parse_binop ((kind & RANGE_HIGH_BOUND_EXCLUSIVE) == 0); |
| if (rhs != nullptr) |
| kind &= ~RANGE_HIGH_BOUND_DEFAULT; |
| |
| return make_operation<rust_range_operation> (kind, |
| std::move (lhs), |
| std::move (rhs)); |
| } |
| |
| /* Parse an expression. */ |
| |
| operation_up |
| rust_parser::parse_expr () |
| { |
| return parse_range (); |
| } |
| |
| /* Parse a sizeof expression. */ |
| |
| operation_up |
| rust_parser::parse_sizeof () |
| { |
| assume (KW_SIZEOF); |
| |
| require ('('); |
| operation_up result = make_operation<unop_sizeof_operation> (parse_expr ()); |
| require (')'); |
| return result; |
| } |
| |
| /* Parse an address-of operation. */ |
| |
| operation_up |
| rust_parser::parse_addr () |
| { |
| assume ('&'); |
| |
| if (current_token == KW_MUT) |
| lex (); |
| |
| return make_operation<rust_unop_addr_operation> (parse_atom (true)); |
| } |
| |
| /* Parse a field expression. */ |
| |
| operation_up |
| rust_parser::parse_field (operation_up &&lhs) |
| { |
| assume ('.'); |
| |
| operation_up result; |
| switch (current_token) |
| { |
| case IDENT: |
| case COMPLETE: |
| { |
| bool is_complete = current_token == COMPLETE; |
| auto struct_op = new rust_structop (std::move (lhs), get_string ()); |
| lex (); |
| if (is_complete) |
| { |
| completion_op.reset (struct_op); |
| pstate->mark_struct_expression (struct_op); |
| /* Throw to the outermost level of the parser. */ |
| error (_("not really an error")); |
| } |
| result.reset (struct_op); |
| } |
| break; |
| |
| case DECIMAL_INTEGER: |
| result = make_operation<rust_struct_anon> (current_int_val.val, |
| std::move (lhs)); |
| lex (); |
| break; |
| |
| case INTEGER: |
| error (_("'_' not allowed in integers in anonymous field references")); |
| |
| default: |
| error (_("field name expected")); |
| } |
| |
| return result; |
| } |
| |
| /* Parse an index expression. */ |
| |
| operation_up |
| rust_parser::parse_index (operation_up &&lhs) |
| { |
| assume ('['); |
| operation_up rhs = parse_expr (); |
| require (']'); |
| |
| return make_operation<rust_subscript_operation> (std::move (lhs), |
| std::move (rhs)); |
| } |
| |
| /* Parse a sequence of comma-separated expressions in parens. */ |
| |
| std::vector<operation_up> |
| rust_parser::parse_paren_args () |
| { |
| assume ('('); |
| |
| std::vector<operation_up> args; |
| while (current_token != ')') |
| { |
| if (!args.empty ()) |
| { |
| if (current_token != ',') |
| error (_("',' or ')' expected")); |
| lex (); |
| } |
| |
| args.push_back (parse_expr ()); |
| } |
| |
| assume (')'); |
| |
| return args; |
| } |
| |
| /* Parse the parenthesized part of a function call. */ |
| |
| operation_up |
| rust_parser::parse_call (operation_up &&lhs) |
| { |
| std::vector<operation_up> args = parse_paren_args (); |
| |
| return make_operation<funcall_operation> (std::move (lhs), |
| std::move (args)); |
| } |
| |
| /* Parse a list of types. */ |
| |
| std::vector<struct type *> |
| rust_parser::parse_type_list () |
| { |
| std::vector<struct type *> result; |
| result.push_back (parse_type ()); |
| while (current_token == ',') |
| { |
| lex (); |
| result.push_back (parse_type ()); |
| } |
| return result; |
| } |
| |
| /* Parse a possibly-empty list of types, surrounded in parens. */ |
| |
| std::vector<struct type *> |
| rust_parser::parse_maybe_type_list () |
| { |
| assume ('('); |
| std::vector<struct type *> types; |
| if (current_token != ')') |
| types = parse_type_list (); |
| require (')'); |
| return types; |
| } |
| |
| /* Parse an array type. */ |
| |
| struct type * |
| rust_parser::parse_array_type () |
| { |
| assume ('['); |
| struct type *elt_type = parse_type (); |
| require (';'); |
| |
| if (current_token != INTEGER && current_token != DECIMAL_INTEGER) |
| error (_("integer expected")); |
| ULONGEST val = current_int_val.val; |
| lex (); |
| require (']'); |
| |
| return lookup_array_range_type (elt_type, 0, val - 1); |
| } |
| |
| /* Parse a slice type. */ |
| |
| struct type * |
| rust_parser::parse_slice_type () |
| { |
| assume ('&'); |
| |
| bool is_slice = current_token == '['; |
| if (is_slice) |
| lex (); |
| |
| struct type *target = parse_type (); |
| |
| if (is_slice) |
| { |
| require (']'); |
| return rust_slice_type ("&[*gdb*]", target, get_type ("usize")); |
| } |
| |
| /* For now we treat &x and *x identically. */ |
| return lookup_pointer_type (target); |
| } |
| |
| /* Parse a pointer type. */ |
| |
| struct type * |
| rust_parser::parse_pointer_type () |
| { |
| assume ('*'); |
| |
| if (current_token == KW_MUT || current_token == KW_CONST) |
| lex (); |
| |
| struct type *target = parse_type (); |
| /* For the time being we ignore mut/const. */ |
| return lookup_pointer_type (target); |
| } |
| |
| /* Parse a function type. */ |
| |
| struct type * |
| rust_parser::parse_function_type () |
| { |
| assume (KW_FN); |
| |
| if (current_token != '(') |
| error (_("'(' expected")); |
| |
| std::vector<struct type *> types = parse_maybe_type_list (); |
| |
| if (current_token != ARROW) |
| error (_("'->' expected")); |
| lex (); |
| |
| struct type *result_type = parse_type (); |
| |
| struct type **argtypes = nullptr; |
| if (!types.empty ()) |
| argtypes = types.data (); |
| |
| result_type = lookup_function_type_with_arguments (result_type, |
| types.size (), |
| argtypes); |
| return lookup_pointer_type (result_type); |
| } |
| |
| /* Parse a tuple type. */ |
| |
| struct type * |
| rust_parser::parse_tuple_type () |
| { |
| std::vector<struct type *> types = parse_maybe_type_list (); |
| |
| auto_obstack obstack; |
| obstack_1grow (&obstack, '('); |
| for (int i = 0; i < types.size (); ++i) |
| { |
| std::string type_name = type_to_string (types[i]); |
| |
| if (i > 0) |
| obstack_1grow (&obstack, ','); |
| obstack_grow_str (&obstack, type_name.c_str ()); |
| } |
| |
| obstack_grow_str0 (&obstack, ")"); |
| const char *name = (const char *) obstack_finish (&obstack); |
| |
| /* We don't allow creating new tuple types (yet), but we do allow |
| looking up existing tuple types. */ |
| struct type *result = rust_lookup_type (name); |
| if (result == nullptr) |
| error (_("could not find tuple type '%s'"), name); |
| |
| return result; |
| } |
| |
| /* Parse a type. */ |
| |
| struct type * |
| rust_parser::parse_type () |
| { |
| switch (current_token) |
| { |
| case '[': |
| return parse_array_type (); |
| case '&': |
| return parse_slice_type (); |
| case '*': |
| return parse_pointer_type (); |
| case KW_FN: |
| return parse_function_type (); |
| case '(': |
| return parse_tuple_type (); |
| case KW_SELF: |
| case KW_SUPER: |
| case COLONCOLON: |
| case KW_EXTERN: |
| case IDENT: |
| { |
| std::string path = parse_path (false); |
| struct type *result = rust_lookup_type (path.c_str ()); |
| if (result == nullptr) |
| error (_("No type name '%s' in current context"), path.c_str ()); |
| return result; |
| } |
| default: |
| error (_("type expected")); |
| } |
| } |
| |
| /* Parse a path. */ |
| |
| std::string |
| rust_parser::parse_path (bool for_expr) |
| { |
| unsigned n_supers = 0; |
| int first_token = current_token; |
| |
| switch (current_token) |
| { |
| case KW_SELF: |
| lex (); |
| if (current_token != COLONCOLON) |
| return "self"; |
| lex (); |
| /* FALLTHROUGH */ |
| case KW_SUPER: |
| while (current_token == KW_SUPER) |
| { |
| ++n_supers; |
| lex (); |
| if (current_token != COLONCOLON) |
| error (_("'::' expected")); |
| lex (); |
| } |
| break; |
| |
| case COLONCOLON: |
| lex (); |
| break; |
| |
| case KW_EXTERN: |
| /* This is a gdb extension to make it possible to refer to items |
| in other crates. It just bypasses adding the current crate |
| to the front of the name. */ |
| lex (); |
| break; |
| } |
| |
| if (current_token != IDENT) |
| error (_("identifier expected")); |
| std::string path = get_string (); |
| bool saw_ident = true; |
| lex (); |
| |
| /* The condition here lets us enter the loop even if we see |
| "ident<...>". */ |
| while (current_token == COLONCOLON || current_token == '<') |
| { |
| if (current_token == COLONCOLON) |
| { |
| lex (); |
| saw_ident = false; |
| |
| if (current_token == IDENT) |
| { |
| path = path + "::" + get_string (); |
| lex (); |
| saw_ident = true; |
| } |
| else if (current_token == COLONCOLON) |
| { |
| /* The code below won't detect this scenario. */ |
| error (_("unexpected '::'")); |
| } |
| } |
| |
| if (current_token != '<') |
| continue; |
| |
| /* Expression use name::<...>, whereas types use name<...>. */ |
| if (for_expr) |
| { |
| /* Expressions use "name::<...>", so if we saw an identifier |
| after the "::", we ignore the "<" here. */ |
| if (saw_ident) |
| break; |
| } |
| else |
| { |
| /* Types use "name<...>", so we need to have seen the |
| identifier. */ |
| if (!saw_ident) |
| break; |
| } |
| |
| lex (); |
| std::vector<struct type *> types = parse_type_list (); |
| if (current_token == '>') |
| lex (); |
| else if (current_token == RSH) |
| { |
| push_back ('>'); |
| lex (); |
| } |
| else |
| error (_("'>' expected")); |
| |
| path += "<"; |
| for (int i = 0; i < types.size (); ++i) |
| { |
| if (i > 0) |
| path += ","; |
| path += type_to_string (types[i]); |
| } |
| path += ">"; |
| break; |
| } |
| |
| switch (first_token) |
| { |
| case KW_SELF: |
| case KW_SUPER: |
| return super_name (path, n_supers); |
| |
| case COLONCOLON: |
| return crate_name (path); |
| |
| case KW_EXTERN: |
| return "::" + path; |
| |
| case IDENT: |
| return path; |
| |
| default: |
| gdb_assert_not_reached ("missing case in path parsing"); |
| } |
| } |
| |
| /* Handle the parsing for a string expression. */ |
| |
| operation_up |
| rust_parser::parse_string () |
| { |
| gdb_assert (current_token == STRING); |
| |
| /* Wrap the raw string in the &str struct. */ |
| struct type *type = rust_lookup_type ("&str"); |
| if (type == nullptr) |
| error (_("Could not find type '&str'")); |
| |
| std::vector<std::pair<std::string, operation_up>> field_v; |
| |
| size_t len = current_string_val.length; |
| operation_up str = make_operation<string_operation> (get_string ()); |
| operation_up addr |
| = make_operation<rust_unop_addr_operation> (std::move (str)); |
| field_v.emplace_back ("data_ptr", std::move (addr)); |
| |
| struct type *valtype = get_type ("usize"); |
| operation_up lenop = make_operation<long_const_operation> (valtype, len); |
| field_v.emplace_back ("length", std::move (lenop)); |
| |
| return make_operation<rust_aggregate_operation> (type, |
| operation_up (), |
| std::move (field_v)); |
| } |
| |
| /* Parse a tuple struct expression. */ |
| |
| operation_up |
| rust_parser::parse_tuple_struct (struct type *type) |
| { |
| std::vector<operation_up> args = parse_paren_args (); |
| |
| std::vector<std::pair<std::string, operation_up>> field_v (args.size ()); |
| for (int i = 0; i < args.size (); ++i) |
| field_v[i] = { string_printf ("__%d", i), std::move (args[i]) }; |
| |
| return (make_operation<rust_aggregate_operation> |
| (type, operation_up (), std::move (field_v))); |
| } |
| |
| /* Parse a path expression. */ |
| |
| operation_up |
| rust_parser::parse_path_expr () |
| { |
| std::string path = parse_path (true); |
| |
| if (current_token == '{') |
| { |
| struct type *type = rust_lookup_type (path.c_str ()); |
| if (type == nullptr) |
| error (_("Could not find type '%s'"), path.c_str ()); |
| |
| return parse_struct_expr (type); |
| } |
| else if (current_token == '(') |
| { |
| struct type *type = rust_lookup_type (path.c_str ()); |
| /* If this is actually a tuple struct expression, handle it |
| here. If it is a call, it will be handled elsewhere. */ |
| if (type != nullptr) |
| { |
| if (!rust_tuple_struct_type_p (type)) |
| error (_("Type %s is not a tuple struct"), path.c_str ()); |
| return parse_tuple_struct (type); |
| } |
| } |
| |
| return name_to_operation (path); |
| } |
| |
| /* Parse an atom. "Atom" isn't a Rust term, but this refers to a |
| single unitary item in the grammar; but here including some unary |
| prefix and postfix expressions. */ |
| |
| operation_up |
| rust_parser::parse_atom (bool required) |
| { |
| operation_up result; |
| |
| switch (current_token) |
| { |
| case '(': |
| result = parse_tuple (); |
| break; |
| |
| case '[': |
| result = parse_array (); |
| break; |
| |
| case INTEGER: |
| case DECIMAL_INTEGER: |
| result = make_operation<long_const_operation> (current_int_val.type, |
| current_int_val.val); |
| lex (); |
| break; |
| |
| case FLOAT: |
| result = make_operation<float_const_operation> (current_float_val.type, |
| current_float_val.val); |
| lex (); |
| break; |
| |
| case STRING: |
| result = parse_string (); |
| break; |
| |
| case BYTESTRING: |
| result = make_operation<string_operation> (get_string ()); |
| lex (); |
| break; |
| |
| case KW_TRUE: |
| case KW_FALSE: |
| result = make_operation<bool_operation> (current_token == KW_TRUE); |
| lex (); |
| break; |
| |
| case GDBVAR: |
| /* This is kind of a hacky approach. */ |
| { |
| pstate->push_dollar (current_string_val); |
| result = pstate->pop (); |
| lex (); |
| } |
| break; |
| |
| case KW_SELF: |
| case KW_SUPER: |
| case COLONCOLON: |
| case KW_EXTERN: |
| case IDENT: |
| result = parse_path_expr (); |
| break; |
| |
| case '*': |
| lex (); |
| result = make_operation<rust_unop_ind_operation> (parse_atom (true)); |
| break; |
| case '+': |
| lex (); |
| result = make_operation<unary_plus_operation> (parse_atom (true)); |
| break; |
| case '-': |
| lex (); |
| result = make_operation<unary_neg_operation> (parse_atom (true)); |
| break; |
| case '!': |
| lex (); |
| result = make_operation<rust_unop_compl_operation> (parse_atom (true)); |
| break; |
| case KW_SIZEOF: |
| result = parse_sizeof (); |
| break; |
| case '&': |
| result = parse_addr (); |
| break; |
| |
| default: |
| if (!required) |
| return {}; |
| error (_("unexpected token")); |
| } |
| |
| /* Now parse suffixes. */ |
| while (true) |
| { |
| switch (current_token) |
| { |
| case '.': |
| result = parse_field (std::move (result)); |
| break; |
| |
| case '[': |
| result = parse_index (std::move (result)); |
| break; |
| |
| case '(': |
| result = parse_call (std::move (result)); |
| break; |
| |
| default: |
| return result; |
| } |
| } |
| } |
| |
| |
| |
| /* The parser as exposed to gdb. */ |
| |
| int |
| rust_language::parser (struct parser_state *state) const |
| { |
| rust_parser parser (state); |
| |
| operation_up result; |
| try |
| { |
| result = parser.parse_entry_point (); |
| } |
| catch (const gdb_exception &exc) |
| { |
| if (state->parse_completion) |
| { |
| result = std::move (parser.completion_op); |
| if (result == nullptr) |
| throw; |
| } |
| else |
| throw; |
| } |
| |
| state->set_operation (std::move (result)); |
| |
| return 0; |
| } |
| |
| |
| |
| #if GDB_SELF_TEST |
| |
| /* A test helper that lexes a string, expecting a single token. */ |
| |
| static void |
| rust_lex_test_one (rust_parser *parser, const char *input, int expected) |
| { |
| int token; |
| |
| parser->reset (input); |
| |
| token = parser->lex_one_token (); |
| SELF_CHECK (token == expected); |
| |
| if (token) |
| { |
| token = parser->lex_one_token (); |
| SELF_CHECK (token == 0); |
| } |
| } |
| |
| /* Test that INPUT lexes as the integer VALUE. */ |
| |
| static void |
| rust_lex_int_test (rust_parser *parser, const char *input, |
| ULONGEST value, int kind) |
| { |
| rust_lex_test_one (parser, input, kind); |
| SELF_CHECK (parser->current_int_val.val == value); |
| } |
| |
| /* Test that INPUT throws an exception with text ERR. */ |
| |
| static void |
| rust_lex_exception_test (rust_parser *parser, const char *input, |
| const char *err) |
| { |
| try |
| { |
| /* The "kind" doesn't matter. */ |
| rust_lex_test_one (parser, input, DECIMAL_INTEGER); |
| SELF_CHECK (0); |
| } |
| catch (const gdb_exception_error &except) |
| { |
| SELF_CHECK (strcmp (except.what (), err) == 0); |
| } |
| } |
| |
| /* Test that INPUT lexes as the identifier, string, or byte-string |
| VALUE. KIND holds the expected token kind. */ |
| |
| static void |
| rust_lex_stringish_test (rust_parser *parser, const char *input, |
| const char *value, int kind) |
| { |
| rust_lex_test_one (parser, input, kind); |
| SELF_CHECK (parser->get_string () == value); |
| } |
| |
| /* Helper to test that a string parses as a given token sequence. */ |
| |
| static void |
| rust_lex_test_sequence (rust_parser *parser, const char *input, int len, |
| const int expected[]) |
| { |
| int i; |
| |
| parser->reset (input); |
| |
| for (i = 0; i < len; ++i) |
| { |
| int token = parser->lex_one_token (); |
| SELF_CHECK (token == expected[i]); |
| } |
| } |
| |
| /* Tests for an integer-parsing corner case. */ |
| |
| static void |
| rust_lex_test_trailing_dot (rust_parser *parser) |
| { |
| const int expected1[] = { DECIMAL_INTEGER, '.', IDENT, '(', ')', 0 }; |
| const int expected2[] = { INTEGER, '.', IDENT, '(', ')', 0 }; |
| const int expected3[] = { FLOAT, EQEQ, '(', ')', 0 }; |
| const int expected4[] = { DECIMAL_INTEGER, DOTDOT, DECIMAL_INTEGER, 0 }; |
| |
| rust_lex_test_sequence (parser, "23.g()", ARRAY_SIZE (expected1), expected1); |
| rust_lex_test_sequence (parser, "23_0.g()", ARRAY_SIZE (expected2), |
| expected2); |
| rust_lex_test_sequence (parser, "23.==()", ARRAY_SIZE (expected3), |
| expected3); |
| rust_lex_test_sequence (parser, "23..25", ARRAY_SIZE (expected4), expected4); |
| } |
| |
| /* Tests of completion. */ |
| |
| static void |
| rust_lex_test_completion (rust_parser *parser) |
| { |
| const int expected[] = { IDENT, '.', COMPLETE, 0 }; |
| |
| parser->pstate->parse_completion = 1; |
| |
| rust_lex_test_sequence (parser, "something.wha", ARRAY_SIZE (expected), |
| expected); |
| rust_lex_test_sequence (parser, "something.", ARRAY_SIZE (expected), |
| expected); |
| |
| parser->pstate->parse_completion = 0; |
| } |
| |
| /* Test pushback. */ |
| |
| static void |
| rust_lex_test_push_back (rust_parser *parser) |
| { |
| int token; |
| |
| parser->reset (">>="); |
| |
| token = parser->lex_one_token (); |
| SELF_CHECK (token == COMPOUND_ASSIGN); |
| SELF_CHECK (parser->current_opcode == BINOP_RSH); |
| |
| parser->push_back ('='); |
| |
| token = parser->lex_one_token (); |
| SELF_CHECK (token == '='); |
| |
| token = parser->lex_one_token (); |
| SELF_CHECK (token == 0); |
| } |
| |
| /* Unit test the lexer. */ |
| |
| static void |
| rust_lex_tests (void) |
| { |
| int i; |
| |
| /* Set up dummy "parser", so that rust_type works. */ |
| struct parser_state ps (language_def (language_rust), target_gdbarch (), |
| nullptr, 0, 0, nullptr, 0, nullptr, false); |
| rust_parser parser (&ps); |
| |
| rust_lex_test_one (&parser, "", 0); |
| rust_lex_test_one (&parser, " \t \n \r ", 0); |
| rust_lex_test_one (&parser, "thread 23", 0); |
| rust_lex_test_one (&parser, "task 23", 0); |
| rust_lex_test_one (&parser, "th 104", 0); |
| rust_lex_test_one (&parser, "ta 97", 0); |
| |
| rust_lex_int_test (&parser, "'z'", 'z', INTEGER); |
| rust_lex_int_test (&parser, "'\\xff'", 0xff, INTEGER); |
| rust_lex_int_test (&parser, "'\\u{1016f}'", 0x1016f, INTEGER); |
| rust_lex_int_test (&parser, "b'z'", 'z', INTEGER); |
| rust_lex_int_test (&parser, "b'\\xfe'", 0xfe, INTEGER); |
| rust_lex_int_test (&parser, "b'\\xFE'", 0xfe, INTEGER); |
| rust_lex_int_test (&parser, "b'\\xfE'", 0xfe, INTEGER); |
| |
| /* Test all escapes in both modes. */ |
| rust_lex_int_test (&parser, "'\\n'", '\n', INTEGER); |
| rust_lex_int_test (&parser, "'\\r'", '\r', INTEGER); |
| rust_lex_int_test (&parser, "'\\t'", '\t', INTEGER); |
| rust_lex_int_test (&parser, "'\\\\'", '\\', INTEGER); |
| rust_lex_int_test (&parser, "'\\0'", '\0', INTEGER); |
| rust_lex_int_test (&parser, "'\\''", '\'', INTEGER); |
| rust_lex_int_test (&parser, "'\\\"'", '"', INTEGER); |
| |
| rust_lex_int_test (&parser, "b'\\n'", '\n', INTEGER); |
| rust_lex_int_test (&parser, "b'\\r'", '\r', INTEGER); |
| rust_lex_int_test (&parser, "b'\\t'", '\t', INTEGER); |
| rust_lex_int_test (&parser, "b'\\\\'", '\\', INTEGER); |
| rust_lex_int_test (&parser, "b'\\0'", '\0', INTEGER); |
| rust_lex_int_test (&parser, "b'\\''", '\'', INTEGER); |
| rust_lex_int_test (&parser, "b'\\\"'", '"', INTEGER); |
| |
| rust_lex_exception_test (&parser, "'z", "Unterminated character literal"); |
| rust_lex_exception_test (&parser, "b'\\x0'", "Not enough hex digits seen"); |
| rust_lex_exception_test (&parser, "b'\\u{0}'", |
| "Unicode escape in byte literal"); |
| rust_lex_exception_test (&parser, "'\\x0'", "Not enough hex digits seen"); |
| rust_lex_exception_test (&parser, "'\\u0'", "Missing '{' in Unicode escape"); |
| rust_lex_exception_test (&parser, "'\\u{0", "Missing '}' in Unicode escape"); |
| rust_lex_exception_test (&parser, "'\\u{0000007}", "Overlong hex escape"); |
| rust_lex_exception_test (&parser, "'\\u{}", "Not enough hex digits seen"); |
| rust_lex_exception_test (&parser, "'\\Q'", "Invalid escape \\Q in literal"); |
| rust_lex_exception_test (&parser, "b'\\Q'", "Invalid escape \\Q in literal"); |
| |
| rust_lex_int_test (&parser, "23", 23, DECIMAL_INTEGER); |
| rust_lex_int_test (&parser, "2_344__29", 234429, INTEGER); |
| rust_lex_int_test (&parser, "0x1f", 0x1f, INTEGER); |
| rust_lex_int_test (&parser, "23usize", 23, INTEGER); |
| rust_lex_int_test (&parser, "23i32", 23, INTEGER); |
| rust_lex_int_test (&parser, "0x1_f", 0x1f, INTEGER); |
| rust_lex_int_test (&parser, "0b1_101011__", 0x6b, INTEGER); |
| rust_lex_int_test (&parser, "0o001177i64", 639, INTEGER); |
| rust_lex_int_test (&parser, "0x123456789u64", 0x123456789ull, INTEGER); |
| |
| rust_lex_test_trailing_dot (&parser); |
| |
| rust_lex_test_one (&parser, "23.", FLOAT); |
| rust_lex_test_one (&parser, "23.99f32", FLOAT); |
| rust_lex_test_one (&parser, "23e7", FLOAT); |
| rust_lex_test_one (&parser, "23E-7", FLOAT); |
| rust_lex_test_one (&parser, "23e+7", FLOAT); |
| rust_lex_test_one (&parser, "23.99e+7f64", FLOAT); |
| rust_lex_test_one (&parser, "23.82f32", FLOAT); |
| |
| rust_lex_stringish_test (&parser, "hibob", "hibob", IDENT); |
| rust_lex_stringish_test (&parser, "hibob__93", "hibob__93", IDENT); |
| rust_lex_stringish_test (&parser, "thread", "thread", IDENT); |
| rust_lex_stringish_test (&parser, "r#true", "true", IDENT); |
| |
| const int expected1[] = { IDENT, DECIMAL_INTEGER, 0 }; |
| rust_lex_test_sequence (&parser, "r#thread 23", ARRAY_SIZE (expected1), |
| expected1); |
| const int expected2[] = { IDENT, '#', 0 }; |
| rust_lex_test_sequence (&parser, "r#", ARRAY_SIZE (expected2), expected2); |
| |
| rust_lex_stringish_test (&parser, "\"string\"", "string", STRING); |
| rust_lex_stringish_test (&parser, "\"str\\ting\"", "str\ting", STRING); |
| rust_lex_stringish_test (&parser, "\"str\\\"ing\"", "str\"ing", STRING); |
| rust_lex_stringish_test (&parser, "r\"str\\ing\"", "str\\ing", STRING); |
| rust_lex_stringish_test (&parser, "r#\"str\\ting\"#", "str\\ting", STRING); |
| rust_lex_stringish_test (&parser, "r###\"str\\\"ing\"###", "str\\\"ing", |
| STRING); |
| |
| rust_lex_stringish_test (&parser, "b\"string\"", "string", BYTESTRING); |
| rust_lex_stringish_test (&parser, "b\"\x73tring\"", "string", BYTESTRING); |
| rust_lex_stringish_test (&parser, "b\"str\\\"ing\"", "str\"ing", BYTESTRING); |
| rust_lex_stringish_test (&parser, "br####\"\\x73tring\"####", "\\x73tring", |
| BYTESTRING); |
| |
| for (i = 0; i < ARRAY_SIZE (identifier_tokens); ++i) |
| rust_lex_test_one (&parser, identifier_tokens[i].name, |
| identifier_tokens[i].value); |
| |
| for (i = 0; i < ARRAY_SIZE (operator_tokens); ++i) |
| rust_lex_test_one (&parser, operator_tokens[i].name, |
| operator_tokens[i].value); |
| |
| rust_lex_test_completion (&parser); |
| rust_lex_test_push_back (&parser); |
| } |
| |
| #endif /* GDB_SELF_TEST */ |
| |
| |
| |
| void _initialize_rust_exp (); |
| void |
| _initialize_rust_exp () |
| { |
| int code = regcomp (&number_regex, number_regex_text, REG_EXTENDED); |
| /* If the regular expression was incorrect, it was a programming |
| error. */ |
| gdb_assert (code == 0); |
| |
| #if GDB_SELF_TEST |
| selftests::register_test ("rust-lex", rust_lex_tests); |
| #endif |
| } |