Subversion Repositories or1k

/* YACC parser for Fortran expressions, for GDB.

/* YACC parser for Fortran expressions, for GDB.

   Copyright 1986, 1989, 1990, 1991, 1993, 1994

   Copyright 1986, 1989, 1990, 1991, 1993, 1994

             Free Software Foundation, Inc.

             Free Software Foundation, Inc.

   Contributed by Motorola.  Adapted from the C parser by Farooq Butt

   Contributed by Motorola.  Adapted from the C parser by Farooq Butt

   (fmbutt@engage.sps.mot.com).

   (fmbutt@engage.sps.mot.com).

This file is part of GDB.

This file is part of GDB.

This program is free software; you can redistribute it and/or modify

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

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 2 of the License, or

the Free Software Foundation; either version 2 of the License, or

(at your option) any later version.

(at your option) any later version.

This program is distributed in the hope that it will be useful,

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

along with this program; if not, write to the Free Software

Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

/* This was blantantly ripped off the C expression parser, please

/* This was blantantly ripped off the C expression parser, please

   be aware of that as you look at its basic structure -FMB */

   be aware of that as you look at its basic structure -FMB */

/* Parse a F77 expression from text in a string,

/* Parse a F77 expression from text in a string,

   and return the result as a  struct expression  pointer.

   and return the result as a  struct expression  pointer.

   That structure contains arithmetic operations in reverse polish,

   That structure contains arithmetic operations in reverse polish,

   with constants represented by operations that are followed by special data.

   with constants represented by operations that are followed by special data.

   See expression.h for the details of the format.

   See expression.h for the details of the format.

   What is important here is that it can be built up sequentially

   What is important here is that it can be built up sequentially

   during the process of parsing; the lower levels of the tree always

   during the process of parsing; the lower levels of the tree always

   come first in the result.

   come first in the result.

   Note that malloc's and realloc's in this file are transformed to

   Note that malloc's and realloc's in this file are transformed to

   xmalloc and xrealloc respectively by the same sed command in the

   xmalloc and xrealloc respectively by the same sed command in the

   makefile that remaps any other malloc/realloc inserted by the parser

   makefile that remaps any other malloc/realloc inserted by the parser

   generator.  Doing this with #defines and trying to control the interaction

   generator.  Doing this with #defines and trying to control the interaction

   with include files ( and  for example) just became

   with include files ( and  for example) just became

   too messy, particularly when such includes can be inserted at random

   too messy, particularly when such includes can be inserted at random

   times by the parser generator.  */

   times by the parser generator.  */

%{

%{

#include "defs.h"

#include "defs.h"

#include "gdb_string.h"

#include "gdb_string.h"

#include "expression.h"

#include "expression.h"

#include "value.h"

#include "value.h"

#include "parser-defs.h"

#include "parser-defs.h"

#include "language.h"

#include "language.h"

#include "f-lang.h"

#include "f-lang.h"

#include "bfd.h" /* Required by objfiles.h.  */

#include "bfd.h" /* Required by objfiles.h.  */

#include "symfile.h" /* Required by objfiles.h.  */

#include "symfile.h" /* Required by objfiles.h.  */

#include "objfiles.h" /* For have_full_symbols and have_partial_symbols */

#include "objfiles.h" /* For have_full_symbols and have_partial_symbols */

/* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),

/* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),

   as well as gratuitiously global symbol names, so we can have multiple

   as well as gratuitiously global symbol names, so we can have multiple

   yacc generated parsers in gdb.  Note that these are only the variables

   yacc generated parsers in gdb.  Note that these are only the variables

   produced by yacc.  If other parser generators (bison, byacc, etc) produce

   produced by yacc.  If other parser generators (bison, byacc, etc) produce

   additional global names that conflict at link time, then those parser

   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 f_maxdepth

#define yymaxdepth f_maxdepth

#define yyparse f_parse

#define yyparse f_parse

#define yylex   f_lex

#define yylex   f_lex

#define yyerror f_error

#define yyerror f_error

#define yylval  f_lval

#define yylval  f_lval

#define yychar  f_char

#define yychar  f_char

#define yydebug f_debug

#define yydebug f_debug

#define yypact  f_pact

#define yypact  f_pact

#define yyr1    f_r1

#define yyr1    f_r1

#define yyr2    f_r2

#define yyr2    f_r2

#define yydef   f_def

#define yydef   f_def

#define yychk   f_chk

#define yychk   f_chk

#define yypgo   f_pgo

#define yypgo   f_pgo

#define yyact   f_act

#define yyact   f_act

#define yyexca  f_exca

#define yyexca  f_exca

#define yyerrflag f_errflag

#define yyerrflag f_errflag

#define yynerrs f_nerrs

#define yynerrs f_nerrs

#define yyps    f_ps

#define yyps    f_ps

#define yypv    f_pv

#define yypv    f_pv

#define yys     f_s

#define yys     f_s

#define yy_yys  f_yys

#define yy_yys  f_yys

#define yystate f_state

#define yystate f_state

#define yytmp   f_tmp

#define yytmp   f_tmp

#define yyv     f_v

#define yyv     f_v

#define yy_yyv  f_yyv

#define yy_yyv  f_yyv

#define yyval   f_val

#define yyval   f_val

#define yylloc  f_lloc

#define yylloc  f_lloc

#define yyreds  f_reds          /* With YYDEBUG defined */

#define yyreds  f_reds          /* With YYDEBUG defined */

#define yytoks  f_toks          /* With YYDEBUG defined */

#define yytoks  f_toks          /* With YYDEBUG defined */

#define yylhs   f_yylhs

#define yylhs   f_yylhs

#define yylen   f_yylen

#define yylen   f_yylen

#define yydefred f_yydefred

#define yydefred f_yydefred

#define yydgoto f_yydgoto

#define yydgoto f_yydgoto

#define yysindex f_yysindex

#define yysindex f_yysindex

#define yyrindex f_yyrindex

#define yyrindex f_yyrindex

#define yygindex f_yygindex

#define yygindex f_yygindex

#define yytable  f_yytable

#define yytable  f_yytable

#define yycheck  f_yycheck

#define yycheck  f_yycheck

#ifndef YYDEBUG

#ifndef YYDEBUG

#define YYDEBUG 1               /* Default to no yydebug support */

#define YYDEBUG 1               /* Default to no yydebug support */

#endif

#endif

int yyparse PARAMS ((void));

int yyparse PARAMS ((void));

static int yylex PARAMS ((void));

static int yylex PARAMS ((void));

void yyerror PARAMS ((char *));

void yyerror PARAMS ((char *));

static void growbuf_by_size PARAMS ((int));

static void growbuf_by_size PARAMS ((int));

static int match_string_literal PARAMS ((void));

static int match_string_literal PARAMS ((void));

%}

%}

