/* YACC parser for Go expressions, for GDB.
- Copyright (C) 2012-2018 Free Software Foundation, Inc.
+ Copyright (C) 2012-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "charset.h"
#include "block.h"
-#define parse_type(ps) builtin_type (parse_gdbarch (ps))
+#define parse_type(ps) builtin_type (ps->gdbarch ())
/* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
etc). */
static int yylex (void);
-void yyerror (const char *);
+static void yyerror (const char *);
%}
expression_context_block); }
*/
| BYTE_KEYWORD
- { $$ = builtin_go_type (parse_gdbarch (pstate))
+ { $$ = builtin_go_type (pstate->gdbarch ())
->builtin_uint8; }
;
if (parsed_float)
{
const struct builtin_go_type *builtin_go_types
- = builtin_go_type (parse_gdbarch (par_state));
+ = builtin_go_type (par_state->gdbarch ());
/* Handle suffixes: 'f' for float32, 'l' for long double.
FIXME: This appears to be an extension -- do we want this? */
un = (ULONGEST)n >> 2;
if (long_p == 0
- && (un >> (gdbarch_int_bit (parse_gdbarch (par_state)) - 2)) == 0)
+ && (un >> (gdbarch_int_bit (par_state->gdbarch ()) - 2)) == 0)
{
high_bit
- = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch (par_state)) - 1);
+ = ((ULONGEST)1) << (gdbarch_int_bit (par_state->gdbarch ()) - 1);
/* A large decimal (not hex or octal) constant (between INT_MAX
and UINT_MAX) is a long or unsigned long, according to ANSI,
signed_type = parse_type (par_state)->builtin_int;
}
else if (long_p <= 1
- && (un >> (gdbarch_long_bit (parse_gdbarch (par_state)) - 2)) == 0)
+ && (un >> (gdbarch_long_bit (par_state->gdbarch ()) - 2)) == 0)
{
high_bit
- = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch (par_state)) - 1);
+ = ((ULONGEST)1) << (gdbarch_long_bit (par_state->gdbarch ()) - 1);
unsigned_type = parse_type (par_state)->builtin_unsigned_long;
signed_type = parse_type (par_state)->builtin_long;
}
{
int shift;
if (sizeof (ULONGEST) * HOST_CHAR_BIT
- < gdbarch_long_long_bit (parse_gdbarch (par_state)))
+ < gdbarch_long_long_bit (par_state->gdbarch ()))
/* A long long does not fit in a LONGEST. */
shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
else
- shift = (gdbarch_long_long_bit (parse_gdbarch (par_state)) - 1);
+ shift = (gdbarch_long_long_bit (par_state->gdbarch ()) - 1);
high_bit = (ULONGEST) 1 << shift;
unsigned_type = parse_type (par_state)->builtin_unsigned_long_long;
signed_type = parse_type (par_state)->builtin_long_long;
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
retry:
- prev_lexptr = lexptr;
+ par_state->prev_lexptr = par_state->lexptr;
- tokstart = lexptr;
+ tokstart = par_state->lexptr;
/* See if it is a special token of length 3. */
for (i = 0; i < sizeof (tokentab3) / sizeof (tokentab3[0]); i++)
if (strncmp (tokstart, tokentab3[i].oper, 3) == 0)
{
- lexptr += 3;
+ par_state->lexptr += 3;
yylval.opcode = tokentab3[i].opcode;
return tokentab3[i].token;
}
for (i = 0; i < sizeof (tokentab2) / sizeof (tokentab2[0]); i++)
if (strncmp (tokstart, tokentab2[i].oper, 2) == 0)
{
- lexptr += 2;
+ par_state->lexptr += 2;
yylval.opcode = tokentab2[i].opcode;
/* NOTE: -> doesn't exist in Go, so we don't need to watch for
setting last_was_structop here. */
case ' ':
case '\t':
case '\n':
- lexptr++;
+ par_state->lexptr++;
goto retry;
case '[':
case '(':
paren_depth++;
- lexptr++;
+ par_state->lexptr++;
return c;
case ']':
if (paren_depth == 0)
return 0;
paren_depth--;
- lexptr++;
+ par_state->lexptr++;
return c;
case ',':
- if (comma_terminates
+ if (pstate->comma_terminates
&& paren_depth == 0)
return 0;
- lexptr++;
+ par_state->lexptr++;
return c;
case '.':
/* Might be a floating point number. */
- if (lexptr[1] < '0' || lexptr[1] > '9')
+ if (par_state->lexptr[1] < '0' || par_state->lexptr[1] > '9')
{
if (parse_completion)
last_was_structop = 1;
goto symbol; /* Nope, must be a symbol. */
}
- /* FALL THRU into number case. */
+ /* FALL THRU. */
case '0':
case '1':
err_copy[p - tokstart] = 0;
error (_("Invalid number \"%s\"."), err_copy);
}
- lexptr = p;
+ par_state->lexptr = p;
return toktype;
}
if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
&& p[len] != '_')
{
- lexptr = &p[len];
+ par_state->lexptr = &p[len];
return ENTRY;
}
}
case '{':
case '}':
symbol:
- lexptr++;
+ par_state->lexptr++;
return c;
case '\'':
case '`':
{
int host_len;
- int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
- &host_len);
+ int result = parse_string_or_char (tokstart, &par_state->lexptr,
+ &yylval.tsval, &host_len);
if (result == CHAR)
{
if (host_len == 0)
else if (host_len > 2 && c == '\'')
{
++tokstart;
- namelen = lexptr - tokstart - 1;
+ namelen = par_state->lexptr - tokstart - 1;
goto tryname;
}
else if (host_len > 1)
return 0;
}
- lexptr += namelen;
+ par_state->lexptr += namelen;
tryname:
if (*tokstart == '$')
return DOLLAR_VARIABLE;
- if (parse_completion && *lexptr == '\0')
+ if (parse_completion && *par_state->lexptr == '\0')
saw_name_at_eof = 1;
return NAME;
}
/* An object of this type is pushed on a FIFO by the "outer" lexer. */
-typedef struct
+struct token_and_value
{
int token;
YYSTYPE value;
-} token_and_value;
-
-DEF_VEC_O (token_and_value);
+};
/* A FIFO of tokens that have been read but not yet returned to the
parser. */
-static VEC (token_and_value) *token_fifo;
+static std::vector<token_and_value> token_fifo;
/* Non-zero if the lexer should return tokens from the FIFO. */
static int popping;
copy = copy_name (yylval.sval);
/* Try primitive types first so they win over bad/weird debug info. */
- type = language_lookup_primitive_type (parse_language (par_state),
- parse_gdbarch (par_state),
+ type = language_lookup_primitive_type (par_state->language (),
+ par_state->gdbarch (),
copy);
if (type != NULL)
{
{
token_and_value current, next;
- if (popping && !VEC_empty (token_and_value, token_fifo))
+ if (popping && !token_fifo.empty ())
{
- token_and_value tv = *VEC_index (token_and_value, token_fifo, 0);
- VEC_ordered_remove (token_and_value, token_fifo, 0);
+ token_and_value tv = token_fifo[0];
+ token_fifo.erase (token_fifo.begin ());
yylval = tv.value;
/* There's no need to fall through to handle package.name
as that can never happen here. In theory. */
return classify_unsafe_function (name2.value.sval);
}
- if (package_name_p (copy, expression_context_block))
+ if (package_name_p (copy, pstate->expression_context_block))
{
popping = 1;
yylval.sval = build_packaged_name (current.value.sval.ptr,
current.value.sval.length,
name2.value.sval.ptr,
name2.value.sval.length);
- return classify_packaged_name (expression_context_block);
+ return classify_packaged_name (pstate->expression_context_block);
}
}
- VEC_safe_push (token_and_value, token_fifo, &next);
- VEC_safe_push (token_and_value, token_fifo, &name2);
+ token_fifo.push_back (next);
+ token_fifo.push_back (name2);
}
else
- {
- VEC_safe_push (token_and_value, token_fifo, &next);
- }
+ token_fifo.push_back (next);
/* If we arrive here we don't have a package-qualified name. */
popping = 1;
yylval = current.value;
- return classify_name (pstate, expression_context_block);
+ return classify_name (pstate, pstate->expression_context_block);
}
int
/* Initialize some state used by the lexer. */
last_was_structop = 0;
saw_name_at_eof = 0;
+ paren_depth = 0;
- VEC_free (token_and_value, token_fifo);
+ token_fifo.clear ();
popping = 0;
name_obstack.clear ();
return yyparse ();
}
-void
+static void
yyerror (const char *msg)
{
- if (prev_lexptr)
- lexptr = prev_lexptr;
+ if (pstate->prev_lexptr)
+ pstate->lexptr = pstate->prev_lexptr;
- error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);
+ error (_("A %s in expression, near `%s'."), msg, pstate->lexptr);
}