| /* Support code for the D expression parser, for GDB. | |
| Copyright (C) 2014-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 "d-exp-parser.h" | |
| #include "d-exp-parser-gen.h" | |
| #include "block.h" | |
| #include "c-exp-parser.h" | |
| #include "c-lang.h" | |
| #include "charset.h" | |
| #include "expression.h" | |
| #include "language.h" | |
| #include "value.h" | |
| /* The entry point of the bison/yacc-generated parser, defined in | |
| d-exp-parser-gen.c. Bison produces a declaration for d_yyparse in | |
| d-exp-parser-gen.h, but byacc does not, hence this declaration. */ | |
| int d_yyparse (); | |
| /* Likewise, byacc does not produce a declaration for d_yydebug. */ | |
| extern int d_yydebug; | |
| namespace d_exp_parser | |
| { | |
| /* See d-exp-parser.h. */ | |
| parser_state *pstate; | |
| /* See d-exp-parser.h. */ | |
| struct type_stack *type_stack; | |
| /* See d-exp-parser.h. */ | |
| int | |
| type_aggregate_p (struct type *type) | |
| { | |
| return (type->code () == TYPE_CODE_STRUCT | |
| || type->code () == TYPE_CODE_UNION | |
| || type->code () == TYPE_CODE_MODULE | |
| || (type->code () == TYPE_CODE_ENUM | |
| && type->is_declared_class ())); | |
| } | |
| /* See d-exp-parser.h. */ | |
| int | |
| parse_number (struct parser_state *ps, const char *p, | |
| int len, int parsed_float, d_exp_parser_YYSTYPE *putithere) | |
| { | |
| ULONGEST n = 0; | |
| ULONGEST prevn = 0; | |
| ULONGEST un; | |
| int i = 0; | |
| int c; | |
| int base = input_radix; | |
| int unsigned_p = 0; | |
| int long_p = 0; | |
| /* We have found a "L" or "U" suffix. */ | |
| int found_suffix = 0; | |
| ULONGEST high_bit; | |
| struct type *signed_type; | |
| struct type *unsigned_type; | |
| if (parsed_float) | |
| { | |
| char *s, *sp; | |
| /* Strip out all embedded '_' before passing to parse_float. */ | |
| s = (char *) alloca (len + 1); | |
| sp = s; | |
| while (len-- > 0) | |
| { | |
| if (*p != '_') | |
| *sp++ = *p; | |
| p++; | |
| } | |
| *sp = '\0'; | |
| len = strlen (s); | |
| /* Check suffix for `i' , `fi' or `li' (idouble, ifloat or ireal). */ | |
| if (len >= 1 && c_tolower (s[len - 1]) == 'i') | |
| { | |
| if (len >= 2 && c_tolower (s[len - 2]) == 'f') | |
| { | |
| putithere->typed_val_float.type | |
| = parse_d_type (ps)->builtin_ifloat; | |
| len -= 2; | |
| } | |
| else if (len >= 2 && c_tolower (s[len - 2]) == 'l') | |
| { | |
| putithere->typed_val_float.type | |
| = parse_d_type (ps)->builtin_ireal; | |
| len -= 2; | |
| } | |
| else | |
| { | |
| putithere->typed_val_float.type | |
| = parse_d_type (ps)->builtin_idouble; | |
| len -= 1; | |
| } | |
| } | |
| /* Check suffix for `f' or `l'' (float or real). */ | |
| else if (len >= 1 && c_tolower (s[len - 1]) == 'f') | |
| { | |
| putithere->typed_val_float.type | |
| = parse_d_type (ps)->builtin_float; | |
| len -= 1; | |
| } | |
| else if (len >= 1 && c_tolower (s[len - 1]) == 'l') | |
| { | |
| putithere->typed_val_float.type | |
| = parse_d_type (ps)->builtin_real; | |
| len -= 1; | |
| } | |
| /* Default type if no suffix. */ | |
| else | |
| { | |
| putithere->typed_val_float.type | |
| = parse_d_type (ps)->builtin_double; | |
| } | |
| if (!parse_float (s, len, | |
| putithere->typed_val_float.type, | |
| putithere->typed_val_float.val)) | |
| return ERROR; | |
| return FLOAT_LITERAL; | |
| } | |
| /* Handle base-switching prefixes 0x, 0b, 0 */ | |
| if (p[0] == '0') | |
| switch (p[1]) | |
| { | |
| case 'x': | |
| case 'X': | |
| if (len >= 3) | |
| { | |
| p += 2; | |
| base = 16; | |
| len -= 2; | |
| } | |
| break; | |
| case 'b': | |
| case 'B': | |
| if (len >= 3) | |
| { | |
| p += 2; | |
| base = 2; | |
| len -= 2; | |
| } | |
| break; | |
| default: | |
| base = 8; | |
| break; | |
| } | |
| while (len-- > 0) | |
| { | |
| c = *p++; | |
| if (c == '_') | |
| continue; /* Ignore embedded '_'. */ | |
| if (c >= 'A' && c <= 'Z') | |
| c += 'a' - 'A'; | |
| if (c != 'l' && c != 'u') | |
| n *= base; | |
| if (c >= '0' && c <= '9') | |
| { | |
| if (found_suffix) | |
| return ERROR; | |
| n += i = c - '0'; | |
| } | |
| else | |
| { | |
| if (base > 10 && c >= 'a' && c <= 'f') | |
| { | |
| if (found_suffix) | |
| return ERROR; | |
| n += i = c - 'a' + 10; | |
| } | |
| else if (c == 'l' && long_p == 0) | |
| { | |
| long_p = 1; | |
| found_suffix = 1; | |
| } | |
| else if (c == 'u' && unsigned_p == 0) | |
| { | |
| unsigned_p = 1; | |
| found_suffix = 1; | |
| } | |
| else | |
| return ERROR; /* Char not a digit */ | |
| } | |
| if (i >= base) | |
| return ERROR; /* Invalid digit in this base. */ | |
| /* Portably test for integer overflow. */ | |
| if (c != 'l' && c != 'u') | |
| { | |
| ULONGEST n2 = prevn * base; | |
| if ((n2 / base != prevn) || (n2 + i < prevn)) | |
| error (_("Numeric constant too large.")); | |
| } | |
| prevn = n; | |
| } | |
| /* An integer constant is an int or a long. An L suffix forces it to | |
| be long, and a U suffix forces it to be unsigned. To figure out | |
| whether it fits, we shift it right and see whether anything remains. | |
| Note that we can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or | |
| more in one operation, because many compilers will warn about such a | |
| shift (which always produces a zero result). To deal with the case | |
| where it is we just always shift the value more than once, with fewer | |
| bits each time. */ | |
| un = (ULONGEST) n >> 2; | |
| if (long_p == 0 && (un >> 30) == 0) | |
| { | |
| high_bit = ((ULONGEST) 1) << 31; | |
| signed_type = parse_d_type (ps)->builtin_int; | |
| /* For decimal notation, keep the sign of the worked out type. */ | |
| if (base == 10 && !unsigned_p) | |
| unsigned_type = parse_d_type (ps)->builtin_long; | |
| else | |
| unsigned_type = parse_d_type (ps)->builtin_uint; | |
| } | |
| else | |
| { | |
| int shift; | |
| if (sizeof (ULONGEST) * HOST_CHAR_BIT < 64) | |
| /* A long long does not fit in a LONGEST. */ | |
| shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1); | |
| else | |
| shift = 63; | |
| high_bit = (ULONGEST) 1 << shift; | |
| signed_type = parse_d_type (ps)->builtin_long; | |
| unsigned_type = parse_d_type (ps)->builtin_ulong; | |
| } | |
| putithere->typed_val_int.val = n; | |
| /* If the high bit of the worked out type is set then this number | |
| has to be unsigned_type. */ | |
| if (unsigned_p || (n & high_bit)) | |
| putithere->typed_val_int.type = unsigned_type; | |
| else | |
| putithere->typed_val_int.type = signed_type; | |
| return INTEGER_LITERAL; | |
| } | |
| /* Temporary obstack used for holding strings. */ | |
| static auto_obstack tempbuf; | |
| /* Parse a string or character literal from TOKPTR. The string or | |
| character may be wide or unicode. *OUTPTR is set to just after the | |
| end of the literal in the input string. The resulting token is | |
| stored in VALUE. This returns a token value, either STRING or | |
| CHAR, depending on what was parsed. *HOST_CHARS is set to the | |
| number of host characters in the literal. */ | |
| static int | |
| parse_string_or_char (const char *tokptr, const char **outptr, | |
| struct typed_stoken *value, int *host_chars) | |
| { | |
| int quote; | |
| /* Build the gdb internal form of the input string in tempbuf. Note | |
| that the buffer is null byte terminated *only* for the | |
| convenience of debugging gdb itself and printing the buffer | |
| contents when the buffer contains no embedded nulls. Gdb does | |
| not depend upon the buffer being null byte terminated, it uses | |
| the length string instead. This allows gdb to handle C strings | |
| (as well as strings in other languages) with embedded null | |
| bytes */ | |
| tempbuf.clear (); | |
| /* Skip the quote. */ | |
| quote = *tokptr; | |
| ++tokptr; | |
| *host_chars = 0; | |
| while (*tokptr) | |
| { | |
| char c = *tokptr; | |
| if (c == '\\') | |
| { | |
| ++tokptr; | |
| *host_chars += c_parse_escape (&tokptr, &tempbuf); | |
| } | |
| else if (c == quote) | |
| break; | |
| else | |
| { | |
| obstack_1grow (&tempbuf, c); | |
| ++tokptr; | |
| /* FIXME: this does the wrong thing with multi-byte host | |
| characters. We could use mbrlen here, but that would | |
| make "set host-charset" a bit less useful. */ | |
| ++*host_chars; | |
| } | |
| } | |
| if (*tokptr != quote) | |
| { | |
| if (quote == '"' || quote == '`') | |
| error (_("Unterminated string in expression.")); | |
| else | |
| error (_("Unmatched single quote.")); | |
| } | |
| ++tokptr; | |
| /* FIXME: should instead use own language string_type enum | |
| and handle D-specific string suffixes here. */ | |
| if (quote == '\'') | |
| value->type = C_CHAR; | |
| else | |
| value->type = C_STRING; | |
| value->ptr = (char *) obstack_base (&tempbuf); | |
| value->length = obstack_object_size (&tempbuf); | |
| *outptr = tokptr; | |
| return quote == '\'' ? CHARACTER_LITERAL : STRING_LITERAL; | |
| } | |
| struct d_token | |
| { | |
| const char *oper; | |
| int token; | |
| enum exp_opcode opcode; | |
| }; | |
| static const struct d_token tokentab3[] = | |
| { | |
| {"^^=", ASSIGN_MODIFY, BINOP_EXP}, | |
| {"<<=", ASSIGN_MODIFY, BINOP_LSH}, | |
| {">>=", ASSIGN_MODIFY, BINOP_RSH}, | |
| }; | |
| static const struct d_token tokentab2[] = | |
| { | |
| {"+=", ASSIGN_MODIFY, BINOP_ADD}, | |
| {"-=", ASSIGN_MODIFY, BINOP_SUB}, | |
| {"*=", ASSIGN_MODIFY, BINOP_MUL}, | |
| {"/=", ASSIGN_MODIFY, BINOP_DIV}, | |
| {"%=", ASSIGN_MODIFY, BINOP_REM}, | |
| {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR}, | |
| {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND}, | |
| {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR}, | |
| {"++", INCREMENT, OP_NULL}, | |
| {"--", DECREMENT, OP_NULL}, | |
| {"&&", ANDAND, OP_NULL}, | |
| {"||", OROR, OP_NULL}, | |
| {"^^", HATHAT, OP_NULL}, | |
| {"<<", LSH, OP_NULL}, | |
| {">>", RSH, OP_NULL}, | |
| {"==", EQUAL, OP_NULL}, | |
| {"!=", NOTEQUAL, OP_NULL}, | |
| {"<=", LEQ, OP_NULL}, | |
| {">=", GEQ, OP_NULL}, | |
| {"..", DOTDOT, OP_NULL}, | |
| }; | |
| /* Identifier-like tokens. */ | |
| static const struct d_token ident_tokens[] = | |
| { | |
| {"is", IDENTITY, OP_NULL}, | |
| {"!is", NOTIDENTITY, OP_NULL}, | |
| {"cast", CAST_KEYWORD, OP_NULL}, | |
| {"const", CONST_KEYWORD, OP_NULL}, | |
| {"immutable", IMMUTABLE_KEYWORD, OP_NULL}, | |
| {"shared", SHARED_KEYWORD, OP_NULL}, | |
| {"super", SUPER_KEYWORD, OP_NULL}, | |
| {"null", NULL_KEYWORD, OP_NULL}, | |
| {"true", TRUE_KEYWORD, OP_NULL}, | |
| {"false", FALSE_KEYWORD, OP_NULL}, | |
| {"init", INIT_KEYWORD, OP_NULL}, | |
| {"sizeof", SIZEOF_KEYWORD, OP_NULL}, | |
| {"typeof", TYPEOF_KEYWORD, OP_NULL}, | |
| {"typeid", TYPEID_KEYWORD, OP_NULL}, | |
| {"delegate", DELEGATE_KEYWORD, OP_NULL}, | |
| {"function", FUNCTION_KEYWORD, OP_NULL}, | |
| {"struct", STRUCT_KEYWORD, OP_NULL}, | |
| {"union", UNION_KEYWORD, OP_NULL}, | |
| {"class", CLASS_KEYWORD, OP_NULL}, | |
| {"interface", INTERFACE_KEYWORD, OP_NULL}, | |
| {"enum", ENUM_KEYWORD, OP_NULL}, | |
| {"template", TEMPLATE_KEYWORD, OP_NULL}, | |
| }; | |
| /* This is set if a NAME token appeared at the very end of the input | |
| string, with no whitespace separating the name from the EOF. This | |
| is used only when parsing to do field name completion. */ | |
| static int saw_name_at_eof; | |
| /* This is set if the previously-returned token was a structure operator. | |
| This is used only when parsing to do field name completion. */ | |
| static int last_was_structop; | |
| /* Depth of parentheses. */ | |
| static int paren_depth; | |
| /* Read one token, getting characters through lexptr. */ | |
| static int | |
| lex_one_token (struct parser_state *par_state) | |
| { | |
| int c; | |
| int namelen; | |
| const char *tokstart; | |
| int saw_structop = last_was_structop; | |
| last_was_structop = 0; | |
| retry: | |
| pstate->prev_lexptr = pstate->lexptr; | |
| tokstart = pstate->lexptr; | |
| /* See if it is a special token of length 3. */ | |
| for (const auto &token : tokentab3) | |
| if (strncmp (tokstart, token.oper, 3) == 0) | |
| { | |
| pstate->lexptr += 3; | |
| d_yylval.opcode = token.opcode; | |
| return token.token; | |
| } | |
| /* See if it is a special token of length 2. */ | |
| for (const auto &token : tokentab2) | |
| if (strncmp (tokstart, token.oper, 2) == 0) | |
| { | |
| pstate->lexptr += 2; | |
| d_yylval.opcode = token.opcode; | |
| return token.token; | |
| } | |
| switch (c = *tokstart) | |
| { | |
| case 0: | |
| /* If we're parsing for field name completion, and the previous | |
| token allows such completion, return a COMPLETE token. | |
| Otherwise, we were already scanning the original text, and | |
| we're really done. */ | |
| if (saw_name_at_eof) | |
| { | |
| saw_name_at_eof = 0; | |
| return COMPLETE; | |
| } | |
| else if (saw_structop) | |
| return COMPLETE; | |
| else | |
| return 0; | |
| case ' ': | |
| case '\t': | |
| case '\n': | |
| pstate->lexptr++; | |
| goto retry; | |
| case '[': | |
| case '(': | |
| paren_depth++; | |
| pstate->lexptr++; | |
| return c; | |
| case ']': | |
| case ')': | |
| if (paren_depth == 0) | |
| return 0; | |
| paren_depth--; | |
| pstate->lexptr++; | |
| return c; | |
| case ',': | |
| if (pstate->comma_terminates && paren_depth == 0) | |
| return 0; | |
| pstate->lexptr++; | |
| return c; | |
| case '.': | |
| /* Might be a floating point number. */ | |
| if (pstate->lexptr[1] < '0' || pstate->lexptr[1] > '9') | |
| { | |
| if (pstate->parse_completion) | |
| last_was_structop = 1; | |
| goto symbol; /* Nope, must be a symbol. */ | |
| } | |
| [[fallthrough]]; | |
| case '0': | |
| case '1': | |
| case '2': | |
| case '3': | |
| case '4': | |
| case '5': | |
| case '6': | |
| case '7': | |
| case '8': | |
| case '9': | |
| { | |
| /* It's a number. */ | |
| int got_dot = 0, got_e = 0, toktype; | |
| const char *p = tokstart; | |
| int hex = input_radix > 10; | |
| if (c == '0' && (p[1] == 'x' || p[1] == 'X')) | |
| { | |
| p += 2; | |
| hex = 1; | |
| } | |
| for (;; ++p) | |
| { | |
| /* Hex exponents start with 'p', because 'e' is a valid hex | |
| digit and thus does not indicate a floating point number | |
| when the radix is hex. */ | |
| if ((!hex && !got_e && c_tolower (p[0]) == 'e') | |
| || (hex && !got_e && c_tolower (p[0] == 'p'))) | |
| got_dot = got_e = 1; | |
| /* A '.' always indicates a decimal floating point number | |
| regardless of the radix. If we have a '..' then its the | |
| end of the number and the beginning of a slice. */ | |
| else if (!got_dot && (p[0] == '.' && p[1] != '.')) | |
| got_dot = 1; | |
| /* This is the sign of the exponent, not the end of the number. */ | |
| else if (got_e && (c_tolower (p[-1]) == 'e' | |
| || c_tolower (p[-1]) == 'p') | |
| && (*p == '-' || *p == '+')) | |
| continue; | |
| /* We will take any letters or digits, ignoring any embedded '_'. | |
| parse_number will complain if past the radix, or if L or U are | |
| not final. */ | |
| else if ((*p < '0' || *p > '9') && (*p != '_') | |
| && ((*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z'))) | |
| break; | |
| } | |
| toktype = parse_number (par_state, tokstart, p - tokstart, | |
| got_dot|got_e, &d_yylval); | |
| if (toktype == ERROR) | |
| error (_("Invalid number \"%.*s\"."), (int) (p - tokstart), | |
| tokstart); | |
| pstate->lexptr = p; | |
| return toktype; | |
| } | |
| case '@': | |
| { | |
| const char *p = &tokstart[1]; | |
| size_t len = strlen ("entry"); | |
| while (c_isspace (*p)) | |
| p++; | |
| if (strncmp (p, "entry", len) == 0 && !c_isalnum (p[len]) | |
| && p[len] != '_') | |
| { | |
| pstate->lexptr = &p[len]; | |
| return ENTRY; | |
| } | |
| } | |
| [[fallthrough]]; | |
| case '+': | |
| case '-': | |
| case '*': | |
| case '/': | |
| case '%': | |
| case '|': | |
| case '&': | |
| case '^': | |
| case '~': | |
| case '!': | |
| case '<': | |
| case '>': | |
| case '?': | |
| case ':': | |
| case '=': | |
| case '{': | |
| case '}': | |
| symbol: | |
| pstate->lexptr++; | |
| return c; | |
| case '\'': | |
| case '"': | |
| case '`': | |
| { | |
| int host_len; | |
| int result = parse_string_or_char (tokstart, &pstate->lexptr, | |
| &d_yylval.tsval, &host_len); | |
| if (result == CHARACTER_LITERAL) | |
| { | |
| if (host_len == 0) | |
| error (_("Empty character constant.")); | |
| else if (host_len > 2 && c == '\'') | |
| { | |
| ++tokstart; | |
| namelen = pstate->lexptr - tokstart - 1; | |
| goto tryname; | |
| } | |
| else if (host_len > 1) | |
| error (_("Invalid character constant.")); | |
| } | |
| return result; | |
| } | |
| } | |
| if (!(c == '_' || c == '$' | |
| || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) | |
| /* We must have come across a bad character (e.g. ';'). */ | |
| error (_("Invalid character '%c' in expression"), c); | |
| /* It's a name. See how long it is. */ | |
| namelen = 0; | |
| for (c = tokstart[namelen]; | |
| (c == '_' || c == '$' || (c >= '0' && c <= '9') | |
| || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));) | |
| c = tokstart[++namelen]; | |
| /* The token "if" terminates the expression and is NOT | |
| removed from the input stream. */ | |
| if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f') | |
| return 0; | |
| /* For the same reason (breakpoint conditions), "thread N" | |
| terminates the expression. "thread" could be an identifier, but | |
| an identifier is never followed by a number without intervening | |
| punctuation. "task" is similar. Handle abbreviations of these, | |
| similarly to breakpoint.c:find_condition_and_thread. */ | |
| if (namelen >= 1 | |
| && (strncmp (tokstart, "thread", namelen) == 0 | |
| || strncmp (tokstart, "task", namelen) == 0) | |
| && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t')) | |
| { | |
| const char *p = skip_spaces (tokstart + namelen + 1); | |
| if (*p >= '0' && *p <= '9') | |
| return 0; | |
| } | |
| pstate->lexptr += namelen; | |
| tryname: | |
| d_yylval.sval.ptr = tokstart; | |
| d_yylval.sval.length = namelen; | |
| /* Catch specific keywords. */ | |
| std::string copy = copy_name (d_yylval.sval); | |
| for (const auto &token : ident_tokens) | |
| if (copy == token.oper) | |
| { | |
| /* It is ok to always set this, even though we don't always | |
| strictly need to. */ | |
| d_yylval.opcode = token.opcode; | |
| return token.token; | |
| } | |
| if (*tokstart == '$') | |
| return DOLLAR_VARIABLE; | |
| d_yylval.tsym.type | |
| = language_lookup_primitive_type (par_state->language (), | |
| par_state->gdbarch (), copy.c_str ()); | |
| if (d_yylval.tsym.type != NULL) | |
| return TYPENAME; | |
| /* Input names that aren't symbols but ARE valid hex numbers, | |
| when the input radix permits them, can be names or numbers | |
| depending on the parse. Note we support radixes > 16 here. */ | |
| if ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) | |
| || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)) | |
| { | |
| d_exp_parser_YYSTYPE newlval; /* Its value is ignored. */ | |
| int hextype = parse_number (par_state, tokstart, namelen, 0, &newlval); | |
| if (hextype == INTEGER_LITERAL) | |
| return NAME_OR_INT; | |
| } | |
| if (pstate->parse_completion && *pstate->lexptr == '\0') | |
| saw_name_at_eof = 1; | |
| return IDENTIFIER; | |
| } | |
| /* An object of this type is pushed on a FIFO by the "outer" lexer. */ | |
| struct d_token_and_value | |
| { | |
| int token; | |
| d_exp_parser_YYSTYPE value; | |
| }; | |
| /* A FIFO of tokens that have been read but not yet returned to the | |
| parser. */ | |
| static std::vector<d_token_and_value> token_fifo; | |
| /* Non-zero if the lexer should return tokens from the FIFO. */ | |
| static int popping; | |
| /* Temporary storage for yylex; this holds symbol names as they are | |
| built up. */ | |
| static auto_obstack name_obstack; | |
| /* Classify an IDENTIFIER token. The contents of the token are in `yylval'. | |
| Updates yylval and returns the new token type. BLOCK is the block | |
| in which lookups start; this can be NULL to mean the global scope. */ | |
| static int | |
| classify_name (struct parser_state *par_state, const struct block *block) | |
| { | |
| struct block_symbol sym; | |
| struct field_of_this_result is_a_field_of_this; | |
| std::string copy = copy_name (d_yylval.sval); | |
| sym = lookup_symbol (copy.c_str (), block, SEARCH_VFT, &is_a_field_of_this); | |
| if (sym.symbol && sym.symbol->loc_class () == LOC_TYPEDEF) | |
| { | |
| d_yylval.tsym.type = sym.symbol->type (); | |
| return TYPENAME; | |
| } | |
| else if (sym.symbol == NULL) | |
| { | |
| /* Look-up first for a module name, then a type. */ | |
| sym = lookup_symbol (copy.c_str (), block, SEARCH_MODULE_DOMAIN, | |
| nullptr); | |
| if (sym.symbol == NULL) | |
| sym = lookup_symbol (copy.c_str (), block, SEARCH_STRUCT_DOMAIN, | |
| nullptr); | |
| if (sym.symbol != NULL) | |
| { | |
| d_yylval.tsym.type = sym.symbol->type (); | |
| return TYPENAME; | |
| } | |
| return UNKNOWN_NAME; | |
| } | |
| return IDENTIFIER; | |
| } | |
| /* Like classify_name, but used by the inner loop of the lexer, when a | |
| name might have already been seen. CONTEXT is the context type, or | |
| NULL if this is the first component of a name. */ | |
| static int | |
| classify_inner_name (struct parser_state *par_state, | |
| const struct block *block, struct type *context) | |
| { | |
| struct type *type; | |
| if (context == NULL) | |
| return classify_name (par_state, block); | |
| type = check_typedef (context); | |
| if (!type_aggregate_p (type)) | |
| return ERROR; | |
| std::string copy = copy_name (d_yylval.ssym.stoken); | |
| d_yylval.ssym.sym = d_lookup_nested_symbol (type, copy.c_str (), block); | |
| if (d_yylval.ssym.sym.symbol == NULL) | |
| return ERROR; | |
| if (d_yylval.ssym.sym.symbol->loc_class () == LOC_TYPEDEF) | |
| { | |
| d_yylval.tsym.type = d_yylval.ssym.sym.symbol->type (); | |
| return TYPENAME; | |
| } | |
| return IDENTIFIER; | |
| } | |
| /* See d-exp-parser.h. */ | |
| int | |
| d_yylex (void) | |
| { | |
| d_token_and_value current; | |
| int last_was_dot; | |
| struct type *context_type = NULL; | |
| int last_to_examine, next_to_examine, checkpoint; | |
| const struct block *search_block; | |
| if (popping && !token_fifo.empty ()) | |
| goto do_pop; | |
| popping = 0; | |
| /* Read the first token and decide what to do. */ | |
| current.token = lex_one_token (pstate); | |
| if (current.token != IDENTIFIER && current.token != '.') | |
| return current.token; | |
| /* Read any sequence of alternating "." and identifier tokens into | |
| the token FIFO. */ | |
| current.value = d_yylval; | |
| token_fifo.push_back (current); | |
| last_was_dot = current.token == '.'; | |
| while (1) | |
| { | |
| current.token = lex_one_token (pstate); | |
| current.value = d_yylval; | |
| token_fifo.push_back (current); | |
| if ((last_was_dot && current.token != IDENTIFIER) | |
| || (!last_was_dot && current.token != '.')) | |
| break; | |
| last_was_dot = !last_was_dot; | |
| } | |
| popping = 1; | |
| /* We always read one extra token, so compute the number of tokens | |
| to examine accordingly. */ | |
| last_to_examine = token_fifo.size () - 2; | |
| next_to_examine = 0; | |
| current = token_fifo[next_to_examine]; | |
| ++next_to_examine; | |
| /* If we are not dealing with a typename, now is the time to find out. */ | |
| if (current.token == IDENTIFIER) | |
| { | |
| d_yylval = current.value; | |
| current.token = classify_name (pstate, pstate->expression_context_block); | |
| current.value = d_yylval; | |
| } | |
| /* If the IDENTIFIER is not known, it could be a package symbol, | |
| first try building up a name until we find the qualified module. */ | |
| if (current.token == UNKNOWN_NAME) | |
| { | |
| name_obstack.clear (); | |
| obstack_grow (&name_obstack, current.value.sval.ptr, | |
| current.value.sval.length); | |
| last_was_dot = 0; | |
| while (next_to_examine <= last_to_examine) | |
| { | |
| d_token_and_value next; | |
| next = token_fifo[next_to_examine]; | |
| ++next_to_examine; | |
| if (next.token == IDENTIFIER && last_was_dot) | |
| { | |
| /* Update the partial name we are constructing. */ | |
| obstack_grow_str (&name_obstack, "."); | |
| obstack_grow (&name_obstack, next.value.sval.ptr, | |
| next.value.sval.length); | |
| d_yylval.sval.ptr = (char *) obstack_base (&name_obstack); | |
| d_yylval.sval.length = obstack_object_size (&name_obstack); | |
| current.token = classify_name (pstate, | |
| pstate->expression_context_block); | |
| current.value = d_yylval; | |
| /* We keep going until we find a TYPENAME. */ | |
| if (current.token == TYPENAME) | |
| { | |
| /* Install it as the first token in the FIFO. */ | |
| token_fifo[0] = current; | |
| token_fifo.erase (token_fifo.begin () + 1, | |
| token_fifo.begin () + next_to_examine); | |
| break; | |
| } | |
| } | |
| else if (next.token == '.' && !last_was_dot) | |
| last_was_dot = 1; | |
| else | |
| { | |
| /* We've reached the end of the name. */ | |
| break; | |
| } | |
| } | |
| /* Reset our current token back to the start, if we found nothing | |
| this means that we will just jump to do pop. */ | |
| current = token_fifo[0]; | |
| next_to_examine = 1; | |
| } | |
| if (current.token != TYPENAME && current.token != '.') | |
| goto do_pop; | |
| name_obstack.clear (); | |
| checkpoint = 0; | |
| if (current.token == '.') | |
| search_block = NULL; | |
| else | |
| { | |
| gdb_assert (current.token == TYPENAME); | |
| search_block = pstate->expression_context_block; | |
| obstack_grow (&name_obstack, current.value.sval.ptr, | |
| current.value.sval.length); | |
| context_type = current.value.tsym.type; | |
| checkpoint = 1; | |
| } | |
| last_was_dot = current.token == '.'; | |
| while (next_to_examine <= last_to_examine) | |
| { | |
| d_token_and_value next; | |
| next = token_fifo[next_to_examine]; | |
| ++next_to_examine; | |
| if (next.token == IDENTIFIER && last_was_dot) | |
| { | |
| int classification; | |
| d_yylval = next.value; | |
| classification = classify_inner_name (pstate, search_block, | |
| context_type); | |
| /* We keep going until we either run out of names, or until | |
| we have a qualified name which is not a type. */ | |
| if (classification != TYPENAME && classification != IDENTIFIER) | |
| break; | |
| /* Accept up to this token. */ | |
| checkpoint = next_to_examine; | |
| /* Update the partial name we are constructing. */ | |
| if (context_type != NULL) | |
| { | |
| /* We don't want to put a leading "." into the name. */ | |
| obstack_grow_str (&name_obstack, "."); | |
| } | |
| obstack_grow (&name_obstack, next.value.sval.ptr, | |
| next.value.sval.length); | |
| d_yylval.sval.ptr = (char *) obstack_base (&name_obstack); | |
| d_yylval.sval.length = obstack_object_size (&name_obstack); | |
| current.value = d_yylval; | |
| current.token = classification; | |
| last_was_dot = 0; | |
| if (classification == IDENTIFIER) | |
| break; | |
| context_type = d_yylval.tsym.type; | |
| } | |
| else if (next.token == '.' && !last_was_dot) | |
| last_was_dot = 1; | |
| else | |
| { | |
| /* We've reached the end of the name. */ | |
| break; | |
| } | |
| } | |
| /* If we have a replacement token, install it as the first token in | |
| the FIFO, and delete the other constituent tokens. */ | |
| if (checkpoint > 0) | |
| { | |
| token_fifo[0] = current; | |
| if (checkpoint > 1) | |
| token_fifo.erase (token_fifo.begin () + 1, | |
| token_fifo.begin () + checkpoint); | |
| } | |
| do_pop: | |
| current = token_fifo[0]; | |
| token_fifo.erase (token_fifo.begin ()); | |
| d_yylval = current.value; | |
| return current.token; | |
| } | |
| /* See d-exp-parser.h. */ | |
| void | |
| d_yyerror (const char *msg) | |
| { | |
| pstate->parse_error (msg); | |
| } | |
| } /* namespace d_exp_parser */ | |
| /* See d-exp-parser.h. */ | |
| int | |
| d_parse (struct parser_state *par_state) | |
| { | |
| using namespace d_exp_parser; | |
| /* Setting up the parser state. */ | |
| scoped_restore pstate_restore = make_scoped_restore (&pstate); | |
| gdb_assert (par_state != NULL); | |
| pstate = par_state; | |
| scoped_restore restore_yydebug = make_scoped_restore (&d_yydebug, | |
| par_state->debug); | |
| struct type_stack stack; | |
| scoped_restore restore_type_stack | |
| = make_scoped_restore (&d_exp_parser::type_stack, &stack); | |
| /* Initialize some state used by the lexer. */ | |
| last_was_structop = 0; | |
| saw_name_at_eof = 0; | |
| paren_depth = 0; | |
| token_fifo.clear (); | |
| popping = 0; | |
| name_obstack.clear (); | |
| int result = d_yyparse (); | |
| if (!result) | |
| pstate->set_operation (pstate->pop ()); | |
| return result; | |
| } |