/* Although the yacc "value" of an expression is not used,

/* Although the yacc "value" of an expression is not used,

   since the result is stored in the structure being created,

   since the result is stored in the structure being created,

   other node types do have values.  */

   other node types do have values.  */

%union

%union

  {

  {

    LONGEST lval;

    LONGEST lval;

    struct {

    struct {

      LONGEST val;

      LONGEST val;

      struct type *type;

      struct type *type;

    } typed_val;

    } typed_val;

    DOUBLEST dval;

    DOUBLEST dval;

    struct symbol *sym;

    struct symbol *sym;

    struct type *tval;

    struct type *tval;

    struct stoken sval;

    struct stoken sval;

    struct ttype tsym;

    struct ttype tsym;

    struct symtoken ssym;

    struct symtoken ssym;

    int voidval;

    int voidval;

    struct block *bval;

    struct block *bval;

    enum exp_opcode opcode;

    enum exp_opcode opcode;

    struct internalvar *ivar;

    struct internalvar *ivar;

    struct type **tvec;

    struct type **tvec;

    int *ivec;

    int *ivec;

  }

  }

%{

%{

/* YYSTYPE gets defined by %union */

/* YYSTYPE gets defined by %union */

static int parse_number PARAMS ((char *, int, int, YYSTYPE *));

static int parse_number PARAMS ((char *, int, int, YYSTYPE *));

%}

%}

%type  exp  type_exp start variable

%type  exp  type_exp start variable

%type  type typebase

%type  type typebase

%type  nonempty_typelist

%type  nonempty_typelist

/* %type  block */

/* %type  block */

/* Fancy type parsing.  */

/* Fancy type parsing.  */

%type  func_mod direct_abs_decl abs_decl

%type  func_mod direct_abs_decl abs_decl

%type  ptype

%type  ptype

%token  INT

%token  INT

%token  FLOAT

%token  FLOAT

/* Both NAME and TYPENAME tokens represent symbols in the input,

/* Both NAME and TYPENAME tokens represent symbols in the input,

   and both convey their data as strings.

   and both convey their data as strings.

   But a TYPENAME is a string that happens to be defined as a typedef

   But a TYPENAME is a string that happens to be defined as a typedef

   or builtin type name (such as int or char)

   or builtin type name (such as int or char)

   and a NAME is any other symbol.

   and a NAME is any other symbol.

   Contexts where this distinction is not important can use the

   Contexts where this distinction is not important can use the

   nonterminal "name", which matches either NAME or TYPENAME.  */

   nonterminal "name", which matches either NAME or TYPENAME.  */

%token  STRING_LITERAL

%token  STRING_LITERAL

%token  BOOLEAN_LITERAL

%token  BOOLEAN_LITERAL

%token  NAME

%token  NAME

%token  TYPENAME

%token  TYPENAME

%type  name

%type  name

%type  name_not_typename

%type  name_not_typename

%type  typename

%type  typename

/* A NAME_OR_INT is a symbol which is not known in the symbol table,

/* A NAME_OR_INT is a symbol which is not known in the symbol table,

   but which would parse as a valid number in the current input radix.

   but which would parse as a valid number in the current input radix.

   E.g. "c" when input_radix==16.  Depending on the parse, it will be

   E.g. "c" when input_radix==16.  Depending on the parse, it will be

   turned into a name or into a number.  */

   turned into a name or into a number.  */

%token  NAME_OR_INT

%token  NAME_OR_INT

%token  SIZEOF

%token  SIZEOF

%token ERROR

%token ERROR

/* Special type cases, put in to allow the parser to distinguish different

/* Special type cases, put in to allow the parser to distinguish different

   legal basetypes.  */

   legal basetypes.  */

%token INT_KEYWORD INT_S2_KEYWORD LOGICAL_S1_KEYWORD LOGICAL_S2_KEYWORD

%token INT_KEYWORD INT_S2_KEYWORD LOGICAL_S1_KEYWORD LOGICAL_S2_KEYWORD

%token LOGICAL_KEYWORD REAL_KEYWORD REAL_S8_KEYWORD REAL_S16_KEYWORD

%token LOGICAL_KEYWORD REAL_KEYWORD REAL_S8_KEYWORD REAL_S16_KEYWORD

%token COMPLEX_S8_KEYWORD COMPLEX_S16_KEYWORD COMPLEX_S32_KEYWORD

%token COMPLEX_S8_KEYWORD COMPLEX_S16_KEYWORD COMPLEX_S32_KEYWORD

%token BOOL_AND BOOL_OR BOOL_NOT

%token BOOL_AND BOOL_OR BOOL_NOT

%token  CHARACTER

%token  CHARACTER

%token  VARIABLE

%token  VARIABLE

%token  ASSIGN_MODIFY

%token  ASSIGN_MODIFY

%left ','

%left ','

%left ABOVE_COMMA

%left ABOVE_COMMA

%right '=' ASSIGN_MODIFY

%right '=' ASSIGN_MODIFY

%right '?'

%right '?'

%left BOOL_OR

%left BOOL_OR

%right BOOL_NOT

%right BOOL_NOT

%left BOOL_AND

%left BOOL_AND

%left '|'

%left '|'

%left '^'

%left '^'

%left '&'

%left '&'

%left EQUAL NOTEQUAL

%left EQUAL NOTEQUAL

%left LESSTHAN GREATERTHAN LEQ GEQ

%left LESSTHAN GREATERTHAN LEQ GEQ

%left LSH RSH

%left LSH RSH

%left '@'

%left '@'

%left '+' '-'

%left '+' '-'

%left '*' '/' '%'

%left '*' '/' '%'

%right UNARY

%right UNARY

%right '('

%right '('

%%

%%

start   :       exp

start   :       exp

        |       type_exp

        |       type_exp

        ;

        ;

type_exp:       type

type_exp:       type

                        { write_exp_elt_opcode(OP_TYPE);

                        { write_exp_elt_opcode(OP_TYPE);

                          write_exp_elt_type($1);

                          write_exp_elt_type($1);

                          write_exp_elt_opcode(OP_TYPE); }

                          write_exp_elt_opcode(OP_TYPE); }

        ;

        ;

exp     :       '(' exp ')'

exp     :       '(' exp ')'

                        { }

                        { }

        ;

        ;

/* Expressions, not including the comma operator.  */

/* Expressions, not including the comma operator.  */

exp     :       '*' exp    %prec UNARY

exp     :       '*' exp    %prec UNARY

                        { write_exp_elt_opcode (UNOP_IND); }

                        { write_exp_elt_opcode (UNOP_IND); }

exp     :       '&' exp    %prec UNARY

exp     :       '&' exp    %prec UNARY

                        { write_exp_elt_opcode (UNOP_ADDR); }

                        { write_exp_elt_opcode (UNOP_ADDR); }

exp     :       '-' exp    %prec UNARY

exp     :       '-' exp    %prec UNARY

                        { write_exp_elt_opcode (UNOP_NEG); }

                        { write_exp_elt_opcode (UNOP_NEG); }

        ;

        ;

