/* YACC parser for Pascal expressions, for GDB.
- Copyright (C) 2000, 2006, 2007, 2008, 2009, 2010, 2011
- Free Software Foundation, Inc.
+ Copyright (C) 2000-2014 Free Software Foundation, Inc.
This file is part of GDB.
%{
#include "defs.h"
-#include "gdb_string.h"
+#include <string.h>
#include <ctype.h>
#include "expression.h"
#include "value.h"
#include "symfile.h" /* Required by objfiles.h. */
#include "objfiles.h" /* For have_full_symbols and have_partial_symbols. */
#include "block.h"
+#include "completer.h"
#define parse_type builtin_type (parse_gdbarch)
#define yylval pascal_lval
#define yychar pascal_char
#define yydebug pascal_debug
-#define yypact pascal_pact
-#define yyr1 pascal_r1
-#define yyr2 pascal_r2
-#define yydef pascal_def
-#define yychk pascal_chk
-#define yypgo pascal_pgo
+#define yypact pascal_pact
+#define yyr1 pascal_r1
+#define yyr2 pascal_r2
+#define yydef pascal_def
+#define yychk pascal_chk
+#define yypgo pascal_pgo
#define yyact pascal_act
#define yyexca pascal_exca
#define yyerrflag pascal_errflag
#define yygindex pascal_yygindex
#define yytable pascal_yytable
#define yycheck pascal_yycheck
+#define yyss pascal_yyss
+#define yysslim pascal_yysslim
+#define yyssp pascal_yyssp
+#define yystacksize pascal_yystacksize
+#define yyvs pascal_yyvs
+#define yyvsp pascal_yyvsp
#ifndef YYDEBUG
#define YYDEBUG 1 /* Default to yydebug support */
static int yylex (void);
-void
-yyerror (char *);
+void yyerror (char *);
-static char * uptok (char *, int);
+static char *uptok (const char *, int);
%}
/* Although the yacc "value" of an expression is not used,
%{
/* YYSTYPE gets defined by %union */
-static int
-parse_number (char *, int, int, YYSTYPE *);
+static int parse_number (const char *, int, int, YYSTYPE *);
static struct type *current_type;
static struct internalvar *intvar;
Contexts where this distinction is not important can use the
nonterminal "name", which matches either NAME or TYPENAME. */
-%token <sval> STRING
+%token <sval> STRING
%token <sval> FIELDNAME
%token <voidval> COMPLETE
%token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
/* Expressions, not including the comma operator. */
exp : exp '^' %prec UNARY
{ write_exp_elt_opcode (UNOP_IND);
- if (current_type)
+ if (current_type)
current_type = TYPE_TARGET_TYPE (current_type); }
;
exp : '@' exp %prec UNARY
- { write_exp_elt_opcode (UNOP_ADDR);
+ { write_exp_elt_opcode (UNOP_ADDR);
if (current_type)
current_type = TYPE_POINTER_TYPE (current_type); }
;
field_exp : exp '.' %prec UNARY
- { search_field = 1; }
+ { search_field = 1; }
;
-exp : field_exp FIELDNAME
+exp : field_exp FIELDNAME
{ write_exp_elt_opcode (STRUCTOP_STRUCT);
- write_exp_string ($2);
+ write_exp_string ($2);
write_exp_elt_opcode (STRUCTOP_STRUCT);
- search_field = 0;
+ search_field = 0;
if (current_type)
- {
+ {
while (TYPE_CODE (current_type)
== TYPE_CODE_PTR)
current_type =
current_type, $2.ptr, 0);
}
}
- ;
+ ;
+
exp : field_exp name
- { mark_struct_expression ();
- write_exp_elt_opcode (STRUCTOP_STRUCT);
+ { write_exp_elt_opcode (STRUCTOP_STRUCT);
write_exp_string ($2);
write_exp_elt_opcode (STRUCTOP_STRUCT);
- search_field = 0;
+ search_field = 0;
if (current_type)
- {
+ {
while (TYPE_CODE (current_type)
== TYPE_CODE_PTR)
current_type =
}
}
;
-
+exp : field_exp name COMPLETE
+ { mark_struct_expression ();
+ write_exp_elt_opcode (STRUCTOP_STRUCT);
+ write_exp_string ($2);
+ write_exp_elt_opcode (STRUCTOP_STRUCT); }
+ ;
exp : field_exp COMPLETE
{ struct stoken s;
mark_struct_expression ();
exp : exp '['
/* We need to save the current_type value. */
- { char *arrayname;
+ { const char *arrayname;
int arrayfieldindex;
arrayfieldindex = is_pascal_string_type (
current_type, NULL, NULL,
- NULL, NULL, &arrayname);
- if (arrayfieldindex)
+ NULL, NULL, &arrayname);
+ if (arrayfieldindex)
{
struct stoken stringsval;
- stringsval.ptr = alloca (strlen (arrayname) + 1);
+ char *buf;
+
+ buf = alloca (strlen (arrayname) + 1);
+ stringsval.ptr = buf;
stringsval.length = strlen (arrayname);
- strcpy (stringsval.ptr, arrayname);
+ strcpy (buf, arrayname);
current_type = TYPE_FIELD_TYPE (current_type,
- arrayfieldindex - 1);
+ arrayfieldindex - 1);
write_exp_elt_opcode (STRUCTOP_STRUCT);
- write_exp_string (stringsval);
+ write_exp_string (stringsval);
write_exp_elt_opcode (STRUCTOP_STRUCT);
}
push_current_type (); }
arglist ')' %prec ARROW
{ write_exp_elt_opcode (OP_FUNCALL);
write_exp_elt_longcst ((LONGEST) end_arglist ());
- write_exp_elt_opcode (OP_FUNCALL);
+ write_exp_elt_opcode (OP_FUNCALL);
pop_current_type ();
if (current_type)
current_type = TYPE_TARGET_TYPE (current_type);
}
write_exp_elt_opcode (UNOP_CAST);
write_exp_elt_type ($1);
- write_exp_elt_opcode (UNOP_CAST);
+ write_exp_elt_opcode (UNOP_CAST);
current_type = $1; }
;
exp : exp '/' {
if (current_type && is_integral_type (current_type))
leftdiv_is_integer = 1;
- }
+ }
exp
- {
+ {
if (leftdiv_is_integer && current_type
&& is_integral_type (current_type))
{
leftdiv_is_integer = 0;
}
- write_exp_elt_opcode (BINOP_DIV);
+ write_exp_elt_opcode (BINOP_DIV);
}
;
;
exp : exp '=' exp
- { write_exp_elt_opcode (BINOP_EQUAL);
+ { write_exp_elt_opcode (BINOP_EQUAL);
current_type = parse_type->builtin_bool;
}
;
exp : exp NOTEQUAL exp
- { write_exp_elt_opcode (BINOP_NOTEQUAL);
+ { write_exp_elt_opcode (BINOP_NOTEQUAL);
current_type = parse_type->builtin_bool;
}
;
exp : exp LEQ exp
- { write_exp_elt_opcode (BINOP_LEQ);
+ { write_exp_elt_opcode (BINOP_LEQ);
current_type = parse_type->builtin_bool;
}
;
exp : exp GEQ exp
- { write_exp_elt_opcode (BINOP_GEQ);
+ { write_exp_elt_opcode (BINOP_GEQ);
current_type = parse_type->builtin_bool;
}
;
exp : exp '<' exp
- { write_exp_elt_opcode (BINOP_LESS);
+ { write_exp_elt_opcode (BINOP_LESS);
current_type = parse_type->builtin_bool;
}
;
exp : exp '>' exp
- { write_exp_elt_opcode (BINOP_GTR);
+ { write_exp_elt_opcode (BINOP_GTR);
current_type = parse_type->builtin_bool;
}
;
exp : SIZEOF '(' type ')' %prec UNARY
{ write_exp_elt_opcode (OP_LONG);
write_exp_elt_type (parse_type->builtin_int);
+ current_type = parse_type->builtin_int;
CHECK_TYPEDEF ($3);
write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
write_exp_elt_opcode (OP_LONG); }
;
exp : SIZEOF '(' exp ')' %prec UNARY
- { write_exp_elt_opcode (UNOP_SIZEOF); }
-
+ { write_exp_elt_opcode (UNOP_SIZEOF);
+ current_type = parse_type->builtin_int; }
+
exp : STRING
{ /* C strings are converted into array constants with
an explicit null byte added at the end. Thus
the array upper bound is the string length.
There is no such thing in C as a completely empty
string. */
- char *sp = $1.ptr; int count = $1.length;
+ const char *sp = $1.ptr; int count = $1.length;
+
while (count-- > 0)
{
write_exp_elt_opcode (OP_LONG);
/* Object pascal */
exp : THIS
- {
+ {
struct value * this_val;
struct type * this_type;
write_exp_elt_opcode (OP_THIS);
- write_exp_elt_opcode (OP_THIS);
+ write_exp_elt_opcode (OP_THIS);
/* We need type of this. */
- this_val = value_of_this (0);
+ this_val = value_of_this_silent (parse_language);
if (this_val)
this_type = value_type (this_val);
else
write_exp_elt_opcode (UNOP_IND);
}
}
-
+
current_type = this_type;
}
;
$$ = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem),
STATIC_BLOCK);
else
- error ("No file or function \"%s\".",
+ error (_("No file or function \"%s\"."),
copy_name ($1.stoken));
}
}
block : block COLONCOLON name
{ struct symbol *tem
= lookup_symbol (copy_name ($3), $1,
- VAR_DOMAIN, (int *) NULL);
+ VAR_DOMAIN, NULL);
if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
- error ("No function \"%s\" in specified context.",
+ error (_("No function \"%s\" in specified context."),
copy_name ($3));
$$ = SYMBOL_BLOCK_VALUE (tem); }
;
variable: block COLONCOLON name
{ struct symbol *sym;
sym = lookup_symbol (copy_name ($3), $1,
- VAR_DOMAIN, (int *) NULL);
+ VAR_DOMAIN, NULL);
if (sym == 0)
- error ("No symbol \"%s\" in specified context.",
+ error (_("No symbol \"%s\" in specified context."),
copy_name ($3));
write_exp_elt_opcode (OP_VAR_VALUE);
struct type *type = $1;
if (TYPE_CODE (type) != TYPE_CODE_STRUCT
&& TYPE_CODE (type) != TYPE_CODE_UNION)
- error ("`%s' is not defined as an aggregate type.",
+ error (_("`%s' is not defined as an aggregate type."),
TYPE_NAME (type));
write_exp_elt_opcode (OP_SCOPE);
{
char *name = copy_name ($2);
struct symbol *sym;
- struct minimal_symbol *msymbol;
+ struct bound_minimal_symbol msymbol;
sym =
lookup_symbol (name, (const struct block *) NULL,
- VAR_DOMAIN, (int *) NULL);
+ VAR_DOMAIN, NULL);
if (sym)
{
write_exp_elt_opcode (OP_VAR_VALUE);
break;
}
- msymbol = lookup_minimal_symbol (name, NULL, NULL);
- if (msymbol != NULL)
+ msymbol = lookup_bound_minimal_symbol (name);
+ if (msymbol.minsym != NULL)
write_exp_msymbol (msymbol);
else if (!have_full_symbols ()
&& !have_partial_symbols ())
- error ("No symbol table is loaded. "
- "Use the \"file\" command.");
+ error (_("No symbol table is loaded. "
+ "Use the \"file\" command."));
else
- error ("No symbol \"%s\" in current context.",
+ error (_("No symbol \"%s\" in current context."),
name);
}
;
write_exp_string ($1.stoken);
write_exp_elt_opcode (STRUCTOP_PTR);
/* We need type of this. */
- this_val = value_of_this (0);
+ this_val = value_of_this_silent (parse_language);
if (this_val)
this_type = value_type (this_val);
else
this_type,
copy_name ($1.stoken), 0);
else
- current_type = NULL;
+ current_type = NULL;
}
else
{
- struct minimal_symbol *msymbol;
+ struct bound_minimal_symbol msymbol;
char *arg = copy_name ($1.stoken);
msymbol =
- lookup_minimal_symbol (arg, NULL, NULL);
- if (msymbol != NULL)
+ lookup_bound_minimal_symbol (arg);
+ if (msymbol.minsym != NULL)
write_exp_msymbol (msymbol);
else if (!have_full_symbols ()
&& !have_partial_symbols ())
- error ("No symbol table is loaded. "
- "Use the \"file\" command.");
+ error (_("No symbol table is loaded. "
+ "Use the \"file\" command."));
else
- error ("No symbol \"%s\" in current context.",
+ error (_("No symbol \"%s\" in current context."),
copy_name ($1.stoken));
}
}
/*** Needs some error checking for the float case ***/
static int
-parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
+parse_number (const char *p, int len, int parsed_float, YYSTYPE *putithere)
{
/* FIXME: Shouldn't these be unsigned? We don't deal with negative values
here, and we do kind of silly things like cast to unsigned. */
FIXME: This check is wrong; for example it doesn't find overflow
on 0x123456789 when LONGEST is 32 bits. */
if (c != 'l' && c != 'u' && n != 0)
- {
+ {
if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
- error ("Numeric constant too large.");
+ error (_("Numeric constant too large."));
}
prevn = n;
}
tpnew->next = tp_top;
tpnew->stored = current_type;
current_type = NULL;
- tp_top = tpnew;
+ tp_top = tpnew;
}
static void
/* Allocate uppercased var: */
/* make an uppercased copy of tokstart. */
-static char * uptok (tokstart, namelen)
- char *tokstart;
- int namelen;
+static char *
+uptok (const char *tokstart, int namelen)
{
int i;
char *uptokstart = (char *)malloc(namelen+1);
return uptokstart;
}
-/* 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;
-
/* Read one token, getting characters through lexptr. */
static int
-yylex ()
+yylex (void)
{
int c;
int namelen;
unsigned int i;
- char *tokstart;
+ const char *tokstart;
char *uptokstart;
- char *tokptr;
+ const char *tokptr;
int explen, tempbufindex;
static char *tempbuf;
static int tempbufsize;
- int saw_structop = last_was_structop;
-
- last_was_structop = 0;
+
retry:
prev_lexptr = lexptr;
tokstart = lexptr;
explen = strlen (lexptr);
+
/* See if it is a special token of length 3. */
if (explen > 2)
for (i = 0; i < sizeof (tokentab3) / sizeof (tokentab3[0]); i++)
switch (c = *tokstart)
{
case 0:
- if (saw_structop && search_field)
+ if (search_field && parse_completion)
return COMPLETE;
else
return 0;
if (c == '\\')
c = parse_escape (parse_gdbarch, &lexptr);
else if (c == '\'')
- error ("Empty character constant.");
+ error (_("Empty character constant."));
yylval.typed_val_int.val = c;
yylval.typed_val_int.type = parse_type->builtin_char;
{
lexptr = tokstart + namelen;
if (lexptr[-1] != '\'')
- error ("Unmatched single quote.");
+ error (_("Unmatched single quote."));
namelen -= 2;
tokstart++;
uptokstart = uptok(tokstart,namelen);
goto tryname;
}
- error ("Invalid character constant.");
+ error (_("Invalid character constant."));
}
return INT;
/* Might be a floating point number. */
if (lexptr[1] < '0' || lexptr[1] > '9')
{
- if (in_parse_field)
- last_was_structop = 1;
goto symbol; /* Nope, must be a symbol. */
}
{
/* It's a number. */
int got_dot = 0, got_e = 0, toktype;
- char *p = tokstart;
+ const char *p = tokstart;
int hex = input_radix > 10;
if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
memcpy (err_copy, tokstart, p - tokstart);
err_copy[p - tokstart] = 0;
- error ("Invalid number \"%s\".", err_copy);
+ error (_("Invalid number \"%s\"."), err_copy);
}
lexptr = p;
return toktype;
/* Do nothing, loop will terminate. */
break;
case '\\':
- tokptr++;
+ ++tokptr;
c = parse_escape (parse_gdbarch, &tokptr);
if (c == -1)
{
} while ((*tokptr != '"') && (*tokptr != '\0'));
if (*tokptr++ != '"')
{
- error ("Unterminated string in expression.");
+ error (_("Unterminated string in expression."));
}
tempbuf[tempbufindex] = '\0'; /* See note above. */
yylval.sval.ptr = tempbuf;
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);
+ error (_("Invalid character '%c' in expression."), c);
/* It's a name. See how long it is. */
namelen = 0;
static const char this_name[] = "this";
if (lookup_symbol (this_name, expression_context_block,
- VAR_DOMAIN, (int *) NULL))
+ VAR_DOMAIN, NULL))
{
free (uptokstart);
return THIS;
if (*tokstart == '$')
{
- char c;
+ char *tmp;
+
/* $ is the normal prefix for pascal hexadecimal values
but this conflicts with the GDB use for debugger variables
so in expression to enter hexadecimal values
we still need to use C syntax with 0xff */
write_dollar_variable (yylval.sval);
- c = tokstart[namelen];
- tokstart[namelen] = 0;
- intvar = lookup_only_internalvar (++tokstart);
- --tokstart;
- tokstart[namelen] = c;
+ tmp = alloca (namelen + 1);
+ memcpy (tmp, tokstart, namelen);
+ tmp[namelen] = '\0';
+ intvar = lookup_only_internalvar (tmp + 1);
free (uptokstart);
return VARIABLE;
}
{
char *tmp = copy_name (yylval.sval);
struct symbol *sym;
- int is_a_field_of_this = 0;
+ struct field_of_this_result is_a_field_of_this;
int is_a_field = 0;
int hextype;
if (search_field && current_type)
is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL);
- if (is_a_field || in_parse_field)
+ if (is_a_field)
sym = NULL;
else
sym = lookup_symbol (tmp, expression_context_block,
VAR_DOMAIN, &is_a_field_of_this);
/* second chance uppercased (as Free Pascal does). */
- if (!sym && !is_a_field_of_this && !is_a_field)
+ if (!sym && is_a_field_of_this.type == NULL && !is_a_field)
{
for (i = 0; i <= namelen; i++)
{
}
if (search_field && current_type)
is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL);
- if (is_a_field || in_parse_field)
+ if (is_a_field)
sym = NULL;
else
sym = lookup_symbol (tmp, expression_context_block,
VAR_DOMAIN, &is_a_field_of_this);
- if (sym || is_a_field_of_this || is_a_field)
- for (i = 0; i <= namelen; i++)
- {
- if ((tokstart[i] >= 'a' && tokstart[i] <= 'z'))
- tokstart[i] -= ('a'-'A');
- }
}
/* Third chance Capitalized (as GPC does). */
- if (!sym && !is_a_field_of_this && !is_a_field)
+ if (!sym && is_a_field_of_this.type == NULL && !is_a_field)
{
for (i = 0; i <= namelen; i++)
{
}
if (search_field && current_type)
is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL);
- if (is_a_field || in_parse_field)
+ if (is_a_field)
sym = NULL;
else
sym = lookup_symbol (tmp, expression_context_block,
VAR_DOMAIN, &is_a_field_of_this);
- if (sym || is_a_field_of_this || is_a_field)
- for (i = 0; i <= namelen; i++)
- {
- if (i == 0)
- {
- if ((tokstart[i] >= 'a' && tokstart[i] <= 'z'))
- tokstart[i] -= ('a'-'A');
- }
- else
- if ((tokstart[i] >= 'A' && tokstart[i] <= 'Z'))
- tokstart[i] -= ('A'-'a');
- }
}
if (is_a_field)
{
tempbuf = (char *) realloc (tempbuf, namelen + 1);
- strncpy (tempbuf, tokstart, namelen); tempbuf [namelen] = 0;
+ strncpy (tempbuf, tmp, namelen);
+ tempbuf [namelen] = 0;
yylval.sval.ptr = tempbuf;
- yylval.sval.length = namelen;
+ yylval.sval.length = namelen;
free (uptokstart);
return FIELDNAME;
- }
+ }
/* Call lookup_symtab, not lookup_partial_symtab, in case there are
no psymtabs (coff, xcoff, or some future change to blow away the
psymtabs once once symbols are read). */
|| lookup_symtab (tmp))
{
yylval.ssym.sym = sym;
- yylval.ssym.is_a_field_of_this = is_a_field_of_this;
+ yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
free (uptokstart);
return BLOCKNAME;
}
distinction) named x, then this code incorrectly thinks we
are dealing with nested types rather than a member function. */
- char *p;
- char *namestart;
+ const char *p;
+ const char *namestart;
struct symbol *best_sym;
/* Look ahead to detect nested types. This probably should be
memcpy (tmp1, namestart, p - namestart);
tmp1[p - namestart] = '\0';
cur_sym = lookup_symbol (ncopy, expression_context_block,
- VAR_DOMAIN, (int *) NULL);
+ VAR_DOMAIN, NULL);
if (cur_sym)
{
if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
if (hextype == INT)
{
yylval.ssym.sym = sym;
- yylval.ssym.is_a_field_of_this = is_a_field_of_this;
+ yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
free (uptokstart);
return NAME_OR_INT;
}
free(uptokstart);
/* Any other kind of symbol. */
yylval.ssym.sym = sym;
- yylval.ssym.is_a_field_of_this = is_a_field_of_this;
+ yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
return NAME;
}
}
void
-yyerror (msg)
- char *msg;
+yyerror (char *msg)
{
if (prev_lexptr)
lexptr = prev_lexptr;
- error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);
+ error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);
}
projects / deliverable / binutils-gdb.git / blobdiff