1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401 |
- /* Rust expression parsing for GDB, the GNU debugger.
- Copyright (C) 2016-2022 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 "gdbsupport/gdb_obstack.h"
- #include "gdbsupport/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 ();
- operation_up result = parse_expr ();
- if (current_token != 0)
- error (_("Syntax error near '%s'"), pstate->prev_lexptr);
- return result;
- }
- 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 result.symbol->type ();
- }
- 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;
- }
- /* A helper for lex_character. Search forward for the closing single
- quote, then convert the bytes from the host charset to UTF-32. */
- static uint32_t
- lex_multibyte_char (const char *text, int *len)
- {
- /* Only look a maximum of 5 bytes for the closing quote. This is
- the maximum for UTF-8. */
- int quote;
- gdb_assert (text[0] != '\'');
- for (quote = 1; text[quote] != '\0' && text[quote] != '\''; ++quote)
- ;
- *len = quote;
- /* The caller will issue an error. */
- if (text[quote] == '\0')
- return 0;
- auto_obstack result;
- convert_between_encodings (host_charset (), HOST_UTF32,
- (const gdb_byte *) text,
- quote, 1, &result, translit_none);
- int size = obstack_object_size (&result);
- if (size > 4)
- error (_("overlong character literal"));
- uint32_t value;
- memcpy (&value, obstack_finish (&result), size);
- return value;
- }
- /* 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;
- if (pstate->lexptr[0] == '\'')
- error (_("empty character literal"));
- else if (pstate->lexptr[0] == '\\')
- value = lex_escape (is_byte);
- else
- {
- int len;
- value = lex_multibyte_char (&pstate->lexptr[0], &len);
- pstate->lexptr += len;
- }
- 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 (HOST_UTF32, "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 == '$'
- /* Allow any non-ASCII character as an identifier. There
- doesn't seem to be a need to be picky about this. */
- || (c & 0x80) != 0);
- }
- /* Lex an identifier. */
- int
- rust_parser::lex_identifier ()
- {
- unsigned int length;
- const struct token_info *token;
- 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;
- /* Allow any non-ASCII character here. This "handles" UTF-8 by
- passing it through. */
- 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[0] & 0x80) != 0)
- ++pstate->lexptr;
- length = pstate->lexptr - start;
- token = NULL;
- if (!is_raw)
- {
- for (const auto &candidate : identifier_tokens)
- {
- if (length == strlen (candidate.name)
- && strncmp (candidate.name, start, length) == 0)
- {
- token = &candidate;
- 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;
- for (const auto &candidate : operator_tokens)
- {
- if (strncmp (candidate.name, pstate->lexptr,
- strlen (candidate.name)) == 0)
- {
- pstate->lexptr += strlen (candidate.name);
- token = &candidate;
- 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 make_operation<rust_parenthesized_operation> (std::move (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 && sym.symbol->aclass () != LOC_TYPEDEF)
- return make_operation<var_value_operation> (sym);
- struct type *type = nullptr;
- if (sym.symbol != nullptr)
- {
- gdb_assert (sym.symbol->aclass () == LOC_TYPEDEF);
- type = sym.symbol->type ();
- }
- 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 ();
- lex ();
- 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)
- {
- /* 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 (const auto &candidate : identifier_tokens)
- rust_lex_test_one (&parser, candidate.name, candidate.value);
- for (const auto &candidate : operator_tokens)
- rust_lex_test_one (&parser, candidate.name, candidate.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
- }
|