exp     :       BOOL_NOT exp    %prec UNARY

exp     :       BOOL_NOT exp    %prec UNARY

                        { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }

                        { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }

        ;

        ;

exp     :       '~' exp    %prec UNARY

exp     :       '~' exp    %prec UNARY

                        { write_exp_elt_opcode (UNOP_COMPLEMENT); }

                        { write_exp_elt_opcode (UNOP_COMPLEMENT); }

        ;

        ;

exp     :       SIZEOF exp       %prec UNARY

exp     :       SIZEOF exp       %prec UNARY

                        { write_exp_elt_opcode (UNOP_SIZEOF); }

                        { write_exp_elt_opcode (UNOP_SIZEOF); }

        ;

        ;

/* No more explicit array operators, we treat everything in F77 as

/* No more explicit array operators, we treat everything in F77 as

   a function call.  The disambiguation as to whether we are

   a function call.  The disambiguation as to whether we are

   doing a subscript operation or a function call is done

   doing a subscript operation or a function call is done

   later in eval.c.  */

   later in eval.c.  */

exp     :       exp '('

exp     :       exp '('

                        { start_arglist (); }

                        { start_arglist (); }

                arglist ')'

                arglist ')'

                        { write_exp_elt_opcode (OP_F77_UNDETERMINED_ARGLIST);

                        { write_exp_elt_opcode (OP_F77_UNDETERMINED_ARGLIST);

                          write_exp_elt_longcst ((LONGEST) end_arglist ());

                          write_exp_elt_longcst ((LONGEST) end_arglist ());

                          write_exp_elt_opcode (OP_F77_UNDETERMINED_ARGLIST); }

                          write_exp_elt_opcode (OP_F77_UNDETERMINED_ARGLIST); }

        ;

        ;

arglist :

arglist :

        ;

        ;

arglist :       exp

arglist :       exp

                        { arglist_len = 1; }

                        { arglist_len = 1; }

        ;

        ;

arglist :      substring

arglist :      substring

                        { arglist_len = 2;}

                        { arglist_len = 2;}

arglist :       arglist ',' exp   %prec ABOVE_COMMA

arglist :       arglist ',' exp   %prec ABOVE_COMMA

                        { arglist_len++; }

                        { arglist_len++; }

        ;

        ;

substring:      exp ':' exp   %prec ABOVE_COMMA

substring:      exp ':' exp   %prec ABOVE_COMMA

                        { }

                        { }

        ;

        ;

complexnum:     exp ',' exp

complexnum:     exp ',' exp

                        { }

                        { }

        ;

        ;

exp     :       '(' complexnum ')'

exp     :       '(' complexnum ')'

                        { write_exp_elt_opcode(OP_COMPLEX); }

                        { write_exp_elt_opcode(OP_COMPLEX); }

        ;

        ;

exp     :       '(' type ')' exp  %prec UNARY

exp     :       '(' type ')' exp  %prec UNARY

                        { write_exp_elt_opcode (UNOP_CAST);

                        { write_exp_elt_opcode (UNOP_CAST);

                          write_exp_elt_type ($2);

                          write_exp_elt_type ($2);

                          write_exp_elt_opcode (UNOP_CAST); }

                          write_exp_elt_opcode (UNOP_CAST); }

        ;

        ;

/* Binary operators in order of decreasing precedence.  */

/* Binary operators in order of decreasing precedence.  */

exp     :       exp '@' exp

exp     :       exp '@' exp

                        { write_exp_elt_opcode (BINOP_REPEAT); }

                        { write_exp_elt_opcode (BINOP_REPEAT); }

        ;

        ;

exp     :       exp '*' exp

exp     :       exp '*' exp

                        { write_exp_elt_opcode (BINOP_MUL); }

                        { write_exp_elt_opcode (BINOP_MUL); }

        ;

        ;

exp     :       exp '/' exp

exp     :       exp '/' exp

                        { write_exp_elt_opcode (BINOP_DIV); }

                        { write_exp_elt_opcode (BINOP_DIV); }

        ;

        ;

exp     :       exp '%' exp

exp     :       exp '%' exp

                        { write_exp_elt_opcode (BINOP_REM); }

                        { write_exp_elt_opcode (BINOP_REM); }

        ;

        ;

exp     :       exp '+' exp

exp     :       exp '+' exp

                        { write_exp_elt_opcode (BINOP_ADD); }

                        { write_exp_elt_opcode (BINOP_ADD); }

        ;

        ;

exp     :       exp '-' exp

exp     :       exp '-' exp

                        { write_exp_elt_opcode (BINOP_SUB); }

                        { write_exp_elt_opcode (BINOP_SUB); }

        ;

        ;

exp     :       exp LSH exp

exp     :       exp LSH exp

                        { write_exp_elt_opcode (BINOP_LSH); }

                        { write_exp_elt_opcode (BINOP_LSH); }

        ;

        ;

exp     :       exp RSH exp

exp     :       exp RSH exp

                        { write_exp_elt_opcode (BINOP_RSH); }

                        { write_exp_elt_opcode (BINOP_RSH); }

        ;

        ;

exp     :       exp EQUAL exp

exp     :       exp EQUAL exp

                        { write_exp_elt_opcode (BINOP_EQUAL); }

                        { write_exp_elt_opcode (BINOP_EQUAL); }

        ;

        ;

exp     :       exp NOTEQUAL exp

exp     :       exp NOTEQUAL exp

                        { write_exp_elt_opcode (BINOP_NOTEQUAL); }

                        { write_exp_elt_opcode (BINOP_NOTEQUAL); }

        ;

        ;

exp     :       exp LEQ exp

exp     :       exp LEQ exp

                        { write_exp_elt_opcode (BINOP_LEQ); }

                        { write_exp_elt_opcode (BINOP_LEQ); }

        ;

        ;

exp     :       exp GEQ exp

exp     :       exp GEQ exp

                        { write_exp_elt_opcode (BINOP_GEQ); }

                        { write_exp_elt_opcode (BINOP_GEQ); }

        ;

        ;

exp     :       exp LESSTHAN exp

exp     :       exp LESSTHAN exp

                        { write_exp_elt_opcode (BINOP_LESS); }

                        { write_exp_elt_opcode (BINOP_LESS); }

        ;

        ;

exp     :       exp GREATERTHAN exp

exp     :       exp GREATERTHAN exp

                        { write_exp_elt_opcode (BINOP_GTR); }

                        { write_exp_elt_opcode (BINOP_GTR); }

        ;

        ;

exp     :       exp '&' exp

exp     :       exp '&' exp

                        { write_exp_elt_opcode (BINOP_BITWISE_AND); }

                        { write_exp_elt_opcode (BINOP_BITWISE_AND); }

        ;

        ;

exp     :       exp '^' exp

