Subversion Repositories or1k

/* YACC parser for Java expressions, for GDB.

/* YACC parser for Java expressions, for GDB.

   Copyright (C) 1997, 1998, 1999.

   Copyright (C) 1997, 1998, 1999.

   Free Software Foundation, Inc.

   Free Software Foundation, Inc.

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.  */

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

/* Parse a Java 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.  Well, almost always; see ArrayAccess.

   come first in the result.  Well, almost always; see ArrayAccess.

   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 

#include 

#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 "jv-lang.h"

#include "jv-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 java_maxdepth

#define yymaxdepth java_maxdepth

#define yyparse java_parse

#define yyparse java_parse

#define yylex   java_lex

#define yylex   java_lex

#define yyerror java_error

#define yyerror java_error

#define yylval  java_lval

#define yylval  java_lval

#define yychar  java_char

#define yychar  java_char

#define yydebug java_debug

#define yydebug java_debug

#define yypact  java_pact

#define yypact  java_pact

#define yyr1    java_r1

#define yyr1    java_r1

#define yyr2    java_r2

#define yyr2    java_r2

#define yydef   java_def

#define yydef   java_def

#define yychk   java_chk

#define yychk   java_chk

#define yypgo   java_pgo

#define yypgo   java_pgo

#define yyact   java_act

#define yyact   java_act

#define yyexca  java_exca

#define yyexca  java_exca

#define yyerrflag java_errflag

#define yyerrflag java_errflag

#define yynerrs java_nerrs

#define yynerrs java_nerrs

#define yyps    java_ps

#define yyps    java_ps

#define yypv    java_pv

#define yypv    java_pv

#define yys     java_s

#define yys     java_s

#define yy_yys  java_yys

#define yy_yys  java_yys

#define yystate java_state

#define yystate java_state

#define yytmp   java_tmp

#define yytmp   java_tmp

#define yyv     java_v

#define yyv     java_v

#define yy_yyv  java_yyv

#define yy_yyv  java_yyv

#define yyval   java_val

#define yyval   java_val

#define yylloc  java_lloc

#define yylloc  java_lloc

#define yyreds  java_reds               /* With YYDEBUG defined */

#define yyreds  java_reds               /* With YYDEBUG defined */

#define yytoks  java_toks               /* With YYDEBUG defined */

#define yytoks  java_toks               /* With YYDEBUG defined */

#define yylhs   java_yylhs

#define yylhs   java_yylhs

#define yylen   java_yylen

#define yylen   java_yylen

#define yydefred java_yydefred

#define yydefred java_yydefred

#define yydgoto java_yydgoto

#define yydgoto java_yydgoto

#define yysindex java_yysindex

#define yysindex java_yysindex

#define yyrindex java_yyrindex

#define yyrindex java_yyrindex

#define yygindex java_yygindex

#define yygindex java_yygindex

#define yytable  java_yytable

#define yytable  java_yytable

#define yycheck  java_yycheck

#define yycheck  java_yycheck

#ifndef YYDEBUG

#ifndef YYDEBUG

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

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

#endif

#endif

int

int

yyparse PARAMS ((void));

yyparse PARAMS ((void));

static int

static int

yylex PARAMS ((void));

yylex PARAMS ((void));

void

void

yyerror PARAMS ((char *));

yyerror PARAMS ((char *));

static struct type * java_type_from_name PARAMS ((struct stoken));

static struct type * java_type_from_name PARAMS ((struct stoken));

static void push_expression_name PARAMS ((struct stoken));

static void push_expression_name PARAMS ((struct stoken));

static void push_fieldnames PARAMS ((struct stoken));

static void push_fieldnames PARAMS ((struct stoken));

static struct expression *copy_exp PARAMS ((struct expression *, int));

static struct expression *copy_exp PARAMS ((struct expression *, int));

static void insert_exp PARAMS ((int, struct expression *));

static void insert_exp PARAMS ((int, struct expression *));

%}

%}

/* 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_int;

    } typed_val_int;

    struct {

    struct {

      DOUBLEST dval;

      DOUBLEST dval;

      struct type *type;

      struct type *type;

    } typed_val_float;

    } typed_val_float;

    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;

    struct block *bval;

    struct block *bval;

    enum exp_opcode opcode;

    enum exp_opcode opcode;

    struct internalvar *ivar;

    struct internalvar *ivar;

    int *ivec;

    int *ivec;

  }

  }

%{

%{

/* YYSTYPE gets defined by %union */

/* YYSTYPE gets defined by %union */

static int

static int

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

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

%}

%}

%type  rcurly Dims Dims_opt

%type  rcurly Dims Dims_opt

%type  ClassOrInterfaceType ClassType /* ReferenceType Type ArrayType */

%type  ClassOrInterfaceType ClassType /* ReferenceType Type ArrayType */

%type  IntegralType FloatingPointType NumericType PrimitiveType ArrayType PrimitiveOrArrayType

%type  IntegralType FloatingPointType NumericType PrimitiveType ArrayType PrimitiveOrArrayType

%token  INTEGER_LITERAL

%token  INTEGER_LITERAL

%token  FLOATING_POINT_LITERAL

%token  FLOATING_POINT_LITERAL

%token  IDENTIFIER

%token  IDENTIFIER

%token  STRING_LITERAL

%token  STRING_LITERAL

%token  BOOLEAN_LITERAL

%token  BOOLEAN_LITERAL

%token  TYPENAME

%token  TYPENAME

%type  Name SimpleName QualifiedName ForcedName

%type  Name SimpleName QualifiedName ForcedName

