diff options
Diffstat (limited to 'gdb/rust-parse.c')
| -rw-r--r-- | gdb/rust-parse.c | 2351 |
1 files changed, 2351 insertions, 0 deletions
diff --git a/gdb/rust-parse.c b/gdb/rust-parse.c new file mode 100644 index 0000000..bb31782 --- /dev/null +++ b/gdb/rust-parse.c @@ -0,0 +1,2351 @@ +/* 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 +{ + LONGEST 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 () +{ + const char *start = pstate->lexptr; + unsigned int length; + const struct token_info *token; + int i; + int is_gdb_var = pstate->lexptr[0] == '$'; + + 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; + 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 + && (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); + + if (current_token == KW_MUT) + lex (); + + 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")); + LONGEST val = current_int_val.val; + if (val < 0) + error (_("Negative array length")); + 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, + LONGEST 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, "\"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 +} |