exp     :       exp '^' exp

                        { write_exp_elt_opcode (BINOP_BITWISE_XOR); }

                        { write_exp_elt_opcode (BINOP_BITWISE_XOR); }

        ;

        ;

exp     :       exp '|' exp

exp     :       exp '|' exp

                        { write_exp_elt_opcode (BINOP_BITWISE_IOR); }

                        { write_exp_elt_opcode (BINOP_BITWISE_IOR); }

        ;

        ;

exp     :       exp BOOL_AND exp

exp     :       exp BOOL_AND exp

                        { write_exp_elt_opcode (BINOP_LOGICAL_AND); }

                        { write_exp_elt_opcode (BINOP_LOGICAL_AND); }

        ;

        ;

exp     :       exp BOOL_OR exp

exp     :       exp BOOL_OR exp

                        { write_exp_elt_opcode (BINOP_LOGICAL_OR); }

                        { write_exp_elt_opcode (BINOP_LOGICAL_OR); }

        ;

        ;

exp     :       exp '=' exp

exp     :       exp '=' exp

                        { write_exp_elt_opcode (BINOP_ASSIGN); }

                        { write_exp_elt_opcode (BINOP_ASSIGN); }

        ;

        ;

exp     :       exp ASSIGN_MODIFY exp

exp     :       exp ASSIGN_MODIFY exp

                        { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);

                        { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);

                          write_exp_elt_opcode ($2);

                          write_exp_elt_opcode ($2);

                          write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }

                          write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }

        ;

        ;

exp     :       INT

exp     :       INT

                        { write_exp_elt_opcode (OP_LONG);

                        { write_exp_elt_opcode (OP_LONG);

                          write_exp_elt_type ($1.type);

                          write_exp_elt_type ($1.type);

                          write_exp_elt_longcst ((LONGEST)($1.val));

                          write_exp_elt_longcst ((LONGEST)($1.val));

                          write_exp_elt_opcode (OP_LONG); }

                          write_exp_elt_opcode (OP_LONG); }

        ;

        ;

exp     :       NAME_OR_INT

exp     :       NAME_OR_INT

                        { YYSTYPE val;

                        { YYSTYPE val;

                          parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);

                          parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);

                          write_exp_elt_opcode (OP_LONG);

                          write_exp_elt_opcode (OP_LONG);

                          write_exp_elt_type (val.typed_val.type);

                          write_exp_elt_type (val.typed_val.type);

                          write_exp_elt_longcst ((LONGEST)val.typed_val.val);

                          write_exp_elt_longcst ((LONGEST)val.typed_val.val);

                          write_exp_elt_opcode (OP_LONG); }

                          write_exp_elt_opcode (OP_LONG); }

        ;

        ;

exp     :       FLOAT

exp     :       FLOAT

                        { write_exp_elt_opcode (OP_DOUBLE);

                        { write_exp_elt_opcode (OP_DOUBLE);

                          write_exp_elt_type (builtin_type_f_real_s8);

                          write_exp_elt_type (builtin_type_f_real_s8);

                          write_exp_elt_dblcst ($1);

                          write_exp_elt_dblcst ($1);

                          write_exp_elt_opcode (OP_DOUBLE); }

                          write_exp_elt_opcode (OP_DOUBLE); }

        ;

        ;

exp     :       variable

exp     :       variable

        ;

        ;

exp     :       VARIABLE

exp     :       VARIABLE

        ;

        ;

exp     :       SIZEOF '(' type ')'     %prec UNARY

exp     :       SIZEOF '(' type ')'     %prec UNARY

                        { write_exp_elt_opcode (OP_LONG);

                        { write_exp_elt_opcode (OP_LONG);

                          write_exp_elt_type (builtin_type_f_integer);

                          write_exp_elt_type (builtin_type_f_integer);

                          CHECK_TYPEDEF ($3);

                          CHECK_TYPEDEF ($3);

                          write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));

                          write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));

                          write_exp_elt_opcode (OP_LONG); }

                          write_exp_elt_opcode (OP_LONG); }

        ;

        ;

exp     :       BOOLEAN_LITERAL

exp     :       BOOLEAN_LITERAL

                        { write_exp_elt_opcode (OP_BOOL);

                        { write_exp_elt_opcode (OP_BOOL);

                          write_exp_elt_longcst ((LONGEST) $1);

                          write_exp_elt_longcst ((LONGEST) $1);

                          write_exp_elt_opcode (OP_BOOL);

                          write_exp_elt_opcode (OP_BOOL);

                        }

                        }

        ;

        ;

exp     :       STRING_LITERAL

exp     :       STRING_LITERAL

                        {

                        {

                          write_exp_elt_opcode (OP_STRING);

                          write_exp_elt_opcode (OP_STRING);

                          write_exp_string ($1);

                          write_exp_string ($1);

                          write_exp_elt_opcode (OP_STRING);

                          write_exp_elt_opcode (OP_STRING);

                        }

                        }

        ;

        ;

variable:       name_not_typename

variable:       name_not_typename

                        { struct symbol *sym = $1.sym;

                        { struct symbol *sym = $1.sym;

                          if (sym)

                          if (sym)

                            {

                            {

                              if (symbol_read_needs_frame (sym))

                              if (symbol_read_needs_frame (sym))

                                {

                                {

                                  if (innermost_block == 0 ||

                                  if (innermost_block == 0 ||

                                      contained_in (block_found,

                                      contained_in (block_found,

                                                    innermost_block))

                                                    innermost_block))

                                    innermost_block = block_found;

                                    innermost_block = block_found;

                                }

                                }

                              write_exp_elt_opcode (OP_VAR_VALUE);

                              write_exp_elt_opcode (OP_VAR_VALUE);

                              /* We want to use the selected frame, not

                              /* We want to use the selected frame, not

                                 another more inner frame which happens to

                                 another more inner frame which happens to

                                 be in the same block.  */

                                 be in the same block.  */

                              write_exp_elt_block (NULL);

                              write_exp_elt_block (NULL);

                              write_exp_elt_sym (sym);

                              write_exp_elt_sym (sym);

                              write_exp_elt_opcode (OP_VAR_VALUE);

                              write_exp_elt_opcode (OP_VAR_VALUE);

                              break;

                              break;

                            }

                            }

                          else

                          else

                            {

                            {

                              struct minimal_symbol *msymbol;

                              struct minimal_symbol *msymbol;

                              register char *arg = copy_name ($1.stoken);

                              register char *arg = copy_name ($1.stoken);

                              msymbol =

                              msymbol =

                                lookup_minimal_symbol (arg, NULL, NULL);

                                lookup_minimal_symbol (arg, NULL, NULL);

                              if (msymbol != NULL)

                              if (msymbol != NULL)

                                {

                                {

                                  write_exp_msymbol (msymbol,

                                  write_exp_msymbol (msymbol,

                                                     lookup_function_type (builtin_type_int),

                                                     lookup_function_type (builtin_type_int),

                                                     builtin_type_int);

                                                     builtin_type_int);

                                }

                                }

                              else if (!have_full_symbols () && !have_partial_symbols ())

                              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

                              else

                                error ("No symbol \"%s\" in current context.",

                                error ("No symbol \"%s\" in current context.",

                                       copy_name ($1.stoken));

                                       copy_name ($1.stoken));

                            }

                            }

                        }

                        }

        ;

        ;