/* 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 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 LONG SHORT BYTE INT CHAR BOOLEAN DOUBLE FLOAT

%token LONG SHORT BYTE INT CHAR BOOLEAN DOUBLE FLOAT

%token VARIABLE

%token VARIABLE

%token  ASSIGN_MODIFY

%token  ASSIGN_MODIFY

%token THIS SUPER NEW

%token THIS SUPER NEW

%left ','

%left ','

%right '=' ASSIGN_MODIFY

%right '=' ASSIGN_MODIFY

%right '?'

%right '?'

%left OROR

%left OROR

%left ANDAND

%left ANDAND

%left '|'

%left '|'

%left '^'

%left '^'

%left '&'

%left '&'

%left EQUAL NOTEQUAL

%left EQUAL NOTEQUAL

%left '<' '>' LEQ GEQ

%left '<' '>' LEQ GEQ

%left LSH RSH

%left LSH RSH

%left '+' '-'

%left '+' '-'

%left '*' '/' '%'

%left '*' '/' '%'

%right INCREMENT DECREMENT

%right INCREMENT DECREMENT

%right '.' '[' '('

%right '.' '[' '('

%%

%%

start   :       exp1

start   :       exp1

        |       type_exp

        |       type_exp

        ;

        ;

type_exp:       PrimitiveOrArrayType

type_exp:       PrimitiveOrArrayType

                {

                {

                  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);

                }

                }

        ;

        ;

PrimitiveOrArrayType:

PrimitiveOrArrayType:

                PrimitiveType

                PrimitiveType

        |       ArrayType

        |       ArrayType

        ;

        ;

StringLiteral:

StringLiteral:

        STRING_LITERAL

        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);

                }

                }

;

;

Literal:

Literal:

        INTEGER_LITERAL

        INTEGER_LITERAL

                { 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); }

|       NAME_OR_INT

|       NAME_OR_INT

                { YYSTYPE val;

                { YYSTYPE val;

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

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

                  write_exp_elt_opcode (OP_LONG);

                  write_exp_elt_opcode (OP_LONG);

                  write_exp_elt_type (val.typed_val_int.type);

                  write_exp_elt_type (val.typed_val_int.type);

                  write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);

                  write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);

                  write_exp_elt_opcode (OP_LONG);

                  write_exp_elt_opcode (OP_LONG);

                }

                }

|       FLOATING_POINT_LITERAL

|       FLOATING_POINT_LITERAL

                { write_exp_elt_opcode (OP_DOUBLE);

                { write_exp_elt_opcode (OP_DOUBLE);

                  write_exp_elt_type ($1.type);

                  write_exp_elt_type ($1.type);

                  write_exp_elt_dblcst ($1.dval);

                  write_exp_elt_dblcst ($1.dval);

                  write_exp_elt_opcode (OP_DOUBLE); }

                  write_exp_elt_opcode (OP_DOUBLE); }

|       BOOLEAN_LITERAL

|       BOOLEAN_LITERAL

                { write_exp_elt_opcode (OP_LONG);

                { write_exp_elt_opcode (OP_LONG);

                  write_exp_elt_type (java_boolean_type);

                  write_exp_elt_type (java_boolean_type);

                  write_exp_elt_longcst ((LONGEST)$1);

                  write_exp_elt_longcst ((LONGEST)$1);

                  write_exp_elt_opcode (OP_LONG); }

                  write_exp_elt_opcode (OP_LONG); }

|       StringLiteral

|       StringLiteral

        ;

        ;

/* UNUSED:

/* UNUSED:

Type:

Type:

        PrimitiveType

        PrimitiveType

|       ReferenceType

|       ReferenceType

;

;

*/

*/

PrimitiveType:

PrimitiveType:

        NumericType

        NumericType

|       BOOLEAN

|       BOOLEAN

                { $$ = java_boolean_type; }

                { $$ = java_boolean_type; }

;

;

NumericType:

NumericType:

        IntegralType

        IntegralType

|       FloatingPointType

|       FloatingPointType

;

;

IntegralType:

IntegralType:

        BYTE

        BYTE

                { $$ = java_byte_type; }

                { $$ = java_byte_type; }

|       SHORT

|       SHORT

                { $$ = java_short_type; }

                { $$ = java_short_type; }

|       INT

|       INT

                { $$ = java_int_type; }

                { $$ = java_int_type; }

|       LONG

|       LONG

                { $$ = java_long_type; }

                { $$ = java_long_type; }

|       CHAR

|       CHAR

                { $$ = java_char_type; }

                { $$ = java_char_type; }

;

;

FloatingPointType:

FloatingPointType:

        FLOAT

        FLOAT

                { $$ = java_float_type; }

                { $$ = java_float_type; }

|       DOUBLE

|       DOUBLE

                { $$ = java_double_type; }

                { $$ = java_double_type; }

;

;

/* UNUSED:

/* UNUSED:

ReferenceType:

ReferenceType:

        ClassOrInterfaceType

        ClassOrInterfaceType

|       ArrayType

|       ArrayType

;

;

*/

*/

ClassOrInterfaceType:

ClassOrInterfaceType:

        Name

        Name

                { $$ = java_type_from_name ($1); }

                { $$ = java_type_from_name ($1); }

;

;

ClassType:

ClassType:

        ClassOrInterfaceType

        ClassOrInterfaceType

;

;

ArrayType:

ArrayType:

        PrimitiveType Dims

        PrimitiveType Dims

                { $$ = java_array_type ($1, $2); }

                { $$ = java_array_type ($1, $2); }

|       Name Dims

|       Name Dims

                { $$ = java_array_type (java_type_from_name ($1), $2); }

                { $$ = java_array_type (java_type_from_name ($1), $2); }

;

;

Name:

