/* YACC parser for Java expressions, for GDB.
- Copyright (C) 1997, 1998, 1999, 2000, 2006, 2007, 2008, 2009
- Free Software Foundation, Inc.
+ Copyright (C) 1997-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 parse_java_type builtin_java_type (parse_gdbarch)
yacc generated parsers in gdb. Note that these are only the variables
produced by yacc. If other parser generators (bison, byacc, etc) produce
additional global names that conflict at link time, then those parser
- generators need to be fixed instead of adding those names to this list. */
+ generators need to be fixed instead of adding those names to this list. */
#define yymaxdepth java_maxdepth
#define yyparse java_parse
#define yygindex java_yygindex
#define yytable java_yytable
#define yycheck java_yycheck
+#define yyss java_yyss
+#define yysslim java_yysslim
+#define yyssp java_yyssp
+#define yystacksize java_yystacksize
+#define yyvs java_yyvs
+#define yyvsp java_yyvsp
#ifndef YYDEBUG
#define YYDEBUG 1 /* Default to yydebug support */
%{
/* YYSTYPE gets defined by %union */
-static int parse_number (char *, int, int, YYSTYPE *);
+static int parse_number (const char *, int, int, YYSTYPE *);
%}
%type <lval> rcurly Dims Dims_opt
{ $$.length = $1.length + $3.length + 1;
if ($1.ptr + $1.length + 1 == $3.ptr
&& $1.ptr[$1.length] == '.')
- $$.ptr = $1.ptr; /* Optimization. */
+ $$.ptr = $1.ptr; /* Optimization. */
else
{
- $$.ptr = (char *) malloc ($$.length + 1);
- make_cleanup (free, $$.ptr);
- sprintf ($$.ptr, "%.*s.%.*s",
+ char *buf;
+
+ buf = malloc ($$.length + 1);
+ make_cleanup (free, buf);
+ sprintf (buf, "%.*s.%.*s",
$1.length, $1.ptr, $3.length, $3.ptr);
+ $$.ptr = buf;
} }
;
| Name
{ push_expression_name ($1); }
| VARIABLE
- /* Already written by write_dollar_variable. */
+ /* Already written by write_dollar_variable. */
| PostIncrementExpression
| PostDecrementExpression
;
write_exp_elt_opcode (UNOP_CAST); }
| '(' Expression ')' UnaryExpressionNotPlusMinus
{
- int exp_size = expout_ptr;
int last_exp_size = length_of_subexp(expout, expout_ptr);
struct type *type;
int i;
error (_("Invalid cast expression"));
type = expout->elts[base+1].type;
/* Remove the 'Expression' and slide the
- UnaryExpressionNotPlusMinus down to replace it. */
+ UnaryExpressionNotPlusMinus down to replace it. */
for (i = 0; i < last_exp_size; i++)
expout->elts[base + i] = expout->elts[base + i + 3];
expout_ptr -= 3;
ForcedName
{ push_expression_name ($1); }
| VARIABLE
- /* Already written by write_dollar_variable. */
+ /* Already written by write_dollar_variable. */
| FieldAccess
| ArrayAccess
;
/*** 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)
{
ULONGEST n = 0;
ULONGEST limit, limit_div_base;
if (parsed_float)
{
- /* It's a float since it contains a point or an exponent. */
- char c;
- int num = 0; /* number of tokens scanned by scanf */
- char saved_char = p[len];
-
- p[len] = 0; /* null-terminate the token */
- num = sscanf (p, "%" DOUBLEST_SCAN_FORMAT "%c",
- &putithere->typed_val_float.dval, &c);
- p[len] = saved_char; /* restore the input stream */
- if (num != 1) /* check scanf found ONLY a float ... */
+ const char *suffix;
+ int suffix_len;
+
+ if (! parse_float (p, len, &putithere->typed_val_float.dval, &suffix))
return ERROR;
- /* See if it has `f' or `d' suffix (float or double). */
- c = tolower (p[len - 1]);
+ suffix_len = p + len - suffix;
- if (c == 'f' || c == 'F')
- putithere->typed_val_float.type = parse_type->builtin_float;
- else if (isdigit (c) || c == '.' || c == 'd' || c == 'D')
+ if (suffix_len == 0)
putithere->typed_val_float.type = parse_type->builtin_double;
+ else if (suffix_len == 1)
+ {
+ /* See if it has `f' or `d' suffix (float or double). */
+ if (tolower (*suffix) == 'f')
+ putithere->typed_val_float.type =
+ parse_type->builtin_float;
+ else if (tolower (*suffix) == 'd')
+ putithere->typed_val_float.type =
+ parse_type->builtin_double;
+ else
+ return ERROR;
+ }
else
return ERROR;
}
c = p[len-1];
- /* A paranoid calculation of (1<<64)-1. */
+ /* A paranoid calculation of (1<<64)-1. */
limit = (ULONGEST)0xffffffff;
limit = ((limit << 16) << 16) | limit;
if (c == 'l' || c == 'L')
}
/* If the type is bigger than a 32-bit signed integer can be, implicitly
- promote to long. Java does not do this, so mark it as builtin_type_uint64
- rather than parse_java_type->builtin_long. 0x80000000 will become
- -0x80000000 instead of 0x80000000L, because we don't know the sign
- at this point. */
+ promote to long. Java does not do this, so mark it as
+ parse_type->builtin_uint64 rather than parse_java_type->builtin_long.
+ 0x80000000 will become -0x80000000 instead of 0x80000000L, because we
+ don't know the sign at this point. */
if (type == parse_java_type->builtin_int && n > (ULONGEST)0x80000000)
- type = builtin_type_uint64;
+ type = parse_type->builtin_uint64;
putithere->typed_val_int.val = n;
putithere->typed_val_int.type = type;
int c;
int namelen;
unsigned int i;
- char *tokstart;
- char *tokptr;
+ const char *tokstart;
+ const char *tokptr;
int tempbufindex;
static char *tempbuf;
static int tempbufsize;
case '\'':
/* We either have a character constant ('0' or '\177' for example)
or we have a quoted symbol reference ('foo(int,int)' in C++
- for example). */
+ for example). */
lexptr++;
c = *lexptr++;
if (c == '\\')
- c = parse_escape (&lexptr);
+ c = parse_escape (parse_gdbarch, &lexptr);
else if (c == '\'')
error (_("Empty character constant"));
case '.':
/* Might be a floating point number. */
if (lexptr[1] < '0' || lexptr[1] > '9')
- goto symbol; /* Nope, must be a symbol. */
+ goto symbol; /* Nope, must be a symbol. */
/* FALL THRU into number case. */
case '0':
{
/* 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'))
do {
/* Grow the static temp buffer if necessary, including allocating
- the first one on demand. */
+ the first one on demand. */
if (tempbufindex + 1 >= tempbufsize)
{
tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
{
case '\0':
case '"':
- /* Do nothing, loop will terminate. */
+ /* Do nothing, loop will terminate. */
break;
case '\\':
tokptr++;
- c = parse_escape (&tokptr);
+ c = parse_escape (parse_gdbarch, &tokptr);
if (c == -1)
{
continue;
}
/* If NAME is a valid variable name in this scope, push it and return 1.
- Otherwise, return 0. */
+ Otherwise, return 0. */
static int
push_variable (struct stoken name)
{
char *tmp = copy_name (name);
- int is_a_field_of_this = 0;
+ struct field_of_this_result is_a_field_of_this;
struct symbol *sym;
sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN,
&is_a_field_of_this);
write_exp_elt_opcode (OP_VAR_VALUE);
return 1;
}
- if (is_a_field_of_this)
+ if (is_a_field_of_this.type != NULL)
{
/* it hangs off of `this'. Must not inadvertently convert from a
method call to data ref. */
/* Assuming a reference expression has been pushed, emit the
STRUCTOP_PTR ops to access the field named NAME. If NAME is a
- qualified name (has '.'), generate a field access for each part. */
+ qualified name (has '.'), generate a field access for each part. */
static void
push_fieldnames (struct stoken name)
{
if (i == name.length || name.ptr[i] == '.')
{
- /* token.ptr is start of current field name. */
+ /* token.ptr is start of current field name. */
token.length = &name.ptr[i] - token.ptr;
write_exp_elt_opcode (STRUCTOP_PTR);
write_exp_string (token);
}
/* Handle Name in an expression (or LHS).
- Handle VAR, TYPE, TYPE.FIELD1....FIELDN and VAR.FIELD1....FIELDN. */
+ Handle VAR, TYPE, TYPE.FIELD1....FIELDN and VAR.FIELD1....FIELDN. */
static void
push_expression_name (struct stoken name)
{
char *tmp;
struct type *typ;
- char *ptr;
int i;
for (i = 0; i < name.length; i++)
{
if (name.ptr[i] == '.')
{
- /* It's a Qualified Expression Name. */
+ /* It's a Qualified Expression Name. */
push_qualified_expression_name (name, i);
return;
}
}
- /* It's a Simple Expression Name. */
+ /* It's a Simple Expression Name. */
if (push_variable (name))
return;
}
else
{
- struct minimal_symbol *msymbol;
+ struct bound_minimal_symbol msymbol;
- msymbol = lookup_minimal_symbol (tmp, NULL, NULL);
- if (msymbol != NULL)
+ msymbol = lookup_bound_minimal_symbol (tmp);
+ 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"));
else
- error (_("No symbol \"%s\" in current context"), tmp);
+ error (_("No symbol \"%s\" in current context."), tmp);
}
}