type    :       ptype

type    :       ptype

        ;

        ;

ptype   :       typebase

ptype   :       typebase

        |       typebase abs_decl

        |       typebase abs_decl

                {

                {

                  /* This is where the interesting stuff happens.  */

                  /* This is where the interesting stuff happens.  */

                  int done = 0;

                  int done = 0;

                  int array_size;

                  int array_size;

                  struct type *follow_type = $1;

                  struct type *follow_type = $1;

                  struct type *range_type;

                  struct type *range_type;

                  while (!done)

                  while (!done)

                    switch (pop_type ())

                    switch (pop_type ())

                      {

                      {

                      case tp_end:

                      case tp_end:

                        done = 1;

                        done = 1;

                        break;

                        break;

                      case tp_pointer:

                      case tp_pointer:

                        follow_type = lookup_pointer_type (follow_type);

                        follow_type = lookup_pointer_type (follow_type);

                        break;

                        break;

                      case tp_reference:

                      case tp_reference:

                        follow_type = lookup_reference_type (follow_type);

                        follow_type = lookup_reference_type (follow_type);

                        break;

                        break;

                      case tp_array:

                      case tp_array:

                        array_size = pop_type_int ();

                        array_size = pop_type_int ();

                        if (array_size != -1)

                        if (array_size != -1)

                          {

                          {

                            range_type =

                            range_type =

                              create_range_type ((struct type *) NULL,

                              create_range_type ((struct type *) NULL,

                                                 builtin_type_f_integer, 0,

                                                 builtin_type_f_integer, 0,

                                                 array_size - 1);

                                                 array_size - 1);

                            follow_type =

                            follow_type =

                              create_array_type ((struct type *) NULL,

                              create_array_type ((struct type *) NULL,

                                                 follow_type, range_type);

                                                 follow_type, range_type);

                          }

                          }

                        else

                        else

                          follow_type = lookup_pointer_type (follow_type);

                          follow_type = lookup_pointer_type (follow_type);

                        break;

                        break;

                      case tp_function:

                      case tp_function:

                        follow_type = lookup_function_type (follow_type);

                        follow_type = lookup_function_type (follow_type);

                        break;

                        break;

                      }

                      }

                  $$ = follow_type;

                  $$ = follow_type;

                }

                }

        ;

        ;

abs_decl:       '*'

abs_decl:       '*'

                        { push_type (tp_pointer); $$ = 0; }

                        { push_type (tp_pointer); $$ = 0; }

        |       '*' abs_decl

        |       '*' abs_decl

                        { push_type (tp_pointer); $$ = $2; }

                        { push_type (tp_pointer); $$ = $2; }

        |       '&'

        |       '&'

                        { push_type (tp_reference); $$ = 0; }

                        { push_type (tp_reference); $$ = 0; }

        |       '&' abs_decl

        |       '&' abs_decl

                        { push_type (tp_reference); $$ = $2; }

                        { push_type (tp_reference); $$ = $2; }

        |       direct_abs_decl

        |       direct_abs_decl

        ;

        ;

direct_abs_decl: '(' abs_decl ')'

direct_abs_decl: '(' abs_decl ')'

                        { $$ = $2; }

                        { $$ = $2; }

        |       direct_abs_decl func_mod

        |       direct_abs_decl func_mod

                        { push_type (tp_function); }

                        { push_type (tp_function); }

        |       func_mod

        |       func_mod

                        { push_type (tp_function); }

                        { push_type (tp_function); }

        ;

        ;

func_mod:       '(' ')'

func_mod:       '(' ')'

                        { $$ = 0; }

                        { $$ = 0; }

        |       '(' nonempty_typelist ')'

        |       '(' nonempty_typelist ')'

                        { free ((PTR)$2); $$ = 0; }

                        { free ((PTR)$2); $$ = 0; }

        ;

        ;

typebase  /* Implements (approximately): (type-qualifier)* type-specifier */

typebase  /* Implements (approximately): (type-qualifier)* type-specifier */

        :       TYPENAME

        :       TYPENAME

                        { $$ = $1.type; }

                        { $$ = $1.type; }

        |       INT_KEYWORD

        |       INT_KEYWORD

                        { $$ = builtin_type_f_integer; }

                        { $$ = builtin_type_f_integer; }

        |       INT_S2_KEYWORD

        |       INT_S2_KEYWORD

                        { $$ = builtin_type_f_integer_s2; }

                        { $$ = builtin_type_f_integer_s2; }

        |       CHARACTER

        |       CHARACTER

                        { $$ = builtin_type_f_character; }

                        { $$ = builtin_type_f_character; }

        |       LOGICAL_KEYWORD

        |       LOGICAL_KEYWORD

                        { $$ = builtin_type_f_logical;}

                        { $$ = builtin_type_f_logical;}

        |       LOGICAL_S2_KEYWORD

        |       LOGICAL_S2_KEYWORD

                        { $$ = builtin_type_f_logical_s2;}

                        { $$ = builtin_type_f_logical_s2;}

        |       LOGICAL_S1_KEYWORD

        |       LOGICAL_S1_KEYWORD

                        { $$ = builtin_type_f_logical_s1;}

                        { $$ = builtin_type_f_logical_s1;}

        |       REAL_KEYWORD

        |       REAL_KEYWORD

                        { $$ = builtin_type_f_real;}

                        { $$ = builtin_type_f_real;}

        |       REAL_S8_KEYWORD

        |       REAL_S8_KEYWORD

                        { $$ = builtin_type_f_real_s8;}

                        { $$ = builtin_type_f_real_s8;}

        |       REAL_S16_KEYWORD

        |       REAL_S16_KEYWORD

                        { $$ = builtin_type_f_real_s16;}

                        { $$ = builtin_type_f_real_s16;}

        |       COMPLEX_S8_KEYWORD

        |       COMPLEX_S8_KEYWORD

                        { $$ = builtin_type_f_complex_s8;}

                        { $$ = builtin_type_f_complex_s8;}

        |       COMPLEX_S16_KEYWORD

        |       COMPLEX_S16_KEYWORD

                        { $$ = builtin_type_f_complex_s16;}

                        { $$ = builtin_type_f_complex_s16;}

        |       COMPLEX_S32_KEYWORD

        |       COMPLEX_S32_KEYWORD

                        { $$ = builtin_type_f_complex_s32;}

                        { $$ = builtin_type_f_complex_s32;}

        ;

        ;

typename:       TYPENAME

typename:       TYPENAME

        ;

        ;

nonempty_typelist