Name:

        IDENTIFIER

        IDENTIFIER

|       QualifiedName

|       QualifiedName

;

;

ForcedName:

ForcedName:

        SimpleName

        SimpleName

|       QualifiedName

|       QualifiedName

;

;

SimpleName:

SimpleName:

        IDENTIFIER

        IDENTIFIER

|       NAME_OR_INT

|       NAME_OR_INT

;

;

QualifiedName:

QualifiedName:

        Name '.' SimpleName

        Name '.' SimpleName

                { $$.length = $1.length + $3.length + 1;

                { $$.length = $1.length + $3.length + 1;

                  if ($1.ptr + $1.length + 1 == $3.ptr

                  if ($1.ptr + $1.length + 1 == $3.ptr

                      && $1.ptr[$1.length] == '.')

                      && $1.ptr[$1.length] == '.')

                    $$.ptr = $1.ptr;  /* Optimization. */

                    $$.ptr = $1.ptr;  /* Optimization. */

                  else

                  else

                    {

                    {

                      $$.ptr = (char *) malloc ($$.length + 1);

                      $$.ptr = (char *) malloc ($$.length + 1);

                      make_cleanup (free, $$.ptr);

                      make_cleanup (free, $$.ptr);

                      sprintf ($$.ptr, "%.*s.%.*s",

                      sprintf ($$.ptr, "%.*s.%.*s",

                               $1.length, $1.ptr, $3.length, $3.ptr);

                               $1.length, $1.ptr, $3.length, $3.ptr);

                } }

                } }

;

;

/*

/*

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);}

        ;

        ;

        */

        */

/* Expressions, including the comma operator.  */

/* Expressions, including the comma operator.  */

exp1    :       Expression

exp1    :       Expression

        |       exp1 ',' Expression

        |       exp1 ',' Expression

                        { write_exp_elt_opcode (BINOP_COMMA); }

                        { write_exp_elt_opcode (BINOP_COMMA); }

        ;

        ;

Primary:

Primary:

        PrimaryNoNewArray

        PrimaryNoNewArray

|       ArrayCreationExpression

|       ArrayCreationExpression

;

;

PrimaryNoNewArray:

PrimaryNoNewArray:

        Literal

        Literal

|       THIS

|       THIS

                { write_exp_elt_opcode (OP_THIS);

                { write_exp_elt_opcode (OP_THIS);

                  write_exp_elt_opcode (OP_THIS); }

                  write_exp_elt_opcode (OP_THIS); }

|       '(' Expression ')'

|       '(' Expression ')'

|       ClassInstanceCreationExpression

|       ClassInstanceCreationExpression

|       FieldAccess

|       FieldAccess

|       MethodInvocation

|       MethodInvocation

|       ArrayAccess

|       ArrayAccess

|       lcurly ArgumentList rcurly

|       lcurly ArgumentList rcurly

                { write_exp_elt_opcode (OP_ARRAY);

                { write_exp_elt_opcode (OP_ARRAY);

                  write_exp_elt_longcst ((LONGEST) 0);

                  write_exp_elt_longcst ((LONGEST) 0);

                  write_exp_elt_longcst ((LONGEST) $3);

                  write_exp_elt_longcst ((LONGEST) $3);

                  write_exp_elt_opcode (OP_ARRAY); }

                  write_exp_elt_opcode (OP_ARRAY); }

;

;

lcurly:

lcurly:

        '{'

        '{'

                { start_arglist (); }

                { start_arglist (); }

;

;

rcurly:

rcurly:

        '}'

        '}'

                { $$ = end_arglist () - 1; }

                { $$ = end_arglist () - 1; }

;

;

ClassInstanceCreationExpression:

ClassInstanceCreationExpression:

        NEW ClassType '(' ArgumentList_opt ')'

        NEW ClassType '(' ArgumentList_opt ')'

                { error ("FIXME - ClassInstanceCreationExpression"); }

                { error ("FIXME - ClassInstanceCreationExpression"); }

;

;

ArgumentList:

ArgumentList:

        Expression

        Expression

                { arglist_len = 1; }

                { arglist_len = 1; }

|       ArgumentList ',' Expression

|       ArgumentList ',' Expression

                { arglist_len++; }

                { arglist_len++; }

;

;

ArgumentList_opt:

ArgumentList_opt:

        /* EMPTY */

        /* EMPTY */

                { arglist_len = 0; }

                { arglist_len = 0; }

| ArgumentList

| ArgumentList

;

;

ArrayCreationExpression:

ArrayCreationExpression:

        NEW PrimitiveType DimExprs Dims_opt

        NEW PrimitiveType DimExprs Dims_opt

                { error ("FIXME - ArrayCreatiionExpression"); }

                { error ("FIXME - ArrayCreatiionExpression"); }

|       NEW ClassOrInterfaceType DimExprs Dims_opt

|       NEW ClassOrInterfaceType DimExprs Dims_opt

                { error ("FIXME - ArrayCreatiionExpression"); }

                { error ("FIXME - ArrayCreatiionExpression"); }

;

;

DimExprs:

DimExprs:

        DimExpr

        DimExpr

|       DimExprs DimExpr

|       DimExprs DimExpr

;

;

DimExpr:

DimExpr:

        '[' Expression ']'

        '[' Expression ']'

;

;

Dims:

Dims:

        '[' ']'

        '[' ']'

                { $$ = 1; }

                { $$ = 1; }

|       Dims '[' ']'

|       Dims '[' ']'

        { $$ = $1 + 1; }

        { $$ = $1 + 1; }

;

;

Dims_opt:

Dims_opt:

        Dims

        Dims

|       /* EMPTY */

