| /* Support code for the Ada expression parser, for GDB. | |
| Copyright (C) 1986-2026 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 "ada-exp-parser.h" | |
| #include "ada-exp-parser-gen.h" | |
| #include "ada-lang.h" | |
| #include "block.h" | |
| #include "cli/cli-style.h" | |
| #include "gdbsupport/gdb_regex.h" | |
| #include "gdbsupport/scoped_restore.h" | |
| #include "gdbsupport/selftest.h" | |
| #include "parser-defs.h" | |
| #include "inferior.h" | |
| using namespace expr; | |
| /* The entry point of the bison/yacc-generated parser, defined in | |
| ada-exp-parser-gen.c. Bison produces a declaration for ada_yyparse in | |
| ada-exp-parser-gen.h, but byacc does not, hence this declaration. */ | |
| int ada_yyparse (); | |
| /* Likewise, byacc does not produce a declaration for ada_yydebug. */ | |
| extern int ada_yydebug; | |
| /* A regular expression matching Ada numbers. */ | |
| static const char number_regex_text[] = | |
| /* We have to match the first character. */ | |
| "^" | |
| /* Hex number. */ | |
| "(0x[0-9a-f][0-9a-f]*)" | |
| #define HEX_NUMBER 1 | |
| "|" | |
| /* Floating point number with positive exponent. */ | |
| "([0-9][0-9_]*e[+]?[0-9][0-9_]*)" | |
| #define FLOAT_POSEXP 2 | |
| "|" | |
| /* Floating point number with optional exponent. */ | |
| "([0-9][0-9_]*\\.[0-9][0-9_]*(e[+-][0-9][0-9_]*)?)" | |
| #define FLOAT_OPTEXP 3 | |
| "|" | |
| /* Floating point numbers but in another base. The "llf" is a gdb | |
| extension, see lex_number. The regexp is a little funny so that | |
| it can match only 0, 1, or 2 "l"s. */ | |
| "([0-9][0-9_]*(l?l?f)?#[0-9a-f][0-9a-f_]*#(e[+]?[0-9][0-9_]*)?)" | |
| #define FLOAT_EXTENSION 5 | |
| #define EXPONENT 7 | |
| "|" | |
| /* Based real literals. */ | |
| "([0-9][0-9_]*#[0-9a-f][0-9a-f_]*\\.[0-9a-f][0-9a-f_]*#(e[+-][0-9][0-9_]*)?)" | |
| #define BASED_REAL 8 | |
| "|" | |
| /* Lowly integers. */ | |
| "[0-9][0-9_]*"; | |
| /* The number of subexpressions to allocate space for, including the | |
| "0th" whole match subexpression. */ | |
| #define NUM_SUBEXPRESSIONS 10 | |
| /* The compiled number-matching regex. */ | |
| static compiled_regex number_regex (number_regex_text, | |
| REG_EXTENDED | REG_ICASE, | |
| _("internal error")); | |
| /* A regular expression matching an Ada operator, surrounded by | |
| quotes. */ | |
| static const char operator_regex_text[] = | |
| "^\"(<=|>=|\\*\\*|/=|and|or|xor|not|mod|rem|abs|[-+*/=<>&])\""; | |
| /* The number of subexpressions to allocate space for, including the | |
| "0th" whole match subexpression. */ | |
| #define NUM_OPER_SUBEXPRESSIONS 2 | |
| /* The compiled operator-matching regex. */ | |
| static compiled_regex operator_regex (operator_regex_text, | |
| REG_EXTENDED | REG_ICASE, | |
| _("internal error")); | |
| namespace ada_exp_parser | |
| { | |
| /* Map a string to a code. */ | |
| struct code_entry | |
| { | |
| const char *name; | |
| int code; | |
| }; | |
| /* See ada-exp-parser.h. */ | |
| struct parser_state *pstate; | |
| /* See ada-exp-parser.h. */ | |
| struct ada_parse_state *ada_parser; | |
| /* Copy S2 to S1, removing all underscores, and downcasing all | |
| letters. Stops at END. */ | |
| static void | |
| canonicalize_numeral (char *s1, const char *s2, const char *end) | |
| { | |
| for (; s2 != end; s2 += 1) | |
| { | |
| if (*s2 != '_') | |
| { | |
| *s1 = c_tolower(*s2); | |
| s1 += 1; | |
| } | |
| } | |
| s1[0] = '\000'; | |
| } | |
| /* See ada-exp-parser.h. */ | |
| int | |
| processInt (struct parser_state *par_state, const char *base0, | |
| const char *num0, const char *exp0) | |
| { | |
| long exp; | |
| int base; | |
| /* For the based literal with an "f" prefix, we'll return a | |
| floating-point number. This counts the number of "l"s seen, | |
| to decide the width of the floating-point number to return. -1 | |
| means no "f". */ | |
| int floating_point_l_count = -1; | |
| if (base0 == NULL) | |
| base = 10; | |
| else | |
| { | |
| char *end_of_base; | |
| base = strtol (base0, &end_of_base, 10); | |
| if (base < 2 || base > 16) | |
| error (_("Invalid base: %d."), base); | |
| while (*end_of_base == 'l') | |
| { | |
| ++floating_point_l_count; | |
| ++end_of_base; | |
| } | |
| /* This assertion is ensured by the pattern. */ | |
| gdb_assert (floating_point_l_count == -1 || *end_of_base == 'f'); | |
| if (*end_of_base == 'f') | |
| { | |
| ++end_of_base; | |
| ++floating_point_l_count; | |
| } | |
| /* This assertion is ensured by the pattern. */ | |
| gdb_assert (*end_of_base == '#'); | |
| } | |
| if (exp0 == NULL) | |
| exp = 0; | |
| else | |
| exp = strtol(exp0, (char **) NULL, 10); | |
| gdb_mpz result; | |
| while (c_isxdigit (*num0)) | |
| { | |
| int dig = fromhex (*num0); | |
| if (dig >= base) | |
| error (_("Invalid digit \"%c\" in based literal"), *num0); | |
| result *= base; | |
| result += dig; | |
| ++num0; | |
| } | |
| while (exp > 0) | |
| { | |
| result *= base; | |
| exp -= 1; | |
| } | |
| if (floating_point_l_count > -1) | |
| { | |
| struct type *fp_type; | |
| if (floating_point_l_count == 0) | |
| fp_type = language_lookup_primitive_type (par_state->language (), | |
| par_state->gdbarch (), | |
| "float"); | |
| else if (floating_point_l_count == 1) | |
| fp_type = language_lookup_primitive_type (par_state->language (), | |
| par_state->gdbarch (), | |
| "long_float"); | |
| else | |
| { | |
| /* This assertion is ensured by the pattern. */ | |
| gdb_assert (floating_point_l_count == 2); | |
| fp_type = language_lookup_primitive_type (par_state->language (), | |
| par_state->gdbarch (), | |
| "long_long_float"); | |
| } | |
| ada_yylval.typed_val_float.type = fp_type; | |
| result.write (gdb::make_span (ada_yylval.typed_val_float.val, | |
| fp_type->length ()), | |
| type_byte_order (fp_type), | |
| true); | |
| return FLOAT; | |
| } | |
| const gdb_mpz *value = ada_parser->push_integer (std::move (result)); | |
| int int_bits = gdbarch_int_bit (par_state->gdbarch ()); | |
| int long_bits = gdbarch_long_bit (par_state->gdbarch ()); | |
| int long_long_bits = gdbarch_long_long_bit (par_state->gdbarch ()); | |
| if (fits_in_type (1, *value, int_bits, true)) | |
| ada_yylval.typed_val.type = parse_type (par_state)->builtin_int; | |
| else if (fits_in_type (1, *value, long_bits, true)) | |
| ada_yylval.typed_val.type = parse_type (par_state)->builtin_long; | |
| else if (fits_in_type (1, *value, long_bits, false)) | |
| ada_yylval.typed_val.type | |
| = builtin_type (par_state->gdbarch ())->builtin_unsigned_long; | |
| else if (fits_in_type (1, *value, long_long_bits, true)) | |
| ada_yylval.typed_val.type = parse_type (par_state)->builtin_long_long; | |
| else if (fits_in_type (1, *value, long_long_bits, false)) | |
| ada_yylval.typed_val.type | |
| = builtin_type (par_state->gdbarch ())->builtin_unsigned_long_long; | |
| else if (fits_in_type (1, *value, 128, true)) | |
| ada_yylval.typed_val.type | |
| = language_lookup_primitive_type (par_state->language (), | |
| par_state->gdbarch (), | |
| "long_long_long_integer"); | |
| else if (fits_in_type (1, *value, 128, false)) | |
| ada_yylval.typed_val.type | |
| = language_lookup_primitive_type (par_state->language (), | |
| par_state->gdbarch (), | |
| "unsigned_long_long_long_integer"); | |
| else | |
| error (_("Integer literal out of range")); | |
| ada_yylval.typed_val.val = value; | |
| return INT; | |
| } | |
| /* See ada-exp-parser.h. */ | |
| int | |
| processReal (struct parser_state *par_state, const char *num0) | |
| { | |
| ada_yylval.typed_val_float.type = parse_type (par_state)->builtin_long_double; | |
| bool parsed = parse_float (num0, strlen (num0), | |
| ada_yylval.typed_val_float.type, | |
| ada_yylval.typed_val_float.val); | |
| gdb_assert (parsed); | |
| return FLOAT; | |
| } | |
| /* See ada-exp-parser.h. */ | |
| struct stoken | |
| ada_parse_state::process_id (std::string_view name0) | |
| { | |
| char *name = (char *) obstack_alloc (&temp_space, name0.size () + 11); | |
| struct stoken result; | |
| result.ptr = name; | |
| while (!name0.empty () && c_isspace (name0.back ())) | |
| name0.remove_suffix (1); | |
| if (!name0.empty () | |
| && (name0[0] == '<' || name0.find ("___") != std::string_view::npos)) | |
| { | |
| size_t len = name0.size (); | |
| strncpy (name, name0.data (), len); | |
| name[len] = '\000'; | |
| result.length = len; | |
| return result; | |
| } | |
| bool in_quotes = false; | |
| int i = 0; | |
| for (char c : name0) | |
| { | |
| if (in_quotes) | |
| name[i++] = c; | |
| else if (c_isalnum (c)) | |
| name[i++] = c_tolower (c); | |
| else if (c_isspace (c)) | |
| { | |
| /* Nothing. */ | |
| } | |
| else if (c == '\'') | |
| { | |
| /* Copy the starting quote, but not the ending quote. */ | |
| if (!in_quotes) | |
| name[i++] = c; | |
| in_quotes = !in_quotes; | |
| } | |
| else | |
| name[i++] = c; | |
| } | |
| name[i] = '\000'; | |
| result.length = i; | |
| return result; | |
| } | |
| /* See ada-exp-parser.h. */ | |
| struct stoken | |
| processString (const char *text, int len) | |
| { | |
| const char *p; | |
| char *q; | |
| const char *lim = text + len; | |
| struct stoken result; | |
| q = (char *) obstack_alloc (&ada_parser->temp_space, len); | |
| result.ptr = q; | |
| p = text; | |
| while (p < lim) | |
| { | |
| if (p[0] == '[' && p[1] == '"' && p+2 < lim) | |
| { | |
| if (p[2] == '"') /* "...["""]... */ | |
| { | |
| *q = '"'; | |
| p += 4; | |
| } | |
| else | |
| { | |
| const char *end; | |
| ULONGEST chr = strtoulst (p + 2, &end, 16); | |
| if (chr > 0xff) | |
| error (_("wide strings are not yet supported")); | |
| *q = (char) chr; | |
| p = end + 1; | |
| } | |
| } | |
| else | |
| *q = *p; | |
| q += 1; | |
| p += 1; | |
| } | |
| result.length = q - result.ptr; | |
| return result; | |
| } | |
| /* Returns non-zero iff string SUBSEQ matches a subsequence of STR, ignoring | |
| case. */ | |
| static int | |
| subseqMatch (const char *subseq, const char *str) | |
| { | |
| if (subseq[0] == '\0') | |
| return 1; | |
| else if (str[0] == '\0') | |
| return 0; | |
| else if (c_tolower (subseq[0]) == c_tolower (str[0])) | |
| return subseqMatch (subseq+1, str+1) || subseqMatch (subseq, str+1); | |
| else | |
| return subseqMatch (subseq, str+1); | |
| } | |
| static const struct code_entry attributes[] = | |
| { | |
| { "address", TICK_ADDRESS }, | |
| { "unchecked_access", TICK_ACCESS }, | |
| { "unrestricted_access", TICK_ACCESS }, | |
| { "access", TICK_ACCESS }, | |
| { "first", TICK_FIRST }, | |
| { "last", TICK_LAST }, | |
| { "length", TICK_LENGTH }, | |
| { "max", TICK_MAX }, | |
| { "min", TICK_MIN }, | |
| { "modulus", TICK_MODULUS }, | |
| { "object_size", TICK_OBJECT_SIZE }, | |
| { "pos", TICK_POS }, | |
| { "range", TICK_RANGE }, | |
| { "size", TICK_SIZE }, | |
| { "tag", TICK_TAG }, | |
| { "val", TICK_VAL }, | |
| { "enum_rep", TICK_ENUM_REP }, | |
| { "enum_val", TICK_ENUM_VAL }, | |
| }; | |
| /* See ada-exp-parser.h. */ | |
| int | |
| ada_parse_state::process_attribute (const std::string &str, bool completing) | |
| { | |
| size_t len = str.length (); | |
| if (completing) | |
| { | |
| ada_yylval.sval.ptr = obstack_strndup (&temp_space, str.c_str (), len); | |
| ada_yylval.sval.length = len; | |
| return TICK_COMPLETE; | |
| } | |
| for (const auto &item : attributes) | |
| if (strcasecmp (str.c_str (), item.name) == 0) | |
| return item.code; | |
| std::optional<int> found; | |
| for (const auto &item : attributes) | |
| if (subseqMatch (str.c_str (), item.name)) | |
| { | |
| if (!found.has_value ()) | |
| found = item.code; | |
| else | |
| error (_("ambiguous attribute name: \"%s\""), str.c_str ()); | |
| } | |
| if (!found.has_value ()) | |
| error (_("unrecognized attribute: \"%s\""), str.c_str ()); | |
| return *found; | |
| } | |
| bool | |
| ada_tick_completer::complete (struct expression *exp, | |
| completion_tracker &tracker) | |
| { | |
| completion_list output; | |
| for (const auto &item : attributes) | |
| { | |
| if (strncasecmp (item.name, m_name.c_str (), m_name.length ()) == 0) | |
| output.emplace_back (xstrdup (item.name)); | |
| } | |
| tracker.add_completions (std::move (output)); | |
| return true; | |
| } | |
| int | |
| ada_parse_state::lex_number () | |
| { | |
| const char *num_start = pstate->lexptr; | |
| gdb_assert (c_isdigit (*num_start)); | |
| regmatch_t subexps[NUM_SUBEXPRESSIONS]; | |
| int match = number_regex.exec (num_start, ARRAY_SIZE (subexps), subexps, 0); | |
| /* Failure means the regexp is broken. */ | |
| gdb_assert (match == 0); | |
| pstate->lexptr += subexps[0].rm_eo; | |
| #define NUMERAL_WIDTH 256 | |
| char numbuf[NUMERAL_WIDTH]; | |
| if (subexps[HEX_NUMBER].rm_so != -1) | |
| { | |
| canonicalize_numeral (numbuf, num_start + 2, pstate->lexptr); | |
| return processInt (pstate, "16#", numbuf, nullptr); | |
| } | |
| else if (subexps[FLOAT_POSEXP].rm_so != -1) | |
| { | |
| canonicalize_numeral (numbuf, num_start, pstate->lexptr); | |
| char *e_ptr = strrchr (numbuf, 'e'); | |
| *e_ptr = '\0'; | |
| return processInt (pstate, nullptr, numbuf, e_ptr + 1); | |
| } | |
| else if (subexps[FLOAT_OPTEXP].rm_so != -1) | |
| { | |
| canonicalize_numeral (numbuf, num_start, pstate->lexptr); | |
| return processReal (pstate, numbuf); | |
| } | |
| else if (subexps[FLOAT_EXTENSION].rm_so != -1) | |
| { | |
| canonicalize_numeral (numbuf, num_start, pstate->lexptr); | |
| char *e_ptr = nullptr; | |
| if (subexps[EXPONENT].rm_so != -1) | |
| { | |
| /* We can't use the 'rm_so' here because | |
| canonicalize_numeral might have removed some underscores. | |
| But we know the 'e' appears after the '#' so we can | |
| search for it and not get one of the (possibly hex) | |
| numerals. */ | |
| e_ptr = strrchr (numbuf, 'e'); | |
| gdb_assert (e_ptr != nullptr); | |
| *e_ptr = '\0'; | |
| ++e_ptr; | |
| } | |
| return processInt (pstate, numbuf, strchr (numbuf, '#') + 1, e_ptr); | |
| } | |
| else if (subexps[BASED_REAL].rm_so != -1) | |
| error (_("Based real literals not implemented yet.")); | |
| /* Must be a simple integer. */ | |
| canonicalize_numeral (numbuf, num_start, pstate->lexptr); | |
| return processInt (pstate, nullptr, numbuf, nullptr); | |
| } | |
| static const code_entry keywords[] = | |
| { | |
| { "abs", ABS }, | |
| { "and", _AND_ }, | |
| { "delta", DELTA }, | |
| { "else", ELSE }, | |
| { "for", FOR }, | |
| { "in", IN }, | |
| { "mod", MOD }, | |
| { "new", NEW }, | |
| { "not", NOT }, | |
| { "null", NULL_PTR }, | |
| { "or", OR }, | |
| { "others", OTHERS }, | |
| { "rem", REM }, | |
| { "then", THEN }, | |
| { "with", WITH }, | |
| { "xor", XOR }, | |
| /* True and False are not keywords in Ada, but rather enumeration | |
| constants. However, the boolean type is no longer represented as | |
| an enum, so True and False are no longer defined in symbol | |
| tables. We compromise by making them keywords (when bare). */ | |
| { "true", TRUEKEYWORD }, | |
| { "false", FALSEKEYWORD }, | |
| { "if", 0 }, | |
| { "task", 0 }, | |
| { "thread", -1 }, | |
| }; | |
| bool | |
| ada_parse_state::check_thread_keyword (const char *text) | |
| { | |
| /* "thread" has to be followed by whitespace and then a digit in | |
| order to be treated as a keyword. */ | |
| if (!c_isspace (*text)) | |
| return false; | |
| const char *after = skip_spaces (text); | |
| return c_isdigit (*after); | |
| } | |
| std::optional<int> | |
| ada_parse_state::check_keyword (size_t len) | |
| { | |
| const char *start = pstate->lexptr; | |
| for (const code_entry &entry : keywords) | |
| { | |
| if (strlen (entry.name) == len | |
| && strncasecmp (entry.name, start, len) == 0) | |
| { | |
| int result = entry.code; | |
| if (result == -1) | |
| { | |
| /* Special handling for the "thread" keyword. */ | |
| if (!check_thread_keyword (pstate->lexptr + len)) | |
| continue; | |
| result = 0; | |
| } | |
| return result; | |
| } | |
| } | |
| return std::nullopt; | |
| } | |
| const char * | |
| ada_parse_state::lex_operator (const char *start) | |
| { | |
| gdb_assert (*start == '"'); | |
| regmatch_t subexps[NUM_OPER_SUBEXPRESSIONS]; | |
| int match = operator_regex.exec (start, ARRAY_SIZE (subexps), subexps, 0); | |
| if (match != 0) | |
| return nullptr; | |
| return start + subexps[0].rm_eo; | |
| } | |
| int | |
| ada_parse_state::lex_identifier (const char *id_end) | |
| { | |
| bool is_quoted = *pstate->lexptr == '<'; | |
| bool completing = *id_end == '\0' && pstate->parse_completion; | |
| /* Only check keywords when the identifier is unquoted, and when not | |
| completing. */ | |
| if (!is_quoted && !completing) | |
| { | |
| std::optional<int> result = check_keyword (id_end - pstate->lexptr); | |
| if (result.has_value ()) | |
| { | |
| /* If the keyword results in an EOF, leave the parser's | |
| lexptr pointing at the start of the keyword. Otherwise, | |
| update to the end. */ | |
| if (*result != 0) | |
| pstate->lexptr = id_end; | |
| return *result; | |
| } | |
| } | |
| while (true) | |
| { | |
| const char *iter = skip_spaces (id_end); | |
| if (*iter != '.') | |
| break; | |
| iter = skip_spaces (iter + 1); | |
| const char *new_id_end = nullptr; | |
| if (*iter == '"') | |
| new_id_end = lex_operator (iter); | |
| else if (c_isalpha (*iter) || *iter == '_' || *iter == '<') | |
| new_id_end = lex_simple_identifier (iter); | |
| if (new_id_end == nullptr) | |
| break; | |
| /* Skip ".all" and leave it for a later DOT_ID lex. */ | |
| if (new_id_end - iter == 3 && strncasecmp (iter, "all", 3) == 0) | |
| break; | |
| id_end = new_id_end; | |
| completing = *id_end == '\0' && pstate->parse_completion; | |
| } | |
| ada_yylval.sval = process_id ({ pstate->lexptr, | |
| (size_t) (id_end - pstate->lexptr) }); | |
| id_end = skip_spaces (id_end); | |
| if (*id_end == '\'') | |
| m_before_qual_quote = true; | |
| pstate->lexptr = id_end; | |
| return completing ? NAME_COMPLETE : NAME; | |
| } | |
| void | |
| ada_parse_state::invalid_char () | |
| { | |
| error (_("Invalid character '%c' in expression."), *pstate->lexptr); | |
| } | |
| const char * | |
| ada_parse_state::lex_simple_identifier (const char *text) | |
| { | |
| gdb_assert (c_isalpha (*text) || *text == '_' || *text == '<'); | |
| const char *iter = text; | |
| bool quoted = (*iter == '<'); | |
| if (quoted) | |
| { | |
| ++iter; | |
| if (!c_isalpha (*iter) && *iter != '_') | |
| return nullptr; | |
| ++iter; | |
| } | |
| auto as_unsigned = [] (const char *ptr) | |
| { | |
| return *(const unsigned char *) ptr; | |
| }; | |
| while (c_isalnum (*iter) || *iter == '_' | |
| || (!quoted && as_unsigned (iter) >= 0x80 | |
| && as_unsigned (iter) <= 0xff)) | |
| ++iter; | |
| if (quoted) | |
| { | |
| /* A quirk of the flex lexer was that completion didn't work for | |
| Ada-quoted symbols like <some_encoded_name>. Perhaps TAB | |
| somewhere before the '>' ought to work. */ | |
| if (*iter != '>') | |
| return nullptr; | |
| ++iter; | |
| } | |
| return iter; | |
| } | |
| int | |
| ada_parse_state::lex_dot () | |
| { | |
| gdb_assert (*pstate->lexptr == '.'); | |
| const char *save = pstate->lexptr; | |
| pstate->lexptr = skip_spaces (pstate->lexptr + 1); | |
| int name_token = 0; | |
| if (*pstate->lexptr == '<' || *pstate->lexptr == '_' | |
| || c_isalpha (*pstate->lexptr)) | |
| { | |
| const char *id_end = lex_simple_identifier (pstate->lexptr); | |
| if (id_end != nullptr) | |
| { | |
| pstate->lexptr = id_end; | |
| name_token = NAME; | |
| } | |
| } | |
| if (*pstate->lexptr == '\0' && pstate->parse_completion) | |
| name_token = NAME_COMPLETE; | |
| if (name_token != NAME && name_token != NAME_COMPLETE) | |
| { | |
| pstate->lexptr = save; | |
| invalid_char (); | |
| } | |
| ada_yylval.sval = process_id ({ save + 1, | |
| (size_t) (pstate->lexptr - save - 1) }); | |
| return name_token == NAME_COMPLETE ? DOT_COMPLETE : DOT_ID; | |
| } | |
| const char * | |
| ada_parse_state::recognize_encoded_char (const char *bracket) | |
| { | |
| if (bracket[0] == '[' && bracket[1] == '"') | |
| { | |
| const char *start = bracket + 2; | |
| const char *iter = start; | |
| /* Handle the weird case of ["""], which just means a double | |
| quote. */ | |
| if (*iter == '"') | |
| ++iter; | |
| else | |
| { | |
| while (c_isxdigit (*iter)) | |
| ++iter; | |
| if (iter - start < 2) | |
| return nullptr; | |
| } | |
| if (iter[0] == '"' && iter[1] == ']') | |
| { | |
| /* Ada-style quoted character. */ | |
| return iter + 2; | |
| } | |
| } | |
| return nullptr; | |
| } | |
| int | |
| ada_parse_state::lex_single_quote () | |
| { | |
| gdb_assert (*pstate->lexptr == '\''); | |
| bool before_qual_quote = m_before_qual_quote; | |
| m_before_qual_quote = false; | |
| if (!before_qual_quote) | |
| { | |
| /* Look for the GDB block extension "'STUFF'::". */ | |
| const char *block_iter = pstate->lexptr + 1; | |
| while (*block_iter != '\0' && *block_iter != '\'') | |
| ++block_iter; | |
| /* Require a non-empty block. */ | |
| if (block_iter[0] == '\'' && block_iter - pstate->lexptr - 1 > 0) | |
| { | |
| const char *block_end = skip_spaces (block_iter + 1); | |
| if (block_end[0] == ':' && block_end[1] == ':') | |
| { | |
| ada_yylval.sval | |
| = process_id ({ pstate->lexptr, | |
| (size_t) (block_end - pstate->lexptr) }); | |
| /* Leave the "::" to be lexed later. */ | |
| pstate->lexptr = block_end; | |
| return NAME; | |
| } | |
| } | |
| if (c_isprint (pstate->lexptr[1]) && pstate->lexptr[2] == '\'') | |
| { | |
| /* Ordinary character literal. */ | |
| int the_char = pstate->lexptr[1]; | |
| ada_yylval.typed_char.val = the_char; | |
| ada_yylval.typed_char.type = type_for_char (pstate, the_char); | |
| pstate->lexptr += 3; | |
| return CHARLIT; | |
| } | |
| const char *end_bracket = recognize_encoded_char (pstate->lexptr + 1); | |
| if (end_bracket != nullptr) | |
| { | |
| if (*end_bracket != '\'') | |
| { | |
| /* We saw something pretty odd. */ | |
| error (_("Unterminated character literal")); | |
| } | |
| /* The character starts at an offset from the initial single | |
| quote. */ | |
| ULONGEST v = strtoulst (pstate->lexptr + 3, nullptr, 16); | |
| ada_yylval.typed_char.val = v; | |
| ada_yylval.typed_char.type = type_for_char (pstate, v); | |
| pstate->lexptr = end_bracket + 1; | |
| return CHARLIT; | |
| } | |
| } | |
| /* Handle 'ATTRIBUTE; with a special case when completing just after | |
| a single quote. */ | |
| const char *attr_start = skip_spaces (pstate->lexptr + 1); | |
| if (c_isalpha (*attr_start) | |
| || (pstate->parse_completion && *attr_start == '\0')) | |
| { | |
| const char *iter = attr_start; | |
| while (*iter == '_' || c_isalpha (*iter)) | |
| ++iter; | |
| bool completing = pstate->parse_completion && *iter == '\0'; | |
| pstate->lexptr = iter; | |
| return process_attribute (std::string (attr_start, iter - attr_start), | |
| completing); | |
| } | |
| ++pstate->lexptr; | |
| return '\''; | |
| } | |
| int | |
| ada_parse_state::lex_double_quote () | |
| { | |
| gdb_assert (*pstate->lexptr == '"'); | |
| const char *start = pstate->lexptr + 1; | |
| const char *iter = start; | |
| while (*iter != '"' && *iter != '\0') | |
| { | |
| /* Note that we don't handle bracket sequences of more than 2 | |
| digits here. Currently there's no support for wide or | |
| wide-wide strings. */ | |
| const char *end_bracket = recognize_encoded_char (iter); | |
| if (end_bracket != nullptr) | |
| iter = end_bracket; | |
| else if (c_isprint (*iter)) | |
| ++iter; | |
| else | |
| break; | |
| } | |
| if (*iter != '"') | |
| error (_("ill-formed or non-terminated string literal")); | |
| ada_yylval.sval = processString (start, iter - start); | |
| pstate->lexptr = iter + 1; | |
| return STRING; | |
| } | |
| int | |
| ada_parse_state::lex_dollar () | |
| { | |
| gdb_assert (*pstate->lexptr == '$'); | |
| const char *start = pstate->lexptr++; | |
| while (c_isalnum (*pstate->lexptr) || *pstate->lexptr == '_' | |
| || *pstate->lexptr == '$') | |
| ++pstate->lexptr; | |
| ada_yylval.sval.ptr = start; | |
| ada_yylval.sval.length = pstate->lexptr - start; | |
| return DOLLAR_VARIABLE; | |
| } | |
| static const code_entry punct[] = | |
| { | |
| { "=>", ARROW }, | |
| { "..", DOTDOT }, | |
| { "**", STARSTAR }, | |
| { ":=", ASSIGN }, | |
| { "/=", NOTEQUAL }, | |
| { "<=", LEQ }, | |
| { ">=", GEQ }, | |
| { "::", COLONCOLON }, | |
| /* "--" is documented in the manual as being a comment. */ | |
| { "--", 0 }, | |
| }; | |
| int | |
| ada_parse_state::lex () | |
| { | |
| /* If m_before_qual_quote is set, we must be examining a single | |
| quote. */ | |
| gdb_assert (!m_before_qual_quote || *pstate->lexptr == '\''); | |
| pstate->lexptr = skip_spaces (pstate->lexptr); | |
| if (pstate->lexptr[0] != '\0' && pstate->lexptr[1] != '\0') | |
| for (const code_entry &entry : punct) | |
| { | |
| size_t len = strlen (entry.name); | |
| gdb_assert (len == 2); | |
| if (strncmp (entry.name, pstate->lexptr, len) == 0) | |
| { | |
| /* Handle the "--" comment case specially. */ | |
| if (entry.code == 0) | |
| { | |
| size_t rest = strlen (pstate->lexptr); | |
| pstate->lexptr += rest; | |
| } | |
| else | |
| pstate->lexptr += len; | |
| return entry.code; | |
| } | |
| } | |
| switch (*pstate->lexptr) | |
| { | |
| case '\0': | |
| return 0; | |
| case '-': | |
| case '=': | |
| case '*': | |
| case ':': | |
| case '&': | |
| case '+': | |
| case '{': | |
| case '}': | |
| case '@': | |
| case '/': | |
| case '>': | |
| case '|': | |
| case ';': | |
| case '[': | |
| case ']': | |
| return *pstate->lexptr++; | |
| case ',': | |
| if (m_paren_depth == 0 && pstate->comma_terminates) | |
| return 0; | |
| else | |
| return *pstate->lexptr++; | |
| case '(': | |
| ++m_paren_depth; | |
| return *pstate->lexptr++; | |
| case ')': | |
| if (m_paren_depth == 0) | |
| return 0; | |
| --m_paren_depth; | |
| return *pstate->lexptr++; | |
| case '\'': | |
| return lex_single_quote (); | |
| case '"': | |
| return lex_double_quote (); | |
| case '$': | |
| return lex_dollar (); | |
| case '.': | |
| return lex_dot (); | |
| } | |
| if (c_isalpha (*pstate->lexptr) || *pstate->lexptr == '_' | |
| || *pstate->lexptr == '<') | |
| { | |
| const char *id_end = lex_simple_identifier (pstate->lexptr); | |
| if (id_end == nullptr) | |
| { | |
| /* It shouldn't be possible to reach here when starting with | |
| a letter or underscore. */ | |
| gdb_assert (*pstate->lexptr == '<'); | |
| return *pstate->lexptr++; | |
| } | |
| return lex_identifier (id_end); | |
| } | |
| if (c_isdigit (*pstate->lexptr)) | |
| return lex_number (); | |
| invalid_char (); | |
| } | |
| #if GDB_SELF_TEST | |
| namespace selftests | |
| { | |
| /* Helper that checks that a given lex causes an exception. */ | |
| static void | |
| ada_lex_test_error (const char *input) | |
| { | |
| /* We need a dummy parser. */ | |
| parser_state ps (language_def (language_ada), current_inferior ()->arch (), | |
| nullptr, 0, 0, input, false, nullptr); | |
| scoped_restore save_parser = make_scoped_restore (&pstate, &ps); | |
| ada_parse_state ada_ps (input); | |
| /* This is probably not needed, but also it doesn't hurt. */ | |
| scoped_restore save_aps = make_scoped_restore (&ada_parser, &ada_ps); | |
| bool saw_failure = false; | |
| try | |
| { | |
| ada_ps.lex (); | |
| } | |
| catch (const gdb_exception_error &err) | |
| { | |
| saw_failure = true; | |
| } | |
| SELF_CHECK (saw_failure); | |
| } | |
| /* Helper to check a lexing sequence, also checking string values of | |
| tokens. */ | |
| static void | |
| ada_lex_test_sequence (const char *input, | |
| gdb::span<const code_entry> expected, | |
| bool completion = false) | |
| { | |
| /* We need a dummy parser. */ | |
| parser_state ps (language_def (language_ada), current_inferior ()->arch (), | |
| nullptr, 0, 0, input, completion, nullptr); | |
| scoped_restore save_parser = make_scoped_restore (&pstate, &ps); | |
| ada_parse_state ada_ps (input); | |
| /* This is probably not needed, but also it doesn't hurt. */ | |
| scoped_restore save_aps = make_scoped_restore (&ada_parser, &ada_ps); | |
| for (const code_entry &entry : expected) | |
| { | |
| int token = ada_ps.lex (); | |
| SELF_CHECK (token == entry.code); | |
| bool has_string_value = (token == NAME || token == NAME_COMPLETE | |
| || token == DOT_ID || token == DOT_COMPLETE | |
| || token == STRING | |
| || token == DOLLAR_VARIABLE | |
| || token == TICK_COMPLETE); | |
| if (has_string_value) | |
| { | |
| std::string_view contents (ada_yylval.sval.ptr, | |
| ada_yylval.sval.length); | |
| SELF_CHECK (contents == entry.name); | |
| } | |
| else | |
| SELF_CHECK (entry.name == nullptr); | |
| } | |
| /* Test that all the input was used. */ | |
| SELF_CHECK (*ps.lexptr == '\0'); | |
| } | |
| /* Helper that checks an integer value. */ | |
| static void | |
| ada_lex_test_integer (const char *input, int value) | |
| { | |
| /* We need a dummy parser. */ | |
| parser_state ps (language_def (language_ada), current_inferior ()->arch (), | |
| nullptr, 0, 0, input, false, nullptr); | |
| scoped_restore save_parser = make_scoped_restore (&pstate, &ps); | |
| ada_parse_state ada_ps (input); | |
| /* This is probably not needed, but also it doesn't hurt. */ | |
| scoped_restore save_aps = make_scoped_restore (&ada_parser, &ada_ps); | |
| int token = ada_ps.lex (); | |
| SELF_CHECK (token == INT); | |
| SELF_CHECK (*ada_yylval.typed_val.val == value); | |
| } | |
| static void | |
| ada_lex_tests () | |
| { | |
| const code_entry cc_test[] = | |
| { | |
| { "blockname", NAME }, | |
| { nullptr, COLONCOLON }, | |
| { "duck", NAME }, | |
| { nullptr, 0 } | |
| }; | |
| ada_lex_test_sequence ("blockname::duck", cc_test); | |
| const code_entry ccq_test[] = | |
| { | |
| { "'blockname'", NAME }, | |
| { nullptr, COLONCOLON }, | |
| { "duck", NAME }, | |
| { nullptr, 0 } | |
| }; | |
| ada_lex_test_sequence ("'blockname'::duck", ccq_test); | |
| ada_lex_test_sequence ("'blockname' :: duck", ccq_test); | |
| /* This should not lex as a character literal. */ | |
| const code_entry ccq2_test[] = | |
| { | |
| { "'a'", NAME }, | |
| { nullptr, COLONCOLON }, | |
| { "duck", NAME }, | |
| { nullptr, 0 } | |
| }; | |
| ada_lex_test_sequence ("'a'::duck", ccq2_test); | |
| const code_entry comment_test[] = | |
| { | |
| { "variable", NAME }, | |
| { nullptr, 0 } | |
| }; | |
| ada_lex_test_sequence ("variable -- comment text here", comment_test); | |
| const code_entry oper_test[] = | |
| { | |
| { "name.\"mod\"", NAME }, | |
| { nullptr, 0 } | |
| }; | |
| ada_lex_test_sequence (" name . \"MoD\" ", oper_test); | |
| const code_entry quote_test[] = | |
| { | |
| { "<some__Weird_Name>.whatever", NAME }, | |
| { "all", DOT_ID }, | |
| { "rest", DOT_ID }, | |
| { nullptr, 0 } | |
| }; | |
| ada_lex_test_sequence ("<some__Weird_Name>.whatever.all.rest", quote_test); | |
| const code_entry uquote_test[] = | |
| { | |
| { "<__leading_uscore>", NAME }, | |
| { nullptr, 0 } | |
| }; | |
| ada_lex_test_sequence ("<__leading_uscore>", uquote_test); | |
| const code_entry qual_test[] = | |
| { | |
| { "char_enum", NAME }, | |
| { nullptr, '\'' }, | |
| { nullptr, '(' }, | |
| { nullptr, CHARLIT }, | |
| { nullptr, ')' }, | |
| { nullptr, 0 } | |
| }; | |
| ada_lex_test_sequence (" Char_Enum ' ( 'B' ) ", qual_test); | |
| /* This failed historically since the TAB character is not | |
| "printable". */ | |
| ada_lex_test_error ("\"\t\""); | |
| /* This should fail due to unbalanced quotes. */ | |
| ada_lex_test_error ("'[\"61\"]x"); | |
| const code_entry char_test[] = | |
| { | |
| { nullptr, CHARLIT }, | |
| { nullptr, 0 } | |
| }; | |
| ada_lex_test_sequence ("'[\"61\"]'", char_test); | |
| ada_lex_test_sequence ("'\"'", char_test); | |
| ada_lex_test_sequence ("' '", char_test); | |
| const code_entry str_test[] = | |
| { | |
| { "a string \"", STRING }, | |
| { nullptr, 0 } | |
| }; | |
| ada_lex_test_sequence ("\"[\"61\"] string [\"\"\"]\"", str_test); | |
| const code_entry compl_test[] = | |
| { | |
| { "duck.duck", NAME }, | |
| { "goose", TICK_COMPLETE }, | |
| { nullptr, 0 } | |
| }; | |
| ada_lex_test_sequence ("duck.duck'goose", compl_test, true); | |
| const code_entry compl2_test[] = | |
| { | |
| { "pck.inner", NAME }, | |
| { "", DOT_COMPLETE }, | |
| { nullptr, 0 } | |
| }; | |
| ada_lex_test_sequence ("pck.inner.", compl2_test, true); | |
| const code_entry compl3_test[] = | |
| { | |
| { nullptr, '(' }, | |
| { "name", NAME }, | |
| { nullptr, ')' }, | |
| { "", DOT_COMPLETE }, | |
| { nullptr, 0 } | |
| }; | |
| ada_lex_test_sequence ("(name).", compl3_test, true); | |
| const code_entry compl4_test[] = | |
| { | |
| { nullptr, '(' }, | |
| { "name", NAME }, | |
| { nullptr, ')' }, | |
| { "fl", DOT_COMPLETE }, | |
| { nullptr, 0 } | |
| }; | |
| ada_lex_test_sequence ("(name).fl", compl4_test, true); | |
| const code_entry tick_test[] = | |
| { | |
| { "duck.duck", NAME }, | |
| { nullptr, TICK_MIN }, | |
| { nullptr, 0 } | |
| }; | |
| ada_lex_test_sequence ("duck.duck ' min", tick_test); | |
| const code_entry us3_test[] = | |
| { | |
| { "x", NAME }, | |
| { nullptr, '+' }, | |
| { "a___b", NAME }, | |
| { nullptr, 0 } | |
| }; | |
| ada_lex_test_sequence ("X + a___b", us3_test); | |
| ada_lex_test_integer ("0xff", 255); | |
| ada_lex_test_integer ("0xffff", 65535); | |
| ada_lex_test_integer ("019", 19); | |
| ada_lex_test_integer ("0", 0); | |
| ada_lex_test_integer ("16#ff#", 255); | |
| ada_lex_test_integer ("16#ee#", 238); | |
| ada_lex_test_integer ("16#EE#", 238); | |
| ada_lex_test_integer ("8#77#", 63); | |
| /* Based reals aren't handled. */ | |
| ada_lex_test_error ("16#abcd.ef01#"); | |
| ada_lex_test_error ("16#abcd.ef01#e+23"); | |
| } | |
| } /* namespace selftests */ | |
| #endif /* GDB_SELF_TEST */ | |
| /* See ada-exp-parser.h. */ | |
| operation_up | |
| resolve (operation_up &&op, bool deprocedure_p, struct type *context_type) | |
| { | |
| operation_up result = std::move (op); | |
| ada_resolvable *res = dynamic_cast<ada_resolvable *> (result.get ()); | |
| if (res != nullptr) | |
| return res->replace (std::move (result), | |
| pstate->expout.get (), | |
| deprocedure_p, | |
| pstate->parse_completion, | |
| pstate->block_tracker, | |
| context_type); | |
| return result; | |
| } | |
| /* See ada-exp-parser.h. */ | |
| operation_up | |
| ada_pop (bool deprocedure_p, struct type *context_type) | |
| { | |
| /* Of course it's ok to call parser_state::pop here... */ | |
| return resolve (pstate->pop (), deprocedure_p, context_type); | |
| } | |
| /* See ada-exp-parser.h. */ | |
| void | |
| ada_addrof (struct type *type) | |
| { | |
| operation_up arg = ada_pop (false); | |
| operation_up addr = make_operation<unop_addr_operation> (std::move (arg)); | |
| operation_up wrapped | |
| = make_operation<ada_wrapped_operation> (std::move (addr)); | |
| if (type != nullptr) | |
| wrapped = make_operation<unop_cast_operation> (std::move (wrapped), type); | |
| pstate->push (std::move (wrapped)); | |
| } | |
| /* See ada-exp-parser.h. */ | |
| operation_up | |
| maybe_overload (enum exp_opcode op, operation_up &lhs, operation_up &rhs) | |
| { | |
| struct value *args[2]; | |
| int nargs = 1; | |
| args[0] = lhs->evaluate (nullptr, pstate->expout.get (), | |
| EVAL_AVOID_SIDE_EFFECTS); | |
| if (rhs == nullptr) | |
| args[1] = nullptr; | |
| else | |
| { | |
| args[1] = rhs->evaluate (nullptr, pstate->expout.get (), | |
| EVAL_AVOID_SIDE_EFFECTS); | |
| ++nargs; | |
| } | |
| block_symbol fn = ada_find_operator_symbol (op, pstate->parse_completion, | |
| nargs, args); | |
| if (fn.symbol == nullptr) | |
| return {}; | |
| if (symbol_read_needs_frame (fn.symbol)) | |
| pstate->block_tracker->update (fn.block, INNERMOST_BLOCK_FOR_SYMBOLS); | |
| operation_up callee = make_operation<ada_var_value_operation> (fn); | |
| std::vector<operation_up> argvec; | |
| argvec.push_back (std::move (lhs)); | |
| if (rhs != nullptr) | |
| argvec.push_back (std::move (rhs)); | |
| return make_operation<ada_funcall_operation> (std::move (callee), | |
| std::move (argvec)); | |
| } | |
| /* See ada-exp-parser.h. */ | |
| void | |
| ada_funcall (int nargs) | |
| { | |
| /* We use the ordinary pop here, because we're going to do | |
| resolution in a separate step, in order to handle array | |
| indices. */ | |
| std::vector<operation_up> args = pstate->pop_vector (nargs); | |
| /* Call parser_state::pop here, because we don't want to | |
| function-convert the callee slot of a call we're already | |
| constructing. */ | |
| operation_up callee = pstate->pop (); | |
| ada_var_value_operation *vvo | |
| = dynamic_cast<ada_var_value_operation *> (callee.get ()); | |
| int array_arity = 0; | |
| struct type *callee_t = nullptr; | |
| if (vvo == nullptr | |
| || vvo->get_symbol ()->domain () != UNDEF_DOMAIN) | |
| { | |
| struct value *callee_v = callee->evaluate (nullptr, | |
| pstate->expout.get (), | |
| EVAL_AVOID_SIDE_EFFECTS); | |
| callee_t = ada_check_typedef (callee_v->type ()); | |
| array_arity = ada_array_arity (callee_t); | |
| } | |
| for (int i = 0; i < nargs; ++i) | |
| { | |
| struct type *subtype = nullptr; | |
| if (i < array_arity) | |
| subtype = ada_index_type (callee_t, i + 1, "array type"); | |
| args[i] = resolve (std::move (args[i]), true, subtype); | |
| } | |
| std::unique_ptr<ada_funcall_operation> funcall | |
| (new ada_funcall_operation (std::move (callee), std::move (args))); | |
| funcall->resolve (pstate->expout.get (), true, pstate->parse_completion, | |
| pstate->block_tracker, nullptr); | |
| pstate->push (std::move (funcall)); | |
| } | |
| /* See ada-exp-parser.h. */ | |
| ada_choices_component * | |
| choice_component () | |
| { | |
| ada_component *last = ada_parser->components.back ().get (); | |
| return gdb::checked_static_cast<ada_choices_component *> (last); | |
| } | |
| /* See ada-exp-parser.h. */ | |
| ada_component_up | |
| pop_component () | |
| { | |
| ada_component_up result = std::move (ada_parser->components.back ()); | |
| ada_parser->components.pop_back (); | |
| return result; | |
| } | |
| /* See ada-exp-parser.h. */ | |
| std::vector<ada_component_up> | |
| pop_components (int n) | |
| { | |
| std::vector<ada_component_up> result (n); | |
| for (int i = 1; i <= n; ++i) | |
| result[n - i] = pop_component (); | |
| return result; | |
| } | |
| /* Pop the most recent association from the global stack, and return | |
| it. */ | |
| static ada_association_up | |
| pop_association () | |
| { | |
| ada_association_up result = std::move (ada_parser->associations.back ()); | |
| ada_parser->associations.pop_back (); | |
| return result; | |
| } | |
| /* See ada-exp-parser.h. */ | |
| std::vector<ada_association_up> | |
| pop_associations (int n) | |
| { | |
| std::vector<ada_association_up> result (n); | |
| for (int i = 1; i <= n; ++i) | |
| result[n - i] = pop_association (); | |
| return result; | |
| } | |
| /* See ada-exp-parser.h. */ | |
| std::unique_ptr<expr_completion_base> | |
| make_tick_completer (struct stoken tok) | |
| { | |
| return (std::unique_ptr<expr_completion_base> | |
| (new ada_tick_completer (std::string (tok.ptr, tok.length)))); | |
| } | |
| /* Emit expression to access an instance of SYM, in block BLOCK (if | |
| non-NULL). */ | |
| static void | |
| write_var_from_sym (struct parser_state *par_state, block_symbol sym) | |
| { | |
| if (symbol_read_needs_frame (sym.symbol)) | |
| par_state->block_tracker->update (sym.block, INNERMOST_BLOCK_FOR_SYMBOLS); | |
| par_state->push_new<ada_var_value_operation> (sym); | |
| } | |
| /* See ada-exp-parser.h. */ | |
| void | |
| write_int (struct parser_state *par_state, LONGEST arg, struct type *type) | |
| { | |
| pstate->push_new<long_const_operation> (type, arg); | |
| ada_wrap<ada_wrapped_operation> (); | |
| } | |
| /* Emit expression corresponding to the renamed object named | |
| designated by RENAMED_ENTITY[0 .. RENAMED_ENTITY_LEN-1] in the | |
| context of ORIG_LEFT_CONTEXT, to which is applied the operations | |
| encoded by RENAMING_EXPR. MAX_DEPTH is the maximum number of | |
| cascaded renamings to allow. If ORIG_LEFT_CONTEXT is null, it | |
| defaults to the currently selected block. ORIG_SYMBOL is the | |
| symbol that originally encoded the renaming. It is needed only | |
| because its prefix also qualifies any index variables used to index | |
| or slice an array. It should not be necessary once we go to the | |
| new encoding entirely (FIXME pnh 7/20/2007). */ | |
| static void | |
| write_object_renaming (struct parser_state *par_state, | |
| const struct block *orig_left_context, | |
| const char *renamed_entity, int renamed_entity_len, | |
| const char *renaming_expr, int max_depth) | |
| { | |
| char *name; | |
| enum { SIMPLE_INDEX, LOWER_BOUND, UPPER_BOUND } slice_state; | |
| if (max_depth <= 0) | |
| error (_("Could not find renamed symbol")); | |
| if (orig_left_context == NULL) | |
| orig_left_context = get_selected_block (); | |
| name = obstack_strndup (&ada_parser->temp_space, renamed_entity, | |
| renamed_entity_len); | |
| block_symbol sym_info = ada_lookup_encoded_symbol (name, orig_left_context, | |
| SEARCH_VFT); | |
| if (sym_info.symbol == NULL) | |
| error (_("Could not find renamed variable: %ps"), | |
| styled_string (variable_name_style.style (), | |
| ada_decode (name).c_str ())); | |
| else if (sym_info.symbol->loc_class () == LOC_TYPEDEF) | |
| /* We have a renaming of an old-style renaming symbol. Don't | |
| trust the block information. */ | |
| sym_info.block = orig_left_context; | |
| { | |
| const char *inner_renamed_entity; | |
| int inner_renamed_entity_len; | |
| const char *inner_renaming_expr; | |
| switch (ada_parse_renaming (sym_info.symbol, &inner_renamed_entity, | |
| &inner_renamed_entity_len, | |
| &inner_renaming_expr)) | |
| { | |
| case ADA_NOT_RENAMING: | |
| write_var_from_sym (par_state, sym_info); | |
| break; | |
| case ADA_OBJECT_RENAMING: | |
| write_object_renaming (par_state, sym_info.block, | |
| inner_renamed_entity, inner_renamed_entity_len, | |
| inner_renaming_expr, max_depth - 1); | |
| break; | |
| default: | |
| goto BadEncoding; | |
| } | |
| } | |
| slice_state = SIMPLE_INDEX; | |
| while (*renaming_expr == 'X') | |
| { | |
| renaming_expr += 1; | |
| switch (*renaming_expr) { | |
| case 'A': | |
| renaming_expr += 1; | |
| ada_wrap<ada_unop_ind_operation> (); | |
| break; | |
| case 'L': | |
| slice_state = LOWER_BOUND; | |
| [[fallthrough]]; | |
| case 'S': | |
| renaming_expr += 1; | |
| if (c_isdigit (*renaming_expr)) | |
| { | |
| char *next; | |
| long val = strtol (renaming_expr, &next, 10); | |
| if (next == renaming_expr) | |
| goto BadEncoding; | |
| renaming_expr = next; | |
| write_int (par_state, val, parse_type (par_state)->builtin_int); | |
| } | |
| else | |
| { | |
| const char *end; | |
| char *index_name; | |
| end = strchr (renaming_expr, 'X'); | |
| if (end == NULL) | |
| end = renaming_expr + strlen (renaming_expr); | |
| index_name = obstack_strndup (&ada_parser->temp_space, | |
| renaming_expr, | |
| end - renaming_expr); | |
| renaming_expr = end; | |
| block_symbol index_sym_info | |
| = ada_lookup_encoded_symbol (index_name, orig_left_context, | |
| SEARCH_VFT); | |
| if (index_sym_info.symbol == NULL) | |
| error (_("Could not find %s"), index_name); | |
| else if (index_sym_info.symbol->loc_class () == LOC_TYPEDEF) | |
| /* Index is an old-style renaming symbol. */ | |
| index_sym_info.block = orig_left_context; | |
| write_var_from_sym (par_state, index_sym_info); | |
| } | |
| if (slice_state == SIMPLE_INDEX) | |
| ada_funcall (1); | |
| else if (slice_state == LOWER_BOUND) | |
| slice_state = UPPER_BOUND; | |
| else if (slice_state == UPPER_BOUND) | |
| { | |
| ada_wrap3<ada_ternop_slice_operation> (); | |
| slice_state = SIMPLE_INDEX; | |
| } | |
| break; | |
| case 'R': | |
| { | |
| const char *end; | |
| renaming_expr += 1; | |
| if (slice_state != SIMPLE_INDEX) | |
| goto BadEncoding; | |
| end = strchr (renaming_expr, 'X'); | |
| if (end == NULL) | |
| end = renaming_expr + strlen (renaming_expr); | |
| operation_up arg = ada_pop (); | |
| pstate->push_new<ada_structop_operation> | |
| (std::move (arg), std::string (renaming_expr, | |
| end - renaming_expr)); | |
| renaming_expr = end; | |
| break; | |
| } | |
| default: | |
| goto BadEncoding; | |
| } | |
| } | |
| if (slice_state == SIMPLE_INDEX) | |
| return; | |
| BadEncoding: | |
| error (_("Internal error in encoding of renaming declaration")); | |
| } | |
| /* See ada-exp-parser.h. */ | |
| const struct block* | |
| block_lookup (const struct block *context, const char *raw_name) | |
| { | |
| const char *name; | |
| struct symtab *symtab; | |
| const struct block *result = NULL; | |
| std::string name_storage; | |
| if (raw_name[0] == '\'') | |
| { | |
| raw_name += 1; | |
| name = raw_name; | |
| } | |
| else | |
| { | |
| name_storage = ada_encode (raw_name); | |
| name = name_storage.c_str (); | |
| } | |
| std::vector<struct block_symbol> syms | |
| = ada_lookup_symbol_list (name, context, SEARCH_FUNCTION_DOMAIN); | |
| if (context == NULL | |
| && (syms.empty () || syms[0].symbol->loc_class () != LOC_BLOCK)) | |
| symtab = lookup_symtab (current_program_space, name); | |
| else | |
| symtab = NULL; | |
| if (symtab != NULL) | |
| result = symtab->compunit ().blockvector ()->static_block (); | |
| else if (syms.empty () || syms[0].symbol->loc_class () != LOC_BLOCK) | |
| { | |
| if (context == NULL) | |
| error (_("No file or function \"%s\"."), raw_name); | |
| else | |
| error (_("No function \"%s\" in specified context."), raw_name); | |
| } | |
| else | |
| { | |
| if (syms.size () > 1) | |
| warning (_("Function name \"%s\" ambiguous here"), raw_name); | |
| result = syms[0].symbol->value_block (); | |
| } | |
| return result; | |
| } | |
| static struct symbol* | |
| select_possible_type_sym (const std::vector<struct block_symbol> &syms) | |
| { | |
| int i; | |
| int preferred_index; | |
| struct type *preferred_type; | |
| preferred_index = -1; preferred_type = NULL; | |
| for (i = 0; i < syms.size (); i += 1) | |
| switch (syms[i].symbol->loc_class ()) | |
| { | |
| case LOC_TYPEDEF: | |
| if (ada_prefer_type (syms[i].symbol->type (), preferred_type)) | |
| { | |
| preferred_index = i; | |
| preferred_type = syms[i].symbol->type (); | |
| } | |
| break; | |
| case LOC_REGISTER: | |
| case LOC_ARG: | |
| case LOC_REF_ARG: | |
| case LOC_REGPARM_ADDR: | |
| case LOC_LOCAL: | |
| case LOC_COMPUTED: | |
| return NULL; | |
| default: | |
| break; | |
| } | |
| if (preferred_type == NULL) | |
| return NULL; | |
| return syms[preferred_index].symbol; | |
| } | |
| static struct type* | |
| find_primitive_type (struct parser_state *par_state, const char *name) | |
| { | |
| struct type *type; | |
| type = language_lookup_primitive_type (par_state->language (), | |
| par_state->gdbarch (), | |
| name); | |
| if (type == NULL && streq ("system__address", name)) | |
| type = type_system_address (par_state); | |
| if (type != NULL) | |
| { | |
| /* Check to see if we have a regular definition of this | |
| type that just didn't happen to have been read yet. */ | |
| struct symbol *sym; | |
| char *expanded_name = | |
| (char *) alloca (strlen (name) + sizeof ("standard__")); | |
| strcpy (expanded_name, "standard__"); | |
| strcat (expanded_name, name); | |
| sym = ada_lookup_symbol (expanded_name, NULL, SEARCH_TYPE_DOMAIN).symbol; | |
| if (sym != NULL && sym->loc_class () == LOC_TYPEDEF) | |
| type = sym->type (); | |
| } | |
| return type; | |
| } | |
| static int | |
| chop_selector (const char *name, int end) | |
| { | |
| int i; | |
| for (i = end - 1; i > 0; i -= 1) | |
| if (name[i] == '.' || (name[i] == '_' && name[i+1] == '_')) | |
| return i; | |
| return -1; | |
| } | |
| /* If NAME is a string beginning with a separator (either '__', or | |
| '.'), chop this separator and return the result; else, return | |
| NAME. */ | |
| static const char * | |
| chop_separator (const char *name) | |
| { | |
| if (*name == '.') | |
| return name + 1; | |
| if (name[0] == '_' && name[1] == '_') | |
| return name + 2; | |
| return name; | |
| } | |
| /* Given that SELS is a string of the form (<sep><identifier>)*, where | |
| <sep> is '__' or '.', write the indicated sequence of | |
| STRUCTOP_STRUCT expression operators. Returns a pointer to the | |
| last operation that was pushed. */ | |
| static ada_structop_operation * | |
| write_selectors (struct parser_state *par_state, const char *sels) | |
| { | |
| ada_structop_operation *result = nullptr; | |
| while (*sels != '\0') | |
| { | |
| const char *p = chop_separator (sels); | |
| sels = p; | |
| while (*sels != '\0' && *sels != '.' | |
| && (sels[0] != '_' || sels[1] != '_')) | |
| sels += 1; | |
| operation_up arg = ada_pop (); | |
| result = new ada_structop_operation (std::move (arg), | |
| std::string (p, sels - p)); | |
| pstate->push (operation_up (result)); | |
| } | |
| return result; | |
| } | |
| /* Write a variable access (OP_VAR_VALUE) to ambiguous encoded name | |
| NAME[0..LEN-1], in block context BLOCK, to be resolved later. Writes | |
| a temporary symbol that is valid until the next call to ada_parse. | |
| */ | |
| static void | |
| write_ambiguous_var (struct parser_state *par_state, | |
| const struct block *block, const char *name, int len) | |
| { | |
| struct symbol *sym = new (&ada_parser->temp_space) symbol (); | |
| sym->set_domain (UNDEF_DOMAIN); | |
| sym->set_linkage_name (obstack_strndup (&ada_parser->temp_space, name, len)); | |
| sym->set_language (language_ada, nullptr); | |
| block_symbol bsym { sym, block }; | |
| par_state->push_new<ada_var_value_operation> (bsym); | |
| } | |
| /* A convenient wrapper around ada_get_field_index that takes | |
| a non NUL-terminated FIELD_NAME0 and a FIELD_NAME_LEN instead | |
| of a NUL-terminated field name. */ | |
| static int | |
| ada_nget_field_index (const struct type *type, const char *field_name0, | |
| int field_name_len, int maybe_missing) | |
| { | |
| char *field_name = (char *) alloca ((field_name_len + 1) * sizeof (char)); | |
| strncpy (field_name, field_name0, field_name_len); | |
| field_name[field_name_len] = '\0'; | |
| return ada_get_field_index (type, field_name, maybe_missing); | |
| } | |
| /* If encoded_field_name is the name of a field inside symbol SYM, | |
| then return the type of that field. Otherwise, return NULL. | |
| This function is actually recursive, so if ENCODED_FIELD_NAME | |
| doesn't match one of the fields of our symbol, then try to see | |
| if ENCODED_FIELD_NAME could not be a succession of field names | |
| (in other words, the user entered an expression of the form | |
| TYPE_NAME.FIELD1.FIELD2.FIELD3), in which case we evaluate | |
| each field name sequentially to obtain the desired field type. | |
| In case of failure, we return NULL. */ | |
| static struct type * | |
| get_symbol_field_type (struct symbol *sym, const char *encoded_field_name) | |
| { | |
| const char *field_name = encoded_field_name; | |
| const char *subfield_name; | |
| struct type *type = sym->type (); | |
| int fieldno; | |
| if (type == NULL || field_name == NULL) | |
| return NULL; | |
| type = check_typedef (type); | |
| while (field_name[0] != '\0') | |
| { | |
| field_name = chop_separator (field_name); | |
| fieldno = ada_get_field_index (type, field_name, 1); | |
| if (fieldno >= 0) | |
| return type->field (fieldno).type (); | |
| subfield_name = field_name; | |
| while (*subfield_name != '\0' && *subfield_name != '.' | |
| && (subfield_name[0] != '_' || subfield_name[1] != '_')) | |
| subfield_name += 1; | |
| if (subfield_name[0] == '\0') | |
| return NULL; | |
| fieldno = ada_nget_field_index (type, field_name, | |
| subfield_name - field_name, 1); | |
| if (fieldno < 0) | |
| return NULL; | |
| type = type->field (fieldno).type (); | |
| field_name = subfield_name; | |
| } | |
| return NULL; | |
| } | |
| /* See ada-exp-parser.h. */ | |
| struct type* | |
| write_var_or_type (struct parser_state *par_state, | |
| const struct block *block, struct stoken name0) | |
| { | |
| int depth; | |
| char *encoded_name; | |
| int name_len; | |
| std::string name_storage = ada_encode (name0.ptr); | |
| if (block == nullptr) | |
| { | |
| auto iter = ada_parser->iterated_associations.find (name_storage); | |
| if (iter != ada_parser->iterated_associations.end ()) | |
| { | |
| auto op = std::make_unique<ada_index_var_operation> (); | |
| iter->second.push_back (op.get ()); | |
| par_state->push (std::move (op)); | |
| return nullptr; | |
| } | |
| block = par_state->expression_context_block; | |
| } | |
| name_len = name_storage.size (); | |
| encoded_name = obstack_strndup (&ada_parser->temp_space, | |
| name_storage.c_str (), | |
| name_len); | |
| for (depth = 0; depth < MAX_RENAMING_CHAIN_LENGTH; depth += 1) | |
| { | |
| int tail_index; | |
| tail_index = name_len; | |
| while (tail_index > 0) | |
| { | |
| struct symbol *type_sym; | |
| struct symbol *renaming_sym; | |
| const char* renaming; | |
| int renaming_len; | |
| const char* renaming_expr; | |
| int terminator = encoded_name[tail_index]; | |
| encoded_name[tail_index] = '\0'; | |
| /* In order to avoid double-encoding, we want to only pass | |
| the decoded form to lookup functions. */ | |
| std::string decoded_name = ada_decode (encoded_name); | |
| encoded_name[tail_index] = terminator; | |
| std::vector<struct block_symbol> syms | |
| = ada_lookup_symbol_list (decoded_name.c_str (), block, | |
| SEARCH_VFT); | |
| type_sym = select_possible_type_sym (syms); | |
| if (type_sym != NULL) | |
| renaming_sym = type_sym; | |
| else if (syms.size () == 1) | |
| renaming_sym = syms[0].symbol; | |
| else | |
| renaming_sym = NULL; | |
| switch (ada_parse_renaming (renaming_sym, &renaming, | |
| &renaming_len, &renaming_expr)) | |
| { | |
| case ADA_NOT_RENAMING: | |
| break; | |
| case ADA_PACKAGE_RENAMING: | |
| case ADA_EXCEPTION_RENAMING: | |
| case ADA_SUBPROGRAM_RENAMING: | |
| { | |
| int alloc_len = renaming_len + name_len - tail_index + 1; | |
| char *new_name | |
| = (char *) obstack_alloc (&ada_parser->temp_space, | |
| alloc_len); | |
| strncpy (new_name, renaming, renaming_len); | |
| strcpy (new_name + renaming_len, encoded_name + tail_index); | |
| encoded_name = new_name; | |
| name_len = renaming_len + name_len - tail_index; | |
| goto TryAfterRenaming; | |
| } | |
| case ADA_OBJECT_RENAMING: | |
| write_object_renaming (par_state, block, renaming, renaming_len, | |
| renaming_expr, MAX_RENAMING_CHAIN_LENGTH); | |
| write_selectors (par_state, encoded_name + tail_index); | |
| return NULL; | |
| default: | |
| internal_error (_("impossible value from ada_parse_renaming")); | |
| } | |
| if (type_sym != NULL) | |
| { | |
| struct type *field_type; | |
| if (tail_index == name_len) | |
| return type_sym->type (); | |
| /* We have some extraneous characters after the type name. | |
| If this is an expression "TYPE_NAME.FIELD0.[...].FIELDN", | |
| then try to get the type of FIELDN. */ | |
| field_type | |
| = get_symbol_field_type (type_sym, encoded_name + tail_index); | |
| if (field_type != NULL) | |
| return field_type; | |
| else | |
| error (_("Invalid attempt to select from type: \"%s\"."), | |
| name0.ptr); | |
| } | |
| else if (tail_index == name_len && syms.empty ()) | |
| { | |
| struct type *type = find_primitive_type (par_state, | |
| encoded_name); | |
| if (type != NULL) | |
| return type; | |
| } | |
| if (syms.size () == 1) | |
| { | |
| write_var_from_sym (par_state, syms[0]); | |
| write_selectors (par_state, encoded_name + tail_index); | |
| return NULL; | |
| } | |
| else if (syms.empty ()) | |
| { | |
| struct objfile *objfile = nullptr; | |
| if (block != nullptr) | |
| objfile = block->objfile (); | |
| bound_minimal_symbol msym | |
| = ada_lookup_simple_minsym (decoded_name.c_str (), objfile); | |
| if (msym.minsym != NULL) | |
| { | |
| par_state->push_new<ada_var_msym_value_operation> (msym); | |
| /* Maybe cause error here rather than later? FIXME? */ | |
| write_selectors (par_state, encoded_name + tail_index); | |
| return NULL; | |
| } | |
| if (tail_index == name_len | |
| && strncmp (encoded_name, "standard__", | |
| sizeof ("standard__") - 1) == 0) | |
| error (_("No definition of \"%s\" found."), name0.ptr); | |
| tail_index = chop_selector (encoded_name, tail_index); | |
| } | |
| else | |
| { | |
| write_ambiguous_var (par_state, block, encoded_name, | |
| tail_index); | |
| write_selectors (par_state, encoded_name + tail_index); | |
| return NULL; | |
| } | |
| } | |
| if (!current_program_space->has_full_symbols () | |
| && !current_program_space->has_partial_symbols () | |
| && block == NULL) | |
| error (_("No symbol table is loaded. Use the \"%ps\" command."), | |
| styled_string (command_style.style (), "file")); | |
| if (block == par_state->expression_context_block) | |
| error (_("No definition of \"%s\" in current context."), name0.ptr); | |
| else | |
| error (_("No definition of \"%s\" in specified context."), name0.ptr); | |
| TryAfterRenaming: ; | |
| } | |
| error (_("Could not find renamed symbol \"%s\""), name0.ptr); | |
| } | |
| /* Because ada_completer_word_break_characters does not contain '.' -- | |
| and it cannot easily be added, this breaks other completions -- we | |
| have to recreate the completion word-splitting here, so that we can | |
| provide a prefix that is then used when completing field names. | |
| Without this, an attempt like "complete print abc.d" will give a | |
| result like "print def" rather than "print abc.def". */ | |
| std::string | |
| ada_parse_state::find_completion_bounds () | |
| { | |
| const char *end = pstate->lexptr; | |
| /* First the end of the prefix. Here we stop at the token start or | |
| at '.' or space. */ | |
| for (; end > m_original_expr && end[-1] != '.' && !c_isspace (end[-1]); --end) | |
| { | |
| /* Nothing. */ | |
| } | |
| /* Now find the start of the prefix. */ | |
| const char *ptr = end; | |
| /* Here we allow '.'. */ | |
| for (; | |
| ptr > m_original_expr && (ptr[-1] == '.' | |
| || ptr[-1] == '_' | |
| || (ptr[-1] >= 'a' && ptr[-1] <= 'z') | |
| || (ptr[-1] >= 'A' && ptr[-1] <= 'Z') | |
| || (ptr[-1] & 0xff) >= 0x80); | |
| --ptr) | |
| { | |
| /* Nothing. */ | |
| } | |
| /* ... except, skip leading spaces. */ | |
| ptr = skip_spaces (ptr); | |
| return std::string (ptr, end); | |
| } | |
| /* See ada-exp-parser.h. */ | |
| struct type * | |
| write_var_or_type_completion (struct parser_state *par_state, | |
| const struct block *block, struct stoken name0) | |
| { | |
| int tail_index = chop_selector (name0.ptr, name0.length); | |
| /* If there's no separator, just defer to ordinary symbol | |
| completion. */ | |
| if (tail_index == -1) | |
| return write_var_or_type (par_state, block, name0); | |
| std::string copy (name0.ptr, tail_index); | |
| struct type *type = write_var_or_type (par_state, block, | |
| { copy.c_str (), | |
| (int) copy.length () }); | |
| /* For completion purposes, it's enough that we return a type | |
| here. */ | |
| if (type != nullptr) | |
| return type; | |
| ada_structop_operation *op = write_selectors (par_state, | |
| name0.ptr + tail_index); | |
| op->set_prefix (ada_parser->find_completion_bounds ()); | |
| par_state->mark_struct_expression (op); | |
| return nullptr; | |
| } | |
| /* See ada-exp-parser.h. */ | |
| void | |
| write_name_assoc (struct parser_state *par_state, struct stoken name) | |
| { | |
| if (strchr (name.ptr, '.') == NULL) | |
| { | |
| std::vector<struct block_symbol> syms | |
| = ada_lookup_symbol_list (name.ptr, | |
| par_state->expression_context_block, | |
| SEARCH_VFT); | |
| if (syms.size () != 1 || syms[0].symbol->loc_class () == LOC_TYPEDEF) | |
| pstate->push_new<ada_string_operation> (copy_name (name)); | |
| else | |
| write_var_from_sym (par_state, syms[0]); | |
| } | |
| else | |
| if (write_var_or_type (par_state, NULL, name) != NULL) | |
| error (_("Invalid use of type.")); | |
| push_association<ada_name_association> (ada_pop ()); | |
| } | |
| /* See ada-exp-parser.h. */ | |
| struct type * | |
| type_for_char (struct parser_state *par_state, ULONGEST value) | |
| { | |
| if (value <= 0xff) | |
| return language_string_char_type (par_state->language (), | |
| par_state->gdbarch ()); | |
| else if (value <= 0xffff) | |
| return language_lookup_primitive_type (par_state->language (), | |
| par_state->gdbarch (), | |
| "wide_character"); | |
| return language_lookup_primitive_type (par_state->language (), | |
| par_state->gdbarch (), | |
| "wide_wide_character"); | |
| } | |
| /* See ada-exp-parser.h. */ | |
| struct type * | |
| type_system_address (struct parser_state *par_state) | |
| { | |
| struct type *type | |
| = language_lookup_primitive_type (par_state->language (), | |
| par_state->gdbarch (), | |
| "system__address"); | |
| return type != NULL ? type : parse_type (par_state)->builtin_data_ptr; | |
| } | |
| /* See ada-exp-parser.h. */ | |
| void | |
| ada_yyerror (const char *msg) | |
| { | |
| ada_exp_parser::pstate->parse_error (msg); | |
| } | |
| } /* namespace ada_exp_parser */ | |
| /* See ada-exp-parser.h. */ | |
| int | |
| ada_parse (struct parser_state *par_state) | |
| { | |
| using namespace ada_exp_parser; | |
| /* Setting up the parser state. */ | |
| scoped_restore pstate_restore = make_scoped_restore (&pstate, par_state); | |
| gdb_assert (par_state != NULL); | |
| ada_parse_state parser (par_state->lexptr); | |
| scoped_restore parser_restore = make_scoped_restore (&ada_parser, &parser); | |
| scoped_restore restore_yydebug = make_scoped_restore (&ada_yydebug, | |
| par_state->debug); | |
| int result = ada_yyparse (); | |
| if (!result) | |
| { | |
| struct type *context_type = nullptr; | |
| if (par_state->void_context_p) | |
| context_type = parse_type (par_state)->builtin_void; | |
| pstate->set_operation (ada_pop (true, context_type)); | |
| } | |
| return result; | |
| } | |
| INIT_GDB_FILE (ada_exp_parser) | |
| { | |
| #if GDB_SELF_TEST | |
| selftests::register_test ("ada-lex", ada_exp_parser::selftests::ada_lex_tests); | |
| #endif | |
| } |