nonempty_typelist

        :       type

        :       type

                { $$ = (struct type **) malloc (sizeof (struct type *) * 2);

                { $$ = (struct type **) malloc (sizeof (struct type *) * 2);

                  $$[0] = 1;    /* Number of types in vector */

                  $$[0] = 1;    /* Number of types in vector */

                  $$[1] = $1;

                  $$[1] = $1;

                }

                }

        |       nonempty_typelist ',' type

        |       nonempty_typelist ',' type

                { int len = sizeof (struct type *) * (++($1[0]) + 1);

                { int len = sizeof (struct type *) * (++($1[0]) + 1);

                  $$ = (struct type **) realloc ((char *) $1, len);

                  $$ = (struct type **) realloc ((char *) $1, len);

                  $$[$$[0]] = $3;

                  $$[$$[0]] = $3;

                }

                }

        ;

        ;

name    :       NAME

name    :       NAME

                        { $$ = $1.stoken; }

                        { $$ = $1.stoken; }

        |       TYPENAME

        |       TYPENAME

                        { $$ = $1.stoken; }

                        { $$ = $1.stoken; }

        |       NAME_OR_INT

        |       NAME_OR_INT

                        { $$ = $1.stoken; }

                        { $$ = $1.stoken; }

        ;

        ;

name_not_typename :     NAME

name_not_typename :     NAME

/* These would be useful if name_not_typename was useful, but it is just

/* These would be useful if name_not_typename was useful, but it is just

   a fake for "variable", so these cause reduce/reduce conflicts because

   a fake for "variable", so these cause reduce/reduce conflicts because

   the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,

   the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,

   =exp) or just an exp.  If name_not_typename was ever used in an lvalue

   =exp) or just an exp.  If name_not_typename was ever used in an lvalue

   context where only a name could occur, this might be useful.

   context where only a name could occur, this might be useful.

        |       NAME_OR_INT

        |       NAME_OR_INT

   */

   */

        ;

        ;

%%

%%

/* Take care of parsing a number (anything that starts with a digit).

/* Take care of parsing a number (anything that starts with a digit).

   Set yylval and return the token type; update lexptr.

   Set yylval and return the token type; update lexptr.

   LEN is the number of characters in it.  */

   LEN is the number of characters in it.  */

/*** Needs some error checking for the float case ***/

/*** Needs some error checking for the float case ***/

static int

static int

parse_number (p, len, parsed_float, putithere)

parse_number (p, len, parsed_float, putithere)

     register char *p;

     register char *p;

     register int len;

     register int len;

     int parsed_float;

     int parsed_float;

     YYSTYPE *putithere;

     YYSTYPE *putithere;

{

{

  register LONGEST n = 0;

  register LONGEST n = 0;

  register LONGEST prevn = 0;

  register LONGEST prevn = 0;

  register int i;

  register int i;

  register int c;

  register int c;

  register int base = input_radix;

  register int base = input_radix;

  int unsigned_p = 0;

  int unsigned_p = 0;

  int long_p = 0;

  int long_p = 0;

  ULONGEST high_bit;

  ULONGEST high_bit;

  struct type *signed_type;

  struct type *signed_type;

  struct type *unsigned_type;

  struct type *unsigned_type;

  if (parsed_float)

  if (parsed_float)

    {

    {

      /* It's a float since it contains a point or an exponent.  */

      /* It's a float since it contains a point or an exponent.  */

      /* [dD] is not understood as an exponent by atof, change it to 'e'.  */

      /* [dD] is not understood as an exponent by atof, change it to 'e'.  */

      char *tmp, *tmp2;

      char *tmp, *tmp2;

      tmp = strsave (p);

      tmp = strsave (p);

      for (tmp2 = tmp; *tmp2; ++tmp2)

      for (tmp2 = tmp; *tmp2; ++tmp2)

        if (*tmp2 == 'd' || *tmp2 == 'D')

        if (*tmp2 == 'd' || *tmp2 == 'D')

          *tmp2 = 'e';

          *tmp2 = 'e';

      putithere->dval = atof (tmp);

      putithere->dval = atof (tmp);

      free (tmp);

      free (tmp);

      return FLOAT;

      return FLOAT;

    }

    }

  /* Handle base-switching prefixes 0x, 0t, 0d, 0 */

  /* Handle base-switching prefixes 0x, 0t, 0d, 0 */

  if (p[0] == '0')

  if (p[0] == '0')

    switch (p[1])

    switch (p[1])

      {

      {

      case 'x':

      case 'x':

      case 'X':

      case 'X':

        if (len >= 3)

        if (len >= 3)

          {

          {

            p += 2;

            p += 2;

            base = 16;

            base = 16;

            len -= 2;

            len -= 2;

          }

          }

        break;

        break;

      case 't':

      case 't':

      case 'T':

      case 'T':

      case 'd':

      case 'd':

      case 'D':

      case 'D':

        if (len >= 3)

        if (len >= 3)

          {

          {

            p += 2;

            p += 2;

            base = 10;

            base = 10;

            len -= 2;

            len -= 2;

          }

          }

        break;

        break;

      default:

      default:

        base = 8;

        base = 8;

        break;

        break;

      }

      }

  while (len-- > 0)

  while (len-- > 0)

    {

    {

      c = *p++;

      c = *p++;

      if (c >= 'A' && c <= 'Z')

      if (c >= 'A' && c <= 'Z')

        c += 'a' - 'A';

        c += 'a' - 'A';

      if (c != 'l' && c != 'u')

      if (c != 'l' && c != 'u')

        n *= base;

        n *= base;

      if (c >= '0' && c <= '9')

      if (c >= '0' && c <= '9')

        n += i = c - '0';

        n += i = c - '0';

      else

      else

        {

        {

          if (base > 10 && c >= 'a' && c <= 'f')

          if (base > 10 && c >= 'a' && c <= 'f')

            n += i = c - 'a' + 10;

            n += i = c - 'a' + 10;

          else if (len == 0 && c == 'l')

          else if (len == 0 && c == 'l')

            long_p = 1;

            long_p = 1;

          else if (len == 0 && c == 'u')

          else if (len == 0 && c == 'u')

            unsigned_p = 1;

            unsigned_p = 1;

          else

          else

            return ERROR;       /* Char not a digit */

            return ERROR;       /* Char not a digit */

        }

        }

      if (i >= base)

      if (i >= base)

        return ERROR;           /* Invalid digit in this base */

        return ERROR;           /* Invalid digit in this base */

      /* Portably test for overflow (only works for nonzero values, so make

      /* Portably test for overflow (only works for nonzero values, so make

         a second check for zero).  */

         a second check for zero).  */

      if ((prevn >= n) && n != 0)

      if ((prevn >= n) && n != 0)

        unsigned_p=1;           /* Try something unsigned */

        unsigned_p=1;           /* Try something unsigned */

      /* If range checking enabled, portably test for unsigned overflow.  */

      /* If range checking enabled, portably test for unsigned overflow.  */

      if (RANGE_CHECK && n != 0)

      if (RANGE_CHECK && n != 0)

        {

        {

          if ((unsigned_p && (unsigned)prevn >= (unsigned)n))

          if ((unsigned_p && (unsigned)prevn >= (unsigned)n))

            range_error("Overflow on numeric constant.");

            range_error("Overflow on numeric constant.");

        }

        }

      prevn = n;

      prevn = n;

    }

    }

  /* If the number is too big to be an int, or it's got an l suffix

  /* If the number is too big to be an int, or it's got an l suffix

     then it's a long.  Work out if this has to be a long by

     then it's a long.  Work out if this has to be a long by

     shifting right and and seeing if anything remains, and the

     shifting right and and seeing if anything remains, and the

     target int size is different to the target long size.

     target int size is different to the target long size.

     In the expression below, we could have tested

     In the expression below, we could have tested

     (n >> TARGET_INT_BIT)

     (n >> TARGET_INT_BIT)

     to see if it was zero,

     to see if it was zero,

     but too many compilers warn about that, when ints and longs

     but too many compilers warn about that, when ints and longs

     are the same size.  So we shift it twice, with fewer bits

     are the same size.  So we shift it twice, with fewer bits

     each time, for the same result.  */

     each time, for the same result.  */

  if ((TARGET_INT_BIT != TARGET_LONG_BIT

  if ((TARGET_INT_BIT != TARGET_LONG_BIT

       && ((n >> 2) >> (TARGET_INT_BIT-2)))   /* Avoid shift warning */

       && ((n >> 2) >> (TARGET_INT_BIT-2)))   /* Avoid shift warning */

      || long_p)

      || long_p)

    {

    {

      high_bit = ((ULONGEST)1) << (TARGET_LONG_BIT-1);

      high_bit = ((ULONGEST)1) << (TARGET_LONG_BIT-1);

      unsigned_type = builtin_type_unsigned_long;

      unsigned_type = builtin_type_unsigned_long;

      signed_type = builtin_type_long;

      signed_type = builtin_type_long;

    }

    }

  else

  else

    {

    {

      high_bit = ((ULONGEST)1) << (TARGET_INT_BIT-1);

      high_bit = ((ULONGEST)1) << (TARGET_INT_BIT-1);

      unsigned_type = builtin_type_unsigned_int;

      unsigned_type = builtin_type_unsigned_int;

      signed_type = builtin_type_int;

      signed_type = builtin_type_int;

    }

    }

  putithere->typed_val.val = n;

  putithere->typed_val.val = n;

  /* If the high bit of the worked out type is set then this number

  /* If the high bit of the worked out type is set then this number

     has to be unsigned. */

     has to be unsigned. */

  if (unsigned_p || (n & high_bit))

  if (unsigned_p || (n & high_bit))

    putithere->typed_val.type = unsigned_type;

    putithere->typed_val.type = unsigned_type;

  else

  else

    putithere->typed_val.type = signed_type;

    putithere->typed_val.type = signed_type;

  return INT;

  return INT;

}

}