|       /* EMPTY */

                { $$ = 0; }

                { $$ = 0; }

;

;

FieldAccess:

FieldAccess:

        Primary '.' SimpleName

        Primary '.' SimpleName

                { push_fieldnames ($3); }

                { push_fieldnames ($3); }

|       VARIABLE '.' SimpleName

|       VARIABLE '.' SimpleName

                { push_fieldnames ($3); }

                { push_fieldnames ($3); }

/*|     SUPER '.' SimpleName { FIXME } */

/*|     SUPER '.' SimpleName { FIXME } */

;

;

MethodInvocation:

MethodInvocation:

        Name '(' ArgumentList_opt ')'

        Name '(' ArgumentList_opt ')'

                { error ("method invocation not implemented"); }

                { error ("method invocation not implemented"); }

|       Primary '.' SimpleName '(' ArgumentList_opt ')'

|       Primary '.' SimpleName '(' ArgumentList_opt ')'

                { error ("method invocation not implemented"); }

                { error ("method invocation not implemented"); }

|       SUPER '.' SimpleName '(' ArgumentList_opt ')'

|       SUPER '.' SimpleName '(' ArgumentList_opt ')'

                { error ("method invocation not implemented"); }

                { error ("method invocation not implemented"); }

;

;

ArrayAccess:

ArrayAccess:

        Name '[' Expression ']'

        Name '[' Expression ']'

                {

                {

                  /* Emit code for the Name now, then exchange it in the

                  /* Emit code for the Name now, then exchange it in the

                     expout array with the Expression's code.  We could

                     expout array with the Expression's code.  We could

                     introduce a OP_SWAP code or a reversed version of

                     introduce a OP_SWAP code or a reversed version of

                     BINOP_SUBSCRIPT, but that makes the rest of GDB pay

                     BINOP_SUBSCRIPT, but that makes the rest of GDB pay

                     for our parsing kludges.  */

                     for our parsing kludges.  */

                  struct expression *name_expr;

                  struct expression *name_expr;

                  push_expression_name ($1);

                  push_expression_name ($1);

                  name_expr = copy_exp (expout, expout_ptr);

                  name_expr = copy_exp (expout, expout_ptr);

                  expout_ptr -= name_expr->nelts;

                  expout_ptr -= name_expr->nelts;

                  insert_exp (expout_ptr-length_of_subexp (expout, expout_ptr),

                  insert_exp (expout_ptr-length_of_subexp (expout, expout_ptr),

                              name_expr);

                              name_expr);

                  free (name_expr);

                  free (name_expr);

                  write_exp_elt_opcode (BINOP_SUBSCRIPT);

                  write_exp_elt_opcode (BINOP_SUBSCRIPT);

                }

                }

|       VARIABLE '[' Expression ']'

|       VARIABLE '[' Expression ']'

                { write_exp_elt_opcode (BINOP_SUBSCRIPT); }

                { write_exp_elt_opcode (BINOP_SUBSCRIPT); }

|       PrimaryNoNewArray '[' Expression ']'

|       PrimaryNoNewArray '[' Expression ']'

                { write_exp_elt_opcode (BINOP_SUBSCRIPT); }

                { write_exp_elt_opcode (BINOP_SUBSCRIPT); }

;

;

PostfixExpression:

PostfixExpression:

        Primary

        Primary

|       Name

|       Name

                { push_expression_name ($1); }

                { push_expression_name ($1); }

|       VARIABLE

|       VARIABLE

                /* Already written by write_dollar_variable. */

                /* Already written by write_dollar_variable. */

|       PostIncrementExpression

|       PostIncrementExpression

|       PostDecrementExpression

|       PostDecrementExpression

;

;

PostIncrementExpression:

PostIncrementExpression:

        PostfixExpression INCREMENT

        PostfixExpression INCREMENT

                { write_exp_elt_opcode (UNOP_POSTINCREMENT); }

                { write_exp_elt_opcode (UNOP_POSTINCREMENT); }

;

;

PostDecrementExpression:

PostDecrementExpression:

        PostfixExpression DECREMENT

        PostfixExpression DECREMENT

                { write_exp_elt_opcode (UNOP_POSTDECREMENT); }

                { write_exp_elt_opcode (UNOP_POSTDECREMENT); }

;

;

UnaryExpression:

UnaryExpression:

        PreIncrementExpression

        PreIncrementExpression

|       PreDecrementExpression

|       PreDecrementExpression

|       '+' UnaryExpression

|       '+' UnaryExpression

|       '-' UnaryExpression

|       '-' UnaryExpression

                { write_exp_elt_opcode (UNOP_NEG); }

                { write_exp_elt_opcode (UNOP_NEG); }

|       '*' UnaryExpression

|       '*' UnaryExpression

                { write_exp_elt_opcode (UNOP_IND); } /*FIXME not in Java  */

                { write_exp_elt_opcode (UNOP_IND); } /*FIXME not in Java  */

|       UnaryExpressionNotPlusMinus

|       UnaryExpressionNotPlusMinus

;

;

PreIncrementExpression:

PreIncrementExpression:

        INCREMENT UnaryExpression

        INCREMENT UnaryExpression

                { write_exp_elt_opcode (UNOP_PREINCREMENT); }

                { write_exp_elt_opcode (UNOP_PREINCREMENT); }

;

;

PreDecrementExpression:

PreDecrementExpression:

        DECREMENT UnaryExpression

        DECREMENT UnaryExpression

                { write_exp_elt_opcode (UNOP_PREDECREMENT); }

                { write_exp_elt_opcode (UNOP_PREDECREMENT); }

;

;

UnaryExpressionNotPlusMinus:

