You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* This was blantantly ripped off the C expression parser, please
be aware of that as you look at its basic structure -FMB */
%{
#include "defs.h"
+#include "gdb_string.h"
#include "expression.h"
-#include "parser-defs.h"
#include "value.h"
+#include "parser-defs.h"
#include "language.h"
#include "f-lang.h"
#include "bfd.h" /* Required by objfiles.h. */
#define yylloc f_lloc
#define yyreds f_reds /* With YYDEBUG defined */
#define yytoks f_toks /* With YYDEBUG defined */
+#define yylhs f_yylhs
+#define yylen f_yylen
+#define yydefred f_yydefred
+#define yydgoto f_yydgoto
+#define yysindex f_yysindex
+#define yyrindex f_yyrindex
+#define yygindex f_yygindex
+#define yytable f_yytable
+#define yycheck f_yycheck
#ifndef YYDEBUG
#define YYDEBUG 1 /* Default to no yydebug support */
void yyerror PARAMS ((char *));
+static void growbuf_by_size PARAMS ((int));
+
+static int match_string_literal PARAMS ((void));
+
%}
/* Although the yacc "value" of an expression is not used,
LONGEST val;
struct type *type;
} typed_val;
- double dval;
+ DOUBLEST dval;
struct symbol *sym;
struct type *tval;
struct stoken sval;
%token LOGICAL_KEYWORD REAL_KEYWORD REAL_S8_KEYWORD REAL_S16_KEYWORD
%token COMPLEX_S8_KEYWORD COMPLEX_S16_KEYWORD COMPLEX_S32_KEYWORD
%token BOOL_AND BOOL_OR BOOL_NOT
-%token <lval> LAST REGNAME CHARACTER
+%token <lval> CHARACTER
-%token <ivar> VARIABLE
+%token <voidval> VARIABLE
%token <opcode> ASSIGN_MODIFY
write_exp_elt_opcode(OP_TYPE); }
;
-
exp : '(' exp ')'
{ }
;
;
exp : '(' complexnum ')'
- { write_exp_elt_opcode(OP_F77_LITERAL_COMPLEX); }
+ { write_exp_elt_opcode(OP_COMPLEX); }
;
exp : '(' type ')' exp %prec UNARY
write_exp_elt_opcode (OP_LONG);
write_exp_elt_type (val.typed_val.type);
write_exp_elt_longcst ((LONGEST)val.typed_val.val);
- write_exp_elt_opcode (OP_LONG);
- }
+ write_exp_elt_opcode (OP_LONG); }
;
exp : FLOAT
exp : variable
;
-exp : LAST
- { write_exp_elt_opcode (OP_LAST);
- write_exp_elt_longcst ((LONGEST) $1);
- write_exp_elt_opcode (OP_LAST); }
- ;
-
-exp : REGNAME
- { write_exp_elt_opcode (OP_REGISTER);
- write_exp_elt_longcst ((LONGEST) $1);
- write_exp_elt_opcode (OP_REGISTER); }
- ;
-
exp : VARIABLE
- { write_exp_elt_opcode (OP_INTERNALVAR);
- write_exp_elt_intern ($1);
- write_exp_elt_opcode (OP_INTERNALVAR); }
;
exp : SIZEOF '(' type ')' %prec UNARY
{ write_exp_elt_opcode (OP_LONG);
write_exp_elt_type (builtin_type_f_integer);
+ CHECK_TYPEDEF ($3);
write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
write_exp_elt_opcode (OP_LONG); }
;
;
exp : STRING_LITERAL
- { /* In F77, we encounter string literals
- basically in only one place:
- when we are setting up manual parameter
- lists to functions we call by hand or
- when setting string vars to manual values.
- These are character*N type variables.
- They are treated specially behind the
- scenes. Remember that the literal strings's
- OPs are being emitted in reverse order, thus
- we first have the elements and then
- the array descriptor itself. */
- char *sp = $1.ptr; int count = $1.length;
-
- while (count-- > 0)
- {
- write_exp_elt_opcode (OP_LONG);
- write_exp_elt_type (builtin_type_f_character);
- write_exp_elt_longcst ((LONGEST)(*sp++));
- write_exp_elt_opcode (OP_LONG);
- }
- write_exp_elt_opcode (OP_ARRAY);
- write_exp_elt_longcst ((LONGEST) 1);
- write_exp_elt_longcst ((LONGEST) ($1.length));
- write_exp_elt_opcode (OP_ARRAY);
+ {
+ write_exp_elt_opcode (OP_STRING);
+ write_exp_string ($1);
+ write_exp_elt_opcode (OP_STRING);
}
-
;
variable: name_not_typename
innermost_block = block_found;
}
write_exp_elt_opcode (OP_VAR_VALUE);
+ /* We want to use the selected frame, not
+ another more inner frame which happens to
+ be in the same block. */
+ write_exp_elt_block (NULL);
write_exp_elt_sym (sym);
write_exp_elt_opcode (OP_VAR_VALUE);
break;
struct minimal_symbol *msymbol;
register char *arg = copy_name ($1.stoken);
- msymbol = lookup_minimal_symbol (arg, NULL);
+ msymbol =
+ lookup_minimal_symbol (arg, NULL, NULL);
if (msymbol != NULL)
{
write_exp_msymbol (msymbol,
register int base = input_radix;
int unsigned_p = 0;
int long_p = 0;
- unsigned LONGEST high_bit;
+ ULONGEST high_bit;
struct type *signed_type;
struct type *unsigned_type;
if (parsed_float)
{
/* It's a float since it contains a point or an exponent. */
- putithere->dval = atof (p);
+ /* [dD] is not understood as an exponent by atof, change it to 'e'. */
+ char *tmp, *tmp2;
+
+ tmp = strsave (p);
+ for (tmp2 = tmp; *tmp2; ++tmp2)
+ if (*tmp2 == 'd' || *tmp2 == 'D')
+ *tmp2 = 'e';
+ putithere->dval = atof (tmp);
+ free (tmp);
return FLOAT;
}
&& ((n >> 2) >> (TARGET_INT_BIT-2))) /* Avoid shift warning */
|| long_p)
{
- high_bit = ((unsigned LONGEST)1) << (TARGET_LONG_BIT-1);
+ high_bit = ((ULONGEST)1) << (TARGET_LONG_BIT-1);
unsigned_type = builtin_type_unsigned_long;
signed_type = builtin_type_long;
}
else
{
- high_bit = ((unsigned LONGEST)1) << (TARGET_INT_BIT-1);
+ high_bit = ((ULONGEST)1) << (TARGET_INT_BIT-1);
unsigned_type = builtin_type_unsigned_int;
signed_type = builtin_type_int;
}
int namelen;
unsigned int i,token;
char *tokstart;
- char *tokptr;
- int tempbufindex;
- static char *tempbuf;
- static int tempbufsize;
retry:
if (*lexptr == '.')
{
- for (i=0;boolean_values[i].name != NULL;i++)
+ for (i = 0; boolean_values[i].name != NULL; i++)
{
- if STREQN(tokstart,boolean_values[i].name,
- strlen(boolean_values[i].name))
+ if STREQN (tokstart, boolean_values[i].name,
+ strlen (boolean_values[i].name))
{
- lexptr += strlen(boolean_values[i].name);
+ lexptr += strlen (boolean_values[i].name);
yylval.lval = boolean_values[i].value;
- return (BOOLEAN_LITERAL);
+ return BOOLEAN_LITERAL;
}
}
}
/* See if it is a special .foo. operator */
for (i = 0; dot_ops[i].operator != NULL; i++)
- if (STREQN(tokstart, dot_ops[i].operator,
- strlen(dot_ops[i].operator)))
+ if (STREQN (tokstart, dot_ops[i].operator, strlen (dot_ops[i].operator)))
{
- lexptr += strlen(dot_ops[i].operator);
+ lexptr += strlen (dot_ops[i].operator);
yylval.opcode = dot_ops[i].opcode;
return dot_ops[i].token;
}
{
if (!hex && !got_e && (*p == 'e' || *p == 'E'))
got_dot = got_e = 1;
- else if (!hex && !got_e && (*p == 'd' || *p == 'D'))
+ else if (!hex && !got_d && (*p == 'd' || *p == 'D'))
got_dot = got_d = 1;
else if (!hex && !got_dot && *p == '.')
got_dot = 1;
- else if ((got_e && (p[-1] == 'e' || p[-1] == 'E')
- || got_d && (p[-1] == 'd' || p[-1] == 'D'))
+ else if (((got_e && (p[-1] == 'e' || p[-1] == 'E'))
+ || (got_d && (p[-1] == 'd' || p[-1] == 'D')))
&& (*p == '-' || *p == '+'))
/* This is the sign of the exponent, not the end of the
number. */
lexptr += namelen;
- /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
- and $$digits (equivalent to $<-digits> if you could type that).
- Make token type LAST, and put the number (the digits) in yylval. */
-
- tryname:
- if (*tokstart == '$')
- {
- register int negate = 0;
-
- c = 1;
- /* Double dollar means negate the number and add -1 as well.
- Thus $$ alone means -1. */
- if (namelen >= 2 && tokstart[1] == '$')
- {
- negate = 1;
- c = 2;
- }
- if (c == namelen)
- {
- /* Just dollars (one or two) */
- yylval.lval = - negate;
- return LAST;
- }
- /* Is the rest of the token digits? */
- for (; c < namelen; c++)
- if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
- break;
- if (c == namelen)
- {
- yylval.lval = atoi (tokstart + 1 + negate);
- if (negate)
- yylval.lval = - yylval.lval;
- return LAST;
- }
- }
-
- /* Handle tokens that refer to machine registers:
- $ followed by a register name. */
-
- if (*tokstart == '$') {
- for (c = 0; c < NUM_REGS; c++)
- if (namelen - 1 == strlen (reg_names[c])
- && STREQN (tokstart + 1, reg_names[c], namelen - 1))
- {
- yylval.lval = c;
- return REGNAME;
- }
- for (c = 0; c < num_std_regs; c++)
- if (namelen - 1 == strlen (std_regs[c].name)
- && STREQN (tokstart + 1, std_regs[c].name, namelen - 1))
- {
- yylval.lval = std_regs[c].regnum;
- return REGNAME;
- }
- }
/* Catch specific keywords. */
for (i = 0; f77_keywords[i].operator != NULL; i++)
yylval.sval.ptr = tokstart;
yylval.sval.length = namelen;
- /* Any other names starting in $ are debugger internal variables. */
-
if (*tokstart == '$')
{
- yylval.ivar = lookup_internalvar (copy_name (yylval.sval) + 1);
+ write_dollar_variable (yylval.sval);
return VARIABLE;
}