struct token

struct token

{

{

  char *operator;

  char *operator;

  int token;

  int token;

  enum exp_opcode opcode;

  enum exp_opcode opcode;

};

};

static const struct token dot_ops[] =

static const struct token dot_ops[] =

{

{

  { ".and.", BOOL_AND, BINOP_END },

  { ".and.", BOOL_AND, BINOP_END },

  { ".AND.", BOOL_AND, BINOP_END },

  { ".AND.", BOOL_AND, BINOP_END },

  { ".or.", BOOL_OR, BINOP_END },

  { ".or.", BOOL_OR, BINOP_END },

  { ".OR.", BOOL_OR, BINOP_END },

  { ".OR.", BOOL_OR, BINOP_END },

  { ".not.", BOOL_NOT, BINOP_END },

  { ".not.", BOOL_NOT, BINOP_END },

  { ".NOT.", BOOL_NOT, BINOP_END },

  { ".NOT.", BOOL_NOT, BINOP_END },

  { ".eq.", EQUAL, BINOP_END },

  { ".eq.", EQUAL, BINOP_END },

  { ".EQ.", EQUAL, BINOP_END },

  { ".EQ.", EQUAL, BINOP_END },

  { ".eqv.", EQUAL, BINOP_END },

  { ".eqv.", EQUAL, BINOP_END },

  { ".NEQV.", NOTEQUAL, BINOP_END },

  { ".NEQV.", NOTEQUAL, BINOP_END },

  { ".neqv.", NOTEQUAL, BINOP_END },

  { ".neqv.", NOTEQUAL, BINOP_END },

  { ".EQV.", EQUAL, BINOP_END },

  { ".EQV.", EQUAL, BINOP_END },

  { ".ne.", NOTEQUAL, BINOP_END },

  { ".ne.", NOTEQUAL, BINOP_END },

  { ".NE.", NOTEQUAL, BINOP_END },

  { ".NE.", NOTEQUAL, BINOP_END },

  { ".le.", LEQ, BINOP_END },

  { ".le.", LEQ, BINOP_END },

  { ".LE.", LEQ, BINOP_END },

  { ".LE.", LEQ, BINOP_END },

  { ".ge.", GEQ, BINOP_END },

  { ".ge.", GEQ, BINOP_END },

  { ".GE.", GEQ, BINOP_END },

  { ".GE.", GEQ, BINOP_END },

  { ".gt.", GREATERTHAN, BINOP_END },

  { ".gt.", GREATERTHAN, BINOP_END },

  { ".GT.", GREATERTHAN, BINOP_END },

  { ".GT.", GREATERTHAN, BINOP_END },

  { ".lt.", LESSTHAN, BINOP_END },

  { ".lt.", LESSTHAN, BINOP_END },

  { ".LT.", LESSTHAN, BINOP_END },

  { ".LT.", LESSTHAN, BINOP_END },

  { NULL, 0, 0 }

  { NULL, 0, 0 }

};

};

struct f77_boolean_val

struct f77_boolean_val

{

{

  char *name;

  char *name;

  int value;

  int value;

};

};

static const struct f77_boolean_val boolean_values[]  =

static const struct f77_boolean_val boolean_values[]  =

{

{

  { ".true.", 1 },

  { ".true.", 1 },

  { ".TRUE.", 1 },

  { ".TRUE.", 1 },

  { ".false.", 0 },

  { ".false.", 0 },

  { ".FALSE.", 0 },

  { ".FALSE.", 0 },

  { NULL, 0 }

  { NULL, 0 }

};

};

static const struct token f77_keywords[] =

static const struct token f77_keywords[] =