UnaryExpressionNotPlusMinus:

        PostfixExpression

        PostfixExpression

|       '~' UnaryExpression

|       '~' UnaryExpression

                { write_exp_elt_opcode (UNOP_COMPLEMENT); }

                { write_exp_elt_opcode (UNOP_COMPLEMENT); }

|       '!' UnaryExpression

|       '!' UnaryExpression

                { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }

                { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }

|       CastExpression

|       CastExpression

        ;

        ;

CastExpression:

CastExpression:

        '(' PrimitiveType Dims_opt ')' UnaryExpression

        '(' PrimitiveType Dims_opt ')' UnaryExpression

                { write_exp_elt_opcode (UNOP_CAST);

                { write_exp_elt_opcode (UNOP_CAST);

                  write_exp_elt_type (java_array_type ($2, $3));

                  write_exp_elt_type (java_array_type ($2, $3));

                  write_exp_elt_opcode (UNOP_CAST); }

                  write_exp_elt_opcode (UNOP_CAST); }

|       '(' Expression ')' UnaryExpressionNotPlusMinus

|       '(' Expression ')' UnaryExpressionNotPlusMinus

                {

                {

                  int exp_size = expout_ptr;

                  int exp_size = expout_ptr;

                  int last_exp_size = length_of_subexp(expout, expout_ptr);

                  int last_exp_size = length_of_subexp(expout, expout_ptr);

                  struct type *type;

                  struct type *type;

                  int i;

                  int i;

                  int base = expout_ptr - last_exp_size - 3;

                  int base = expout_ptr - last_exp_size - 3;

                  if (base < 0 || expout->elts[base+2].opcode != OP_TYPE)

                  if (base < 0 || expout->elts[base+2].opcode != OP_TYPE)

                    error ("invalid cast expression");

                    error ("invalid cast expression");

                  type = expout->elts[base+1].type;

                  type = expout->elts[base+1].type;

                  /* Remove the 'Expression' and slide the

                  /* Remove the 'Expression' and slide the

                     UnaryExpressionNotPlusMinus down to replace it. */

                     UnaryExpressionNotPlusMinus down to replace it. */

                  for (i = 0;  i < last_exp_size;  i++)

                  for (i = 0;  i < last_exp_size;  i++)

                    expout->elts[base + i] = expout->elts[base + i + 3];

                    expout->elts[base + i] = expout->elts[base + i + 3];

                  expout_ptr -= 3;

                  expout_ptr -= 3;

                  if (TYPE_CODE (type) == TYPE_CODE_STRUCT)

                  if (TYPE_CODE (type) == TYPE_CODE_STRUCT)

                    type = lookup_pointer_type (type);

                    type = lookup_pointer_type (type);

                  write_exp_elt_opcode (UNOP_CAST);

                  write_exp_elt_opcode (UNOP_CAST);

                  write_exp_elt_type (type);

                  write_exp_elt_type (type);

                  write_exp_elt_opcode (UNOP_CAST);

                  write_exp_elt_opcode (UNOP_CAST);

                }

                }

|       '(' Name Dims ')' UnaryExpressionNotPlusMinus

|       '(' Name Dims ')' UnaryExpressionNotPlusMinus

                { write_exp_elt_opcode (UNOP_CAST);

                { write_exp_elt_opcode (UNOP_CAST);

                  write_exp_elt_type (java_array_type (java_type_from_name ($2), $3));

                  write_exp_elt_type (java_array_type (java_type_from_name ($2), $3));

                  write_exp_elt_opcode (UNOP_CAST); }

                  write_exp_elt_opcode (UNOP_CAST); }

;

;

MultiplicativeExpression:

MultiplicativeExpression:

        UnaryExpression

        UnaryExpression

|       MultiplicativeExpression '*' UnaryExpression

|       MultiplicativeExpression '*' UnaryExpression

                { write_exp_elt_opcode (BINOP_MUL); }

                { write_exp_elt_opcode (BINOP_MUL); }

|       MultiplicativeExpression '/' UnaryExpression

|       MultiplicativeExpression '/' UnaryExpression

                { write_exp_elt_opcode (BINOP_DIV); }

                { write_exp_elt_opcode (BINOP_DIV); }

|       MultiplicativeExpression '%' UnaryExpression

|       MultiplicativeExpression '%' UnaryExpression

                { write_exp_elt_opcode (BINOP_REM); }

                { write_exp_elt_opcode (BINOP_REM); }

;

;

AdditiveExpression:

AdditiveExpression:

        MultiplicativeExpression

        MultiplicativeExpression

|       AdditiveExpression '+' MultiplicativeExpression

|       AdditiveExpression '+' MultiplicativeExpression

                { write_exp_elt_opcode (BINOP_ADD); }

                { write_exp_elt_opcode (BINOP_ADD); }

|       AdditiveExpression '-' MultiplicativeExpression

|       AdditiveExpression '-' MultiplicativeExpression

                { write_exp_elt_opcode (BINOP_SUB); }

                { write_exp_elt_opcode (BINOP_SUB); }

;

;

ShiftExpression:

ShiftExpression:

        AdditiveExpression

        AdditiveExpression

|       ShiftExpression LSH AdditiveExpression

|       ShiftExpression LSH AdditiveExpression

                { write_exp_elt_opcode (BINOP_LSH); }

                { write_exp_elt_opcode (BINOP_LSH); }

|       ShiftExpression RSH AdditiveExpression

|       ShiftExpression RSH AdditiveExpression

                { write_exp_elt_opcode (BINOP_RSH); }

                { write_exp_elt_opcode (BINOP_RSH); }

/* |    ShiftExpression >>> AdditiveExpression { FIXME } */

/* |    ShiftExpression >>> AdditiveExpression { FIXME } */

;

;

RelationalExpression:

RelationalExpression:

        ShiftExpression

        ShiftExpression

|       RelationalExpression '<' ShiftExpression

|       RelationalExpression '<' ShiftExpression

                { write_exp_elt_opcode (BINOP_LESS); }

                { write_exp_elt_opcode (BINOP_LESS); }

|       RelationalExpression '>' ShiftExpression

|       RelationalExpression '>' ShiftExpression

                { write_exp_elt_opcode (BINOP_GTR); }

                { write_exp_elt_opcode (BINOP_GTR); }

|       RelationalExpression LEQ ShiftExpression

|       RelationalExpression LEQ ShiftExpression

                { write_exp_elt_opcode (BINOP_LEQ); }

                { write_exp_elt_opcode (BINOP_LEQ); }

|       RelationalExpression GEQ ShiftExpression

|       RelationalExpression GEQ ShiftExpression

                { write_exp_elt_opcode (BINOP_GEQ); }

                { write_exp_elt_opcode (BINOP_GEQ); }

/* | RelationalExpresion INSTANCEOF ReferenceType { FIXME } */

/* | RelationalExpresion INSTANCEOF ReferenceType { FIXME } */

;

;

EqualityExpression:

EqualityExpression:

        RelationalExpression

        RelationalExpression

|       EqualityExpression EQUAL RelationalExpression

|       EqualityExpression EQUAL RelationalExpression

                { write_exp_elt_opcode (BINOP_EQUAL); }

                { write_exp_elt_opcode (BINOP_EQUAL); }

|       EqualityExpression NOTEQUAL RelationalExpression

|       EqualityExpression NOTEQUAL RelationalExpression

                { write_exp_elt_opcode (BINOP_NOTEQUAL); }

                { write_exp_elt_opcode (BINOP_NOTEQUAL); }

;

;

AndExpression:

AndExpression:

        EqualityExpression

        EqualityExpression

|       AndExpression '&' EqualityExpression

|       AndExpression '&' EqualityExpression

                { write_exp_elt_opcode (BINOP_BITWISE_AND); }

                { write_exp_elt_opcode (BINOP_BITWISE_AND); }

;

;

ExclusiveOrExpression:

ExclusiveOrExpression:

        AndExpression

        AndExpression

|       ExclusiveOrExpression '^' AndExpression

|       ExclusiveOrExpression '^' AndExpression

                { write_exp_elt_opcode (BINOP_BITWISE_XOR); }

                { write_exp_elt_opcode (BINOP_BITWISE_XOR); }

;

;

InclusiveOrExpression:

InclusiveOrExpression:

        ExclusiveOrExpression

        ExclusiveOrExpression

|       InclusiveOrExpression '|' ExclusiveOrExpression

|       InclusiveOrExpression '|' ExclusiveOrExpression

                { write_exp_elt_opcode (BINOP_BITWISE_IOR); }

                { write_exp_elt_opcode (BINOP_BITWISE_IOR); }

;

;

ConditionalAndExpression:

ConditionalAndExpression:

        InclusiveOrExpression

        InclusiveOrExpression

|       ConditionalAndExpression ANDAND InclusiveOrExpression

|       ConditionalAndExpression ANDAND InclusiveOrExpression

                { write_exp_elt_opcode (BINOP_LOGICAL_AND); }

                { write_exp_elt_opcode (BINOP_LOGICAL_AND); }

;

;

ConditionalOrExpression:

ConditionalOrExpression:

        ConditionalAndExpression

        ConditionalAndExpression

|       ConditionalOrExpression OROR ConditionalAndExpression

|       ConditionalOrExpression OROR ConditionalAndExpression

                { write_exp_elt_opcode (BINOP_LOGICAL_OR); }

                { write_exp_elt_opcode (BINOP_LOGICAL_OR); }

;

;

ConditionalExpression:

ConditionalExpression:

        ConditionalOrExpression

        ConditionalOrExpression

|       ConditionalOrExpression '?' Expression ':' ConditionalExpression

|       ConditionalOrExpression '?' Expression ':' ConditionalExpression

                { write_exp_elt_opcode (TERNOP_COND); }

                { write_exp_elt_opcode (TERNOP_COND); }

;

;

AssignmentExpression:

AssignmentExpression:

        ConditionalExpression

        ConditionalExpression

|       Assignment

|       Assignment

;

;

Assignment:

Assignment:

        LeftHandSide '=' ConditionalExpression

        LeftHandSide '=' ConditionalExpression

                { write_exp_elt_opcode (BINOP_ASSIGN); }

                { write_exp_elt_opcode (BINOP_ASSIGN); }

|       LeftHandSide ASSIGN_MODIFY ConditionalExpression

|       LeftHandSide ASSIGN_MODIFY ConditionalExpression

                { 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); }

;

;

LeftHandSide:

LeftHandSide:

        ForcedName

        ForcedName

                { push_expression_name ($1); }

                { push_expression_name ($1); }

|       VARIABLE

|       VARIABLE

                /* Already written by write_dollar_variable. */

                /* Already written by write_dollar_variable. */

|       FieldAccess

|       FieldAccess

|       ArrayAccess

|       ArrayAccess

;

;

Expression:

Expression:

        AssignmentExpression

        AssignmentExpression

;

;

%%

%%