{

{

  { "complex_16", COMPLEX_S16_KEYWORD, BINOP_END },

  { "complex_16", COMPLEX_S16_KEYWORD, BINOP_END },

  { "complex_32", COMPLEX_S32_KEYWORD, BINOP_END },

  { "complex_32", COMPLEX_S32_KEYWORD, BINOP_END },

  { "character", CHARACTER, BINOP_END },

  { "character", CHARACTER, BINOP_END },

  { "integer_2", INT_S2_KEYWORD, BINOP_END },

  { "integer_2", INT_S2_KEYWORD, BINOP_END },

  { "logical_1", LOGICAL_S1_KEYWORD, BINOP_END },

  { "logical_1", LOGICAL_S1_KEYWORD, BINOP_END },

  { "logical_2", LOGICAL_S2_KEYWORD, BINOP_END },

  { "logical_2", LOGICAL_S2_KEYWORD, BINOP_END },

  { "complex_8", COMPLEX_S8_KEYWORD, BINOP_END },

  { "complex_8", COMPLEX_S8_KEYWORD, BINOP_END },

  { "integer", INT_KEYWORD, BINOP_END },

  { "integer", INT_KEYWORD, BINOP_END },

  { "logical", LOGICAL_KEYWORD, BINOP_END },

  { "logical", LOGICAL_KEYWORD, BINOP_END },

  { "real_16", REAL_S16_KEYWORD, BINOP_END },

  { "real_16", REAL_S16_KEYWORD, BINOP_END },

  { "complex", COMPLEX_S8_KEYWORD, BINOP_END },

  { "complex", COMPLEX_S8_KEYWORD, BINOP_END },

  { "sizeof", SIZEOF, BINOP_END },

  { "sizeof", SIZEOF, BINOP_END },

  { "real_8", REAL_S8_KEYWORD, BINOP_END },

  { "real_8", REAL_S8_KEYWORD, BINOP_END },

  { "real", REAL_KEYWORD, BINOP_END },

  { "real", REAL_KEYWORD, BINOP_END },

  { NULL, 0, 0 }

  { NULL, 0, 0 }

};

};

/* Implementation of a dynamically expandable buffer for processing input

/* Implementation of a dynamically expandable buffer for processing input

   characters acquired through lexptr and building a value to return in

   characters acquired through lexptr and building a value to return in

   yylval. Ripped off from ch-exp.y */

   yylval. Ripped off from ch-exp.y */

static char *tempbuf;           /* Current buffer contents */

static char *tempbuf;           /* Current buffer contents */

static int tempbufsize;         /* Size of allocated buffer */

static int tempbufsize;         /* Size of allocated buffer */

static int tempbufindex;        /* Current index into buffer */

static int tempbufindex;        /* Current index into buffer */

#define GROWBY_MIN_SIZE 64      /* Minimum amount to grow buffer by */

#define GROWBY_MIN_SIZE 64      /* Minimum amount to grow buffer by */

#define CHECKBUF(size) \

#define CHECKBUF(size) \

  do { \

  do { \

    if (tempbufindex + (size) >= tempbufsize) \

    if (tempbufindex + (size) >= tempbufsize) \

      { \

      { \

        growbuf_by_size (size); \

        growbuf_by_size (size); \

      } \

      } \

  } while (0);

  } while (0);

/* Grow the static temp buffer if necessary, including allocating the first one

/* Grow the static temp buffer if necessary, including allocating the first one

   on demand. */

   on demand. */

static void

static void

growbuf_by_size (count)

growbuf_by_size (count)

     int count;

     int count;

{

{

  int growby;

  int growby;

  growby = max (count, GROWBY_MIN_SIZE);

  growby = max (count, GROWBY_MIN_SIZE);

  tempbufsize += growby;

  tempbufsize += growby;

  if (tempbuf == NULL)

  if (tempbuf == NULL)

    tempbuf = (char *) malloc (tempbufsize);

    tempbuf = (char *) malloc (tempbufsize);

  else

  else

    tempbuf = (char *) realloc (tempbuf, tempbufsize);

    tempbuf = (char *) realloc (tempbuf, tempbufsize);

}

}

/* Blatantly ripped off from ch-exp.y. This routine recognizes F77

/* Blatantly ripped off from ch-exp.y. This routine recognizes F77

   string-literals.

   string-literals.

   Recognize a string literal.  A string literal is a nonzero sequence

   Recognize a string literal.  A string literal is a nonzero sequence

   of characters enclosed in matching single quotes, except that

   of characters enclosed in matching single quotes, except that

   a single character inside single quotes is a character literal, which

   a single character inside single quotes is a character literal, which

   we reject as a string literal.  To embed the terminator character inside

   we reject as a string literal.  To embed the terminator character inside

   a string, it is simply doubled (I.E. 'this''is''one''string') */

   a string, it is simply doubled (I.E. 'this''is''one''string') */

static int

static int

match_string_literal ()

match_string_literal ()

{

{

  char *tokptr = lexptr;

  char *tokptr = lexptr;

  for (tempbufindex = 0, tokptr++; *tokptr != '\0'; tokptr++)

  for (tempbufindex = 0, tokptr++; *tokptr != '\0'; tokptr++)

    {

    {

      CHECKBUF (1);

      CHECKBUF (1);

      if (*tokptr == *lexptr)

      if (*tokptr == *lexptr)

        {

        {

          if (*(tokptr + 1) == *lexptr)

          if (*(tokptr + 1) == *lexptr)

            tokptr++;

            tokptr++;

          else

          else

            break;

            break;

        }

        }

      tempbuf[tempbufindex++] = *tokptr;

      tempbuf[tempbufindex++] = *tokptr;

    }

    }

  if (*tokptr == '\0'                                   /* no terminator */

  if (*tokptr == '\0'                                   /* no terminator */

      || tempbufindex == 0)                             /* no string */

      || tempbufindex == 0)                             /* no string */

    return 0;

    return 0;

  else

  else

    {

    {

      tempbuf[tempbufindex] = '\0';

      tempbuf[tempbufindex] = '\0';

      yylval.sval.ptr = tempbuf;

      yylval.sval.ptr = tempbuf;

      yylval.sval.length = tempbufindex;

      yylval.sval.length = tempbufindex;

      lexptr = ++tokptr;

      lexptr = ++tokptr;

      return STRING_LITERAL;

      return STRING_LITERAL;

    }

    }

}

}

/* Read one token, getting characters through lexptr.  */

/* Read one token, getting characters through lexptr.  */

static int

static int

yylex ()

yylex ()

{

{

  int c;

  int c;

  int namelen;

  int namelen;

  unsigned int i,token;

  unsigned int i,token;

  char *tokstart;

  char *tokstart;

 retry:

 retry:

  tokstart = lexptr;

  tokstart = lexptr;

  /* First of all, let us make sure we are not dealing with the

  /* First of all, let us make sure we are not dealing with the

     special tokens .true. and .false. which evaluate to 1 and 0.  */

     special tokens .true. and .false. which evaluate to 1 and 0.  */

  if (*lexptr == '.')

  if (*lexptr == '.')

    {

    {