/* 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 ULONGEST n = 0;

  register ULONGEST n = 0;

  ULONGEST limit, limit_div_base;

  ULONGEST limit, limit_div_base;

  register int c;

  register int c;

  register int base = input_radix;

  register int base = input_radix;

  struct type *type;

  struct type *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.  */

      char c;

      char c;

      int num = 0;      /* number of tokens scanned by scanf */

      int num = 0;      /* number of tokens scanned by scanf */

      char saved_char = p[len];

      char saved_char = p[len];

      p[len] = 0;       /* null-terminate the token */

      p[len] = 0;       /* null-terminate the token */

      if (sizeof (putithere->typed_val_float.dval) <= sizeof (float))

      if (sizeof (putithere->typed_val_float.dval) <= sizeof (float))

        num = sscanf (p, "%g%c", (float *) &putithere->typed_val_float.dval, &c);

        num = sscanf (p, "%g%c", (float *) &putithere->typed_val_float.dval, &c);

      else if (sizeof (putithere->typed_val_float.dval) <= sizeof (double))

      else if (sizeof (putithere->typed_val_float.dval) <= sizeof (double))

        num = sscanf (p, "%lg%c", (double *) &putithere->typed_val_float.dval, &c);

        num = sscanf (p, "%lg%c", (double *) &putithere->typed_val_float.dval, &c);

      else

      else

        {

        {

#ifdef SCANF_HAS_LONG_DOUBLE

#ifdef SCANF_HAS_LONG_DOUBLE

          num = sscanf (p, "%Lg%c", &putithere->typed_val_float.dval, &c);

          num = sscanf (p, "%Lg%c", &putithere->typed_val_float.dval, &c);

#else

#else

          /* Scan it into a double, then assign it to the long double.

          /* Scan it into a double, then assign it to the long double.

             This at least wins with values representable in the range

             This at least wins with values representable in the range

             of doubles. */

             of doubles. */

          double temp;

          double temp;

          num = sscanf (p, "%lg%c", &temp, &c);

          num = sscanf (p, "%lg%c", &temp, &c);

          putithere->typed_val_float.dval = temp;

          putithere->typed_val_float.dval = temp;

#endif

#endif

        }

        }

      p[len] = saved_char;      /* restore the input stream */

      p[len] = saved_char;      /* restore the input stream */

      if (num != 1)             /* check scanf found ONLY a float ... */

      if (num != 1)             /* check scanf found ONLY a float ... */

        return ERROR;

        return ERROR;

      /* See if it has `f' or `d' suffix (float or double).  */

      /* See if it has `f' or `d' suffix (float or double).  */

      c = tolower (p[len - 1]);

      c = tolower (p[len - 1]);

      if (c == 'f' || c == 'F')

      if (c == 'f' || c == 'F')

        putithere->typed_val_float.type = builtin_type_float;

        putithere->typed_val_float.type = builtin_type_float;

      else if (isdigit (c) || c == '.' || c == 'd' || c == 'D')

      else if (isdigit (c) || c == '.' || c == 'd' || c == 'D')

        putithere->typed_val_float.type = builtin_type_double;

        putithere->typed_val_float.type = builtin_type_double;

      else

      else

        return ERROR;

        return ERROR;

      return FLOATING_POINT_LITERAL;

      return FLOATING_POINT_LITERAL;

    }

    }

  /* 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;

      }

      }

  c = p[len-1];

  c = p[len-1];

  limit = (ULONGEST)0xffffffff;

  limit = (ULONGEST)0xffffffff;

  if (c == 'l' || c == 'L')

  if (c == 'l' || c == 'L')

    {

    {

      type = java_long_type;

      type = java_long_type;

      len--;

      len--;

      /* A paranoid calculation of (1<<64)-1. */

      /* A paranoid calculation of (1<<64)-1. */

      limit = ((limit << 16) << 16) | limit;

      limit = ((limit << 16) << 16) | limit;

    }

    }

  else

  else

    {

    {

      type = java_int_type;

      type = java_int_type;

    }

    }

  limit_div_base = limit / (ULONGEST) base;

  limit_div_base = limit / (ULONGEST) base;

  while (--len >= 0)

  while (--len >= 0)

    {

    {

      c = *p++;

      c = *p++;

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

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

        c -= '0';

        c -= '0';

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

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

        c -= 'A' - 10;

        c -= 'A' - 10;

      else if (c >= 'a' && c <= 'z')

      else if (c >= 'a' && c <= 'z')

        c -= 'a' - 10;

        c -= 'a' - 10;

      else

      else

        return ERROR;   /* Char not a digit */

        return ERROR;   /* Char not a digit */

      if (c >= base)

      if (c >= base)

        return ERROR;

        return ERROR;

      if (n > limit_div_base

      if (n > limit_div_base

          || (n *= base) > limit - c)

          || (n *= base) > limit - c)

        error ("Numeric constant too large.");

        error ("Numeric constant too large.");

      n += c;

      n += c;

        }

        }

   putithere->typed_val_int.val = n;

   putithere->typed_val_int.val = n;

   putithere->typed_val_int.type = type;

   putithere->typed_val_int.type = type;

   return INTEGER_LITERAL;

   return INTEGER_LITERAL;

}

}

struct token

struct token

{

{

  char *operator;

  char *operator;

  int token;

  int token;

  enum exp_opcode opcode;

  enum exp_opcode opcode;

};

};

static const struct token tokentab3[] =

static const struct token tokentab3[] =

  {

  {

    {">>=", ASSIGN_MODIFY, BINOP_RSH},

    {">>=", ASSIGN_MODIFY, BINOP_RSH},

    {"<<=", ASSIGN_MODIFY, BINOP_LSH}

    {"<<=", ASSIGN_MODIFY, BINOP_LSH}

  };

  };

static const struct token tokentab2[] =

static const struct token tokentab2[] =

  {

  {

    {"+=", ASSIGN_MODIFY, BINOP_ADD},

    {"+=", ASSIGN_MODIFY, BINOP_ADD},

    {"-=", ASSIGN_MODIFY, BINOP_SUB},

    {"-=", ASSIGN_MODIFY, BINOP_SUB},

    {"*=", ASSIGN_MODIFY, BINOP_MUL},

    {"*=", ASSIGN_MODIFY, BINOP_MUL},

    {"/=", ASSIGN_MODIFY, BINOP_DIV},

    {"/=", ASSIGN_MODIFY, BINOP_DIV},

    {"%=", ASSIGN_MODIFY, BINOP_REM},

    {"%=", ASSIGN_MODIFY, BINOP_REM},

    {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},

    {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},

    {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},

    {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},

    {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},

    {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},

    {"++", INCREMENT, BINOP_END},

    {"++", INCREMENT, BINOP_END},

    {"--", DECREMENT, BINOP_END},

    {"--", DECREMENT, BINOP_END},

    {"&&", ANDAND, BINOP_END},

    {"&&", ANDAND, BINOP_END},

    {"||", OROR, BINOP_END},

    {"||", OROR, BINOP_END},

    {"<<", LSH, BINOP_END},

    {"<<", LSH, BINOP_END},

    {">>", RSH, BINOP_END},

    {">>", RSH, BINOP_END},

    {"==", EQUAL, BINOP_END},

    {"==", EQUAL, BINOP_END},

    {"!=", NOTEQUAL, BINOP_END},

    {"!=", NOTEQUAL, BINOP_END},

    {"<=", LEQ, BINOP_END},

    {"<=", LEQ, BINOP_END},

    {">=", GEQ, BINOP_END}

    {">=", GEQ, BINOP_END}

  };

  };

/* 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;

  unsigned int i;

  char *tokstart;

  char *tokstart;

  char *tokptr;

  char *tokptr;

  int tempbufindex;

  int tempbufindex;

  static char *tempbuf;

  static char *tempbuf;

  static int tempbufsize;

  static int tempbufsize;

 retry:

 retry:

  tokstart = lexptr;

  tokstart = lexptr;

  /* See if it is a special token of length 3.  */

  /* See if it is a special token of length 3.  */

  for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)

  for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)

    if (STREQN (tokstart, tokentab3[i].operator, 3))

    if (STREQN (tokstart, tokentab3[i].operator, 3))

      {

      {

        lexptr += 3;

        lexptr += 3;

        yylval.opcode = tokentab3[i].opcode;

        yylval.opcode = tokentab3[i].opcode;

        return tokentab3[i].token;

        return tokentab3[i].token;

      }

      }

  /* See if it is a special token of length 2.  */

  /* See if it is a special token of length 2.  */

  for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)

  for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)

    if (STREQN (tokstart, tokentab2[i].operator, 2))

    if (STREQN (tokstart, tokentab2[i].operator, 2))

      {

      {

        lexptr += 2;

        lexptr += 2;

        yylval.opcode = tokentab2[i].opcode;

        yylval.opcode = tokentab2[i].opcode;

        return tokentab2[i].token;

        return tokentab2[i].token;

      }

      }

  switch (c = *tokstart)

  switch (c = *tokstart)

    {

    {

    case 0:

    case 0:

      return 0;

      return 0;

    case ' ':

    case ' ':

    case '\t':

    case '\t':

    case '\n':

    case '\n':

      lexptr++;

      lexptr++;

      goto retry;

      goto retry;

    case '\'':

    case '\'':

      /* We either have a character constant ('0' or '\177' for example)

      /* We either have a character constant ('0' or '\177' for example)

         or we have a quoted symbol reference ('foo(int,int)' in C++

         or we have a quoted symbol reference ('foo(int,int)' in C++

         for example). */

         for example). */

      lexptr++;

      lexptr++;

      c = *lexptr++;

      c = *lexptr++;

      if (c == '\\')

      if (c == '\\')

        c = parse_escape (&lexptr);

        c = parse_escape (&lexptr);

      else if (c == '\'')

      else if (c == '\'')

        error ("Empty character constant.");

        error ("Empty character constant.");

      yylval.typed_val_int.val = c;

      yylval.typed_val_int.val = c;

      yylval.typed_val_int.type = java_char_type;

      yylval.typed_val_int.type = java_char_type;

      c = *lexptr++;

      c = *lexptr++;

      if (c != '\'')

      if (c != '\'')

        {

        {

          namelen = skip_quoted (tokstart) - tokstart;

          namelen = skip_quoted (tokstart) - tokstart;

          if (namelen > 2)

          if (namelen > 2)

            {

            {

              lexptr = tokstart + namelen;

              lexptr = tokstart + namelen;

              if (lexptr[-1] != '\'')

              if (lexptr[-1] != '\'')

                error ("Unmatched single quote.");

                error ("Unmatched single quote.");

              namelen -= 2;

              namelen -= 2;

              tokstart++;

              tokstart++;

              goto tryname;

              goto tryname;

            }

            }

          error ("Invalid character constant.");

          error ("Invalid character constant.");

        }

        }

      return INTEGER_LITERAL;

      return INTEGER_LITERAL;

    case '(':

    case '(':

      paren_depth++;

      paren_depth++;

      lexptr++;

      lexptr++;

      return c;

      return c;

    case ')':

    case ')':

      if (paren_depth == 0)

      if (paren_depth == 0)

        return 0;

        return 0;

      paren_depth--;

      paren_depth--;

      lexptr++;

      lexptr++;

      return c;

      return c;

    case ',':

    case ',':

      if (comma_terminates && paren_depth == 0)

      if (comma_terminates && paren_depth == 0)

        return 0;

        return 0;

      lexptr++;