gdb/p-exp.c - Issue 124383005: GDB 7.6.50

Unified Diff: gdb/p-exp.c

Issue 124383005: GDB 7.6.50 (Closed) Base URL: http://git.chromium.org/native_client/nacl-gdb.git@upstream

Patch Set: Created 6 years, 11 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: gdb/p-exp.c

diff --git a/gdb/p-exp.c b/gdb/p-exp.c

deleted file mode 100644

index 974370e4a2ee297e52062ca4bcfd19b995892d72..0000000000000000000000000000000000000000

--- a/gdb/p-exp.c

+++ /dev/null

@@ -1,3107 +0,0 @@

-/* A Bison parser, made by GNU Bison 1.875c. */

-/* Skeleton parser for Yacc-like parsing with Bison,

- 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

- the Free Software Foundation; either version 2, or (at your option)

- any later version.

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

- but WITHOUT ANY WARRANTY; without even the implied warranty of

- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

- GNU General Public License for more details.

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

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

- Foundation, Inc., 59 Temple Place - Suite 330,

- Boston, MA 02111-1307, USA. */

-/* As a special exception, when this file is copied by Bison into a

- Bison output file, you may use that output file without restriction.

- This special exception was added by the Free Software Foundation

- in version 1.24 of Bison. */

-/* Written by Richard Stallman by simplifying the original so called

- ``semantic'' parser. */

-/* All symbols defined below should begin with yy or YY, to avoid

- infringing on user name space. This should be done even for local

- variables, as they might otherwise be expanded by user macros.

- There are some unavoidable exceptions within include files to

- define necessary library symbols; they are noted "INFRINGES ON

- USER NAME SPACE" below. */

-/* Identify Bison output. */

-#define YYBISON 1

-/* Skeleton name. */

-#define YYSKELETON_NAME "yacc.c"

-/* Pure parsers. */

-#define YYPURE 0

-/* Using locations. */

-#define YYLSP_NEEDED 0

-/* Tokens. */

-#ifndef YYTOKENTYPE

-# define YYTOKENTYPE

- /* Put the tokens into the symbol table, so that GDB and other debuggers

- know about them. */

- enum yytokentype {

- INT = 258,

- FLOAT = 259,

- STRING = 260,

- FIELDNAME = 261,

- COMPLETE = 262,

- NAME = 263,

- TYPENAME = 264,

- NAME_OR_INT = 265,

- STRUCT = 266,

- CLASS = 267,

- SIZEOF = 268,

- COLONCOLON = 269,

- ERROR = 270,

- VARIABLE = 271,

- THIS = 272,

- TRUEKEYWORD = 273,

- FALSEKEYWORD = 274,

- ABOVE_COMMA = 275,

- ASSIGN = 276,

- NOT = 277,

- OR = 278,

- XOR = 279,

- ANDAND = 280,

- NOTEQUAL = 281,

- GEQ = 282,

- LEQ = 283,

- MOD = 284,

- DIV = 285,

- RSH = 286,

- LSH = 287,

- DECREMENT = 288,

- INCREMENT = 289,

- UNARY = 290,

- ARROW = 291,

- BLOCKNAME = 292

- };

-#endif

-#define INT 258

-#define FLOAT 259

-#define STRING 260

-#define FIELDNAME 261

-#define COMPLETE 262

-#define NAME 263

-#define TYPENAME 264

-#define NAME_OR_INT 265

-#define STRUCT 266

-#define CLASS 267

-#define SIZEOF 268

-#define COLONCOLON 269

-#define ERROR 270

-#define VARIABLE 271

-#define THIS 272

-#define TRUEKEYWORD 273

-#define FALSEKEYWORD 274

-#define ABOVE_COMMA 275

-#define ASSIGN 276

-#define NOT 277

-#define OR 278

-#define XOR 279

-#define ANDAND 280

-#define NOTEQUAL 281

-#define GEQ 282

-#define LEQ 283

-#define MOD 284

-#define DIV 285

-#define RSH 286

-#define LSH 287

-#define DECREMENT 288

-#define INCREMENT 289

-#define UNARY 290

-#define ARROW 291

-#define BLOCKNAME 292

-/* Copy the first part of user declarations. */

-#line 44 "p-exp.y"

-#include "defs.h"

-#include "gdb_string.h"

-#include <ctype.h>

-#include "expression.h"

-#include "value.h"

-#include "parser-defs.h"

-#include "language.h"

-#include "p-lang.h"

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

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

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

-#include "block.h"

-#define parse_type builtin_type (parse_gdbarch)

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

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

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

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

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

- generators need to be fixed instead of adding those names to this list. */

-#define yymaxdepth pascal_maxdepth

-#define yyparse pascal_parse

-#define yylex pascal_lex

-#define yyerror pascal_error

-#define yylval pascal_lval

-#define yychar pascal_char

-#define yydebug pascal_debug

-#define yypact pascal_pact

-#define yyr1 pascal_r1

-#define yyr2 pascal_r2

-#define yydef pascal_def

-#define yychk pascal_chk

-#define yypgo pascal_pgo

-#define yyact pascal_act

-#define yyexca pascal_exca

-#define yyerrflag pascal_errflag

-#define yynerrs pascal_nerrs

-#define yyps pascal_ps

-#define yypv pascal_pv

-#define yys pascal_s

-#define yy_yys pascal_yys

-#define yystate pascal_state

-#define yytmp pascal_tmp

-#define yyv pascal_v

-#define yy_yyv pascal_yyv

-#define yyval pascal_val

-#define yylloc pascal_lloc

-#define yyreds pascal_reds /* With YYDEBUG defined */

-#define yytoks pascal_toks /* With YYDEBUG defined */

-#define yyname pascal_name /* With YYDEBUG defined */

-#define yyrule pascal_rule /* With YYDEBUG defined */

-#define yylhs pascal_yylhs

-#define yylen pascal_yylen

-#define yydefred pascal_yydefred

-#define yydgoto pascal_yydgoto

-#define yysindex pascal_yysindex

-#define yyrindex pascal_yyrindex

-#define yygindex pascal_yygindex

-#define yytable pascal_yytable

-#define yycheck pascal_yycheck

-#define yyss pascal_yyss

-#define yysslim pascal_yysslim

-#define yyssp pascal_yyssp

-#define yystacksize pascal_yystacksize

-#define yyvs pascal_yyvs

-#define yyvsp pascal_yyvsp

-#ifndef YYDEBUG

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

-#endif

-#define YYFPRINTF parser_fprintf

-int yyparse (void);

-static int yylex (void);

-void yyerror (char *);

-static char * uptok (char *, int);

-/* Enabling traces. */

-#ifndef YYDEBUG

-# define YYDEBUG 0

-#endif

-/* Enabling verbose error messages. */

-#ifdef YYERROR_VERBOSE

-# undef YYERROR_VERBOSE

-# define YYERROR_VERBOSE 1

-#else

-# define YYERROR_VERBOSE 0

-#endif

-#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)

-#line 135 "p-exp.y"

-typedef union YYSTYPE {

- LONGEST lval;

- struct {

- LONGEST val;

- struct type *type;

- } typed_val_int;

- struct {

- DOUBLEST dval;

- struct type *type;

- } typed_val_float;

- struct symbol *sym;

- struct type *tval;

- struct stoken sval;

- struct ttype tsym;

- struct symtoken ssym;

- int voidval;

- struct block *bval;

- enum exp_opcode opcode;

- struct internalvar *ivar;

- struct type **tvec;

- int *ivec;

- } YYSTYPE;

-/* Line 191 of yacc.c. */

-#line 260 "p-exp.c"

-# define yystype YYSTYPE /* obsolescent; will be withdrawn */

-# define YYSTYPE_IS_DECLARED 1

-# define YYSTYPE_IS_TRIVIAL 1

-#endif

-/* Copy the second part of user declarations. */

-#line 159 "p-exp.y"

-/* YYSTYPE gets defined by %union */

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

-static struct type *current_type;

-static struct internalvar *intvar;

-static int leftdiv_is_integer;

-static void push_current_type (void);

-static void pop_current_type (void);

-static int search_field;

-/* Line 214 of yacc.c. */

-#line 283 "p-exp.c"

-#if ! defined (yyoverflow) || YYERROR_VERBOSE

-# ifndef YYFREE

-# define YYFREE xfree

-# endif

-# ifndef YYMALLOC

-# define YYMALLOC xmalloc

-# endif

-/* The parser invokes alloca or xmalloc; define the necessary symbols. */

-# ifdef YYSTACK_USE_ALLOCA

-# if YYSTACK_USE_ALLOCA

-# define YYSTACK_ALLOC alloca

-# endif

-# else

-# if defined (alloca) || defined (_ALLOCA_H)

-# define YYSTACK_ALLOC alloca

-# else

-# ifdef __GNUC__

-# define YYSTACK_ALLOC __builtin_alloca

-# endif

-# ifdef YYSTACK_ALLOC

- /* Pacify GCC's `empty if-body' warning. */

-# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)

-# else

-# if defined (__STDC__) || defined (__cplusplus)

-# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */

-# define YYSIZE_T size_t

-# endif

-# define YYSTACK_ALLOC YYMALLOC

-# define YYSTACK_FREE YYFREE

-# endif

-#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */

-#if (! defined (yyoverflow) \

- && (! defined (__cplusplus) \

- || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))

-/* A type that is properly aligned for any stack member. */

-union yyalloc

- short yyss;

- YYSTYPE yyvs;

- };

-/* The size of the maximum gap between one aligned stack and the next. */

-# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)

-/* The size of an array large to enough to hold all stacks, each with

- N elements. */

-# define YYSTACK_BYTES(N) \

- ((N) * (sizeof (short) + sizeof (YYSTYPE)) \

- + YYSTACK_GAP_MAXIMUM)

-/* Copy COUNT objects from FROM to TO. The source and destination do

- not overlap. */

-# ifndef YYCOPY

-# if defined (__GNUC__) && 1 < __GNUC__

-# define YYCOPY(To, From, Count) \

- __builtin_memcpy (To, From, (Count) * sizeof (*(From)))

-# else

-# define YYCOPY(To, From, Count) \

- do \

- { \

- register YYSIZE_T yyi; \

- for (yyi = 0; yyi < (Count); yyi++) \

- (To)[yyi] = (From)[yyi]; \

- } \

- while (0)

-# endif

-/* Relocate STACK from its old location to the new one. The

- local variables YYSIZE and YYSTACKSIZE give the old and new number of

- elements in the stack, and YYPTR gives the new location of the

- stack. Advance YYPTR to a properly aligned location for the next

- stack. */

-# define YYSTACK_RELOCATE(Stack) \

- do \

- { \

- YYSIZE_T yynewbytes; \

- YYCOPY (&yyptr->Stack, Stack, yysize); \

- Stack = &yyptr->Stack; \

- yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \

- yyptr += yynewbytes / sizeof (*yyptr); \

- } \

- while (0)

-#endif

-#if defined (__STDC__) || defined (__cplusplus)

- typedef signed char yysigned_char;

-#else

- typedef short yysigned_char;

-#endif

-/* YYFINAL -- State number of the termination state. */

-#define YYFINAL 3

-/* YYLAST -- Last index in YYTABLE. */

-#define YYLAST 382

-/* YYNTOKENS -- Number of terminals. */

-#define YYNTOKENS 53

-/* YYNNTS -- Number of nonterminals. */

-#define YYNNTS 20

-/* YYNRULES -- Number of rules. */

-#define YYNRULES 76

-/* YYNRULES -- Number of states. */

-#define YYNSTATES 125

-/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */

-#define YYUNDEFTOK 2

-#define YYMAXUTOK 292

-#define YYTRANSLATE(YYX) \

- ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

-/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */

-static const unsigned char yytranslate[] =

- 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,

- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

- 47, 51, 40, 38, 20, 39, 45, 41, 2, 2,

- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

- 29, 27, 30, 2, 37, 2, 2, 2, 2, 2,

- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

- 2, 46, 2, 52, 49, 2, 2, 2, 2, 2,

- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

- 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,

- 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,

- 15, 16, 17, 18, 19, 21, 22, 23, 24, 25,

- 26, 28, 31, 32, 33, 34, 35, 36, 42, 43,

- 44, 48, 50

-};

-#if YYDEBUG

-/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in

- YYRHS. */

-static const unsigned char yyprhs[] =

- 0, 0, 3, 4, 7, 9, 11, 13, 15, 19,

- 22, 25, 28, 31, 36, 41, 44, 47, 50, 53,

- 54, 60, 61, 67, 68, 70, 74, 79, 83, 87,

- 88, 93, 97, 101, 105, 109, 113, 117, 121, 125,

- 129, 133, 137, 141, 145, 149, 153, 157, 159, 161,

- 163, 165, 167, 169, 171, 176, 181, 183, 185, 187,

- 191, 195, 199, 201, 204, 206, 208, 210, 213, 215,

- 218, 221, 223, 225, 227, 229, 231

-};

-/* YYRHS -- A `-1'-separated list of the rules' RHS. */

-static const yysigned_char yyrhs[] =

- 54, 0, -1, -1, 55, 56, -1, 58, -1, 57,

- -1, 69, -1, 59, -1, 58, 20, 59, -1, 59,

- 49, -1, 37, 59, -1, 39, 59, -1, 23, 59,

- -1, 43, 47, 59, 51, -1, 42, 47, 59, 51,

- -1, 59, 45, -1, 60, 6, -1, 60, 71, -1,

- 60, 7, -1, -1, 59, 46, 61, 58, 52, -1,

- -1, 59, 47, 62, 63, 51, -1, -1, 59, -1,

- 63, 20, 59, -1, 69, 47, 59, 51, -1, 47,

- 58, 51, -1, 59, 40, 59, -1, -1, 59, 41,

- 64, 59, -1, 59, 34, 59, -1, 59, 33, 59,

- -1, 59, 38, 59, -1, 59, 39, 59, -1, 59,

- 36, 59, -1, 59, 35, 59, -1, 59, 27, 59,

- -1, 59, 28, 59, -1, 59, 32, 59, -1, 59,

- 31, 59, -1, 59, 29, 59, -1, 59, 30, 59,

- -1, 59, 26, 59, -1, 59, 25, 59, -1, 59,

- 24, 59, -1, 59, 22, 59, -1, 18, -1, 19,

- -1, 3, -1, 10, -1, 4, -1, 66, -1, 16,

- -1, 13, 47, 69, 51, -1, 13, 47, 59, 51,

- -1, 5, -1, 17, -1, 50, -1, 65, 14, 71,

- -1, 65, 14, 71, -1, 70, 14, 71, -1, 67,

- -1, 14, 71, -1, 72, -1, 70, -1, 68, -1,

- 49, 70, -1, 9, -1, 11, 71, -1, 12, 71,

- -1, 8, -1, 50, -1, 9, -1, 10, -1, 8,

- -1, 50, -1

-};

-/* YYRLINE[YYN] -- source line where rule number YYN was defined. */

-static const unsigned short yyrline[] =

- 0, 240, 240, 240, 249, 250, 253, 260, 261, 266,

- 272, 278, 282, 286, 290, 295, 299, 317, 335, 347,

- 345, 375, 372, 387, 388, 390, 394, 409, 415, 419,

- 419, 439, 443, 447, 451, 455, 459, 463, 469, 475,

- 481, 487, 493, 499, 503, 507, 511, 515, 522, 529,

- 537, 551, 559, 562, 577, 585, 588, 613, 640, 658,

- 668, 683, 698, 699, 730, 801, 812, 816, 818, 820,

- 823, 831, 832, 833, 834, 837, 838

-};

-#endif

-#if YYDEBUG || YYERROR_VERBOSE

-/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.

- First, the terminals, then, starting at YYNTOKENS, nonterminals. */

-static const char *const yytname[] =

- "$end", "error", "$undefined", "INT", "FLOAT", "STRING", "FIELDNAME",

- "COMPLETE", "NAME", "TYPENAME", "NAME_OR_INT", "STRUCT", "CLASS",

- "SIZEOF", "COLONCOLON", "ERROR", "VARIABLE", "THIS", "TRUEKEYWORD",

- "FALSEKEYWORD", "','", "ABOVE_COMMA", "ASSIGN", "NOT", "OR", "XOR",

- "ANDAND", "'='", "NOTEQUAL", "'<'", "'>'", "GEQ", "LEQ", "MOD", "DIV",

- "RSH", "LSH", "'@'", "'+'", "'-'", "'*'", "'/'", "DECREMENT",

- "INCREMENT", "UNARY", "'.'", "'['", "'('", "ARROW", "'^'", "BLOCKNAME",

- "')'", "']'", "$accept", "start", "@1", "normal_start", "type_exp",

- "exp1", "exp", "field_exp", "@2", "@3", "arglist", "@4", "block",

- "variable", "qualified_name", "ptype", "type", "typebase", "name",

- "name_not_typename", 0

-};

-#endif

-# ifdef YYPRINT

-/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to

- token YYLEX-NUM. */

-static const unsigned short yytoknum[] =

- 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,

- 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,

- 44, 275, 276, 277, 278, 279, 280, 61, 281, 60,

- 62, 282, 283, 284, 285, 286, 287, 64, 43, 45,

- 42, 47, 288, 289, 290, 46, 91, 40, 291, 94,

- 292, 41, 93

-};

-# endif

-/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */

-static const unsigned char yyr1[] =

- 0, 53, 55, 54, 56, 56, 57, 58, 58, 59,

- 59, 59, 59, 59, 59, 60, 59, 59, 59, 61,

- 59, 62, 59, 63, 63, 63, 59, 59, 59, 64,

- 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,

- 59, 59, 59, 59, 59, 59, 59, 59, 65, 65,

- 66, 67, 66, 66, 66, 68, 69, 70, 70, 70,

- 70, 71, 71, 71, 71, 72, 72

-};

-/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */

-static const unsigned char yyr2[] =

- 0, 2, 0, 2, 1, 1, 1, 1, 3, 2,

- 2, 2, 2, 4, 4, 2, 2, 2, 2, 0,

- 5, 0, 5, 0, 1, 3, 4, 3, 3, 0,

- 4, 3, 3, 3, 3, 3, 3, 3, 3, 3,

- 3, 3, 3, 3, 3, 3, 3, 1, 1, 1,

- 1, 1, 1, 1, 4, 4, 1, 1, 1, 3,

- 3, 3, 1, 2, 1, 1, 1, 2, 1, 2,

- 2, 1, 1, 1, 1, 1, 1

-};

-/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state

- STATE-NUM when YYTABLE doesn't specify something else to do. Zero

- means the default is an error. */

-static const unsigned char yydefact[] =

- 2, 0, 0, 1, 49, 51, 56, 75, 68, 50,

- 0, 0, 0, 0, 53, 57, 47, 48, 0, 0,

- 0, 0, 0, 0, 0, 76, 3, 5, 4, 7,

- 0, 0, 52, 62, 66, 6, 65, 64, 71, 73,

- 74, 72, 69, 70, 0, 63, 12, 0, 10, 11,

- 0, 0, 0, 67, 0, 0, 0, 0, 0, 0,

- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

- 0, 0, 29, 15, 19, 21, 9, 16, 18, 17,

- 0, 0, 0, 0, 0, 0, 0, 27, 8, 46,

- 45, 44, 43, 37, 38, 41, 42, 40, 39, 32,

- 31, 36, 35, 33, 34, 28, 0, 0, 23, 60,

- 0, 61, 55, 54, 14, 13, 30, 0, 24, 0,

- 26, 20, 0, 22, 25

-};

-/* YYDEFGOTO[NTERM-NUM]. */

-static const yysigned_char yydefgoto[] =

- -1, 1, 2, 26, 27, 28, 29, 30, 107, 108,

- 119, 106, 31, 32, 33, 34, 47, 36, 42, 37

-};

-/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing

- STATE-NUM. */

-#define YYPACT_NINF -43

-static const short yypact[] =

- -43, 8, 89, -43, -43, -43, -43, -43, -43, -43,

- 7, 7, -40, 7, -43, -43, -43, -43, 89, 89,

- 89, -27, -23, 89, 10, 13, -43, -43, 14, 230,

- 4, 21, -43, -43, -43, -19, 41, -43, -43, -43,

- -43, -43, -43, -43, 89, -43, 36, -19, 36, 36,

- 89, 89, 5, -43, 89, 89, 89, 89, 89, 89,

- 89, 89, 89, 89, 89, 89, 89, 89, 89, 89,

- 89, 89, -43, -43, -43, -43, -43, -43, -43, -43,

- 7, 89, 7, 118, -42, 146, 174, -43, 230, 230,

- 255, 279, 302, 323, 323, 31, 31, 31, 31, 75,

- 75, 75, 75, 333, 333, 36, 89, 89, 89, 44,

- 202, -43, -43, -43, -43, -43, 36, 9, 230, 11,

- -43, -43, 89, -43, 230

-};

-/* YYPGOTO[NTERM-NUM]. */

-static const yysigned_char yypgoto[] =

- -43, -43, -43, -43, -43, -20, -18, -43, -43, -43,

- -43, -43, -43, -43, -43, -43, 16, 6, -7, -43

-};

-/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If

- positive, shift that token. If negative, reduce the rule which

- number is the opposite. If zero, do what YYDEFACT says.

- If YYTABLE_NINF, syntax error. */

-#define YYTABLE_NINF -60

-static const yysigned_char yytable[] =

- 46, 48, 49, 52, 43, 81, 45, 44, 3, 113,

- 77, 78, 38, 39, 40, 38, 39, 40, 35, 8,

- 50, 10, 11, 79, 51, 54, 83, -58, 81, 54,

- 53, 122, 85, 86, 54, 80, 88, 89, 90, 91,

- 92, 93, 94, 95, 96, 97, 98, 99, 100, 101,

- 102, 103, 104, 105, 41, 82, 87, 41, -59, 24,

- 84, 121, 123, 110, 65, 66, 67, 68, 0, 69,

- 70, 71, 72, 109, 0, 111, 73, 74, 75, 0,

- 76, 73, 74, 75, 0, 76, 0, 117, 116, 0,

- 118, 0, 4, 5, 6, 0, 0, 7, 8, 9,

- 10, 11, 12, 13, 124, 14, 15, 16, 17, 0,

- 0, 0, 18, 69, 70, 71, 72, 0, 0, 0,

- 73, 74, 75, 0, 76, 0, 19, 0, 20, 0,

- 0, 21, 22, 0, 0, 0, 23, 0, 24, 25,

- 55, 0, 56, 57, 58, 59, 60, 61, 62, 63,

- 64, 65, 66, 67, 68, 0, 69, 70, 71, 72,

- 0, 0, 0, 73, 74, 75, 0, 76, 55, 112,

- 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,

- 66, 67, 68, 0, 69, 70, 71, 72, 0, 0,

- 0, 73, 74, 75, 0, 76, 55, 114, 56, 57,

- 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,

- 68, 0, 69, 70, 71, 72, 0, 0, 0, 73,

- 74, 75, 0, 76, 55, 115, 56, 57, 58, 59,

- 60, 61, 62, 63, 64, 65, 66, 67, 68, 0,

- 69, 70, 71, 72, 0, 0, 0, 73, 74, 75,

- 0, 76, 55, 120, 56, 57, 58, 59, 60, 61,

- 62, 63, 64, 65, 66, 67, 68, 0, 69, 70,

- 71, 72, 0, 0, 0, 73, 74, 75, 0, 76,

- 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,

- 67, 68, 0, 69, 70, 71, 72, 0, 0, 0,

- 73, 74, 75, 0, 76, 58, 59, 60, 61, 62,

- 63, 64, 65, 66, 67, 68, 0, 69, 70, 71,

- 72, 0, 0, 0, 73, 74, 75, 0, 76, 59,

- 60, 61, 62, 63, 64, 65, 66, 67, 68, 0,

- 69, 70, 71, 72, 0, 0, 0, 73, 74, 75,

- 0, 76, 61, 62, 63, 64, 65, 66, 67, 68,

- 0, 69, 70, 71, 72, 0, 0, 0, 73, 74,

- 75, 0, 76, 71, 72, 0, 0, 0, 73, 74,

- 75, 0, 76

-};

-static const yysigned_char yycheck[] =

- 18, 19, 20, 23, 11, 47, 13, 47, 0, 51,

- 6, 7, 8, 9, 10, 8, 9, 10, 2, 9,

- 47, 11, 12, 30, 47, 20, 44, 14, 47, 20,

- 24, 20, 50, 51, 20, 14, 54, 55, 56, 57,

- 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,

- 68, 69, 70, 71, 50, 14, 51, 50, 14, 49,

- 44, 52, 51, 81, 33, 34, 35, 36, -1, 38,

- 39, 40, 41, 80, -1, 82, 45, 46, 47, -1,

- 49, 45, 46, 47, -1, 49, -1, 107, 106, -1,

- 108, -1, 3, 4, 5, -1, -1, 8, 9, 10,

- 11, 12, 13, 14, 122, 16, 17, 18, 19, -1,

- -1, -1, 23, 38, 39, 40, 41, -1, -1, -1,

- 45, 46, 47, -1, 49, -1, 37, -1, 39, -1,

- -1, 42, 43, -1, -1, -1, 47, -1, 49, 50,

- 22, -1, 24, 25, 26, 27, 28, 29, 30, 31,

- 32, 33, 34, 35, 36, -1, 38, 39, 40, 41,

- -1, -1, -1, 45, 46, 47, -1, 49, 22, 51,

- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,

- 34, 35, 36, -1, 38, 39, 40, 41, -1, -1,

- -1, 45, 46, 47, -1, 49, 22, 51, 24, 25,

- 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,

- 36, -1, 38, 39, 40, 41, -1, -1, -1, 45,

- 46, 47, -1, 49, 22, 51, 24, 25, 26, 27,

- 28, 29, 30, 31, 32, 33, 34, 35, 36, -1,

- 38, 39, 40, 41, -1, -1, -1, 45, 46, 47,

- -1, 49, 22, 51, 24, 25, 26, 27, 28, 29,

- 30, 31, 32, 33, 34, 35, 36, -1, 38, 39,

- 40, 41, -1, -1, -1, 45, 46, 47, -1, 49,

- 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,

- 35, 36, -1, 38, 39, 40, 41, -1, -1, -1,

- 45, 46, 47, -1, 49, 26, 27, 28, 29, 30,

- 31, 32, 33, 34, 35, 36, -1, 38, 39, 40,

- 41, -1, -1, -1, 45, 46, 47, -1, 49, 27,

- 28, 29, 30, 31, 32, 33, 34, 35, 36, -1,

- 38, 39, 40, 41, -1, -1, -1, 45, 46, 47,

- -1, 49, 29, 30, 31, 32, 33, 34, 35, 36,

- -1, 38, 39, 40, 41, -1, -1, -1, 45, 46,

- 47, -1, 49, 40, 41, -1, -1, -1, 45, 46,

- 47, -1, 49

-};

-/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing

- symbol of state STATE-NUM. */

-static const unsigned char yystos[] =

- 0, 54, 55, 0, 3, 4, 5, 8, 9, 10,

- 11, 12, 13, 14, 16, 17, 18, 19, 23, 37,

- 39, 42, 43, 47, 49, 50, 56, 57, 58, 59,

- 60, 65, 66, 67, 68, 69, 70, 72, 8, 9,

- 10, 50, 71, 71, 47, 71, 59, 69, 59, 59,

- 47, 47, 58, 70, 20, 22, 24, 25, 26, 27,

- 28, 29, 30, 31, 32, 33, 34, 35, 36, 38,

- 39, 40, 41, 45, 46, 47, 49, 6, 7, 71,

- 14, 47, 14, 59, 69, 59, 59, 51, 59, 59,

- 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,

- 59, 59, 59, 59, 59, 59, 64, 61, 62, 71,

- 59, 71, 51, 51, 51, 51, 59, 58, 59, 63,

- 51, 52, 20, 51, 59

-};

-#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)

-# define YYSIZE_T __SIZE_TYPE__

-#endif

-#if ! defined (YYSIZE_T) && defined (size_t)

-# define YYSIZE_T size_t

-#endif

-#if ! defined (YYSIZE_T)

-# if defined (__STDC__) || defined (__cplusplus)

-# include <stddef.h> /* INFRINGES ON USER NAME SPACE */

-# define YYSIZE_T size_t

-# endif

-#endif

-#if ! defined (YYSIZE_T)

-# define YYSIZE_T unsigned int

-#endif

-#define yyerrok (yyerrstatus = 0)

-#define yyclearin (yychar = YYEMPTY)

-#define YYEMPTY (-2)

-#define YYEOF 0

-#define YYACCEPT goto yyacceptlab

-#define YYABORT goto yyabortlab

-#define YYERROR goto yyerrorlab

-/* Like YYERROR except do call yyerror. This remains here temporarily

- to ease the transition to the new meaning of YYERROR, for GCC.

- Once GCC version 2 has supplanted version 1, this can go. */

-#define YYFAIL goto yyerrlab

-#define YYRECOVERING() (!!yyerrstatus)

-#define YYBACKUP(Token, Value) \

-do \

- if (yychar == YYEMPTY && yylen == 1) \

- { \

- yychar = (Token); \

- yylval = (Value); \

- yytoken = YYTRANSLATE (yychar); \

- YYPOPSTACK; \

- goto yybackup; \

- } \

- else \

- { \

- yyerror ("syntax error: cannot back up");\

- YYERROR; \

- } \

-while (0)

-#define YYTERROR 1

-#define YYERRCODE 256

-/* YYLLOC_DEFAULT -- Compute the default location (before the actions

- are run). */

-#ifndef YYLLOC_DEFAULT

-# define YYLLOC_DEFAULT(Current, Rhs, N) \

- ((Current).first_line = (Rhs)[1].first_line, \

- (Current).first_column = (Rhs)[1].first_column, \

- (Current).last_line = (Rhs)[N].last_line, \

- (Current).last_column = (Rhs)[N].last_column)

-#endif

-/* YYLEX -- calling `yylex' with the right arguments. */

-#ifdef YYLEX_PARAM

-# define YYLEX yylex (YYLEX_PARAM)

-#else

-# define YYLEX yylex ()

-#endif

-/* Enable debugging if requested. */

-#if YYDEBUG

-# ifndef YYFPRINTF

-# include <stdio.h> /* INFRINGES ON USER NAME SPACE */

-# define YYFPRINTF fprintf

-# endif

-# define YYDPRINTF(Args) \

-do { \

- if (yydebug) \

- YYFPRINTF Args; \

-} while (0)

-# define YYDSYMPRINT(Args) \

-do { \

- if (yydebug) \

- yysymprint Args; \

-} while (0)

-# define YYDSYMPRINTF(Title, Token, Value, Location) \

-do { \

- if (yydebug) \

- { \

- YYFPRINTF (stderr, "%s ", Title); \

- yysymprint (stderr, \

- Token, Value); \

- YYFPRINTF (stderr, "\n"); \

- } \

-} while (0)

-/*------------------------------------------------------------------.

-| yy_stack_print -- Print the state stack from its BOTTOM up to its |

-| TOP (included). |

-`------------------------------------------------------------------*/

-#if defined (__STDC__) || defined (__cplusplus)

-static void

-yy_stack_print (short *bottom, short *top)

-#else

-static void

-yy_stack_print (bottom, top)

- short *bottom;

- short *top;

-#endif

- YYFPRINTF (stderr, "Stack now");

- for (/* Nothing. */; bottom <= top; ++bottom)

- YYFPRINTF (stderr, " %d", *bottom);

- YYFPRINTF (stderr, "\n");

-# define YY_STACK_PRINT(Bottom, Top) \

-do { \

- if (yydebug) \

- yy_stack_print ((Bottom), (Top)); \

-} while (0)

-/*------------------------------------------------.

-| Report that the YYRULE is going to be reduced. |

-`------------------------------------------------*/

-#if defined (__STDC__) || defined (__cplusplus)

-static void

-yy_reduce_print (int yyrule)

-#else

-static void

-yy_reduce_print (yyrule)

- int yyrule;

-#endif

- int yyi;

- unsigned int yylno = yyrline[yyrule];

- YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",

- yyrule - 1, yylno);

- /* Print the symbols being reduced, and their result. */

- for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)

- YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);

- YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);

-# define YY_REDUCE_PRINT(Rule) \

-do { \

- if (yydebug) \

- yy_reduce_print (Rule); \

-} while (0)

-/* Nonzero means print parse trace. It is left uninitialized so that

- multiple parsers can coexist. */

-int yydebug;

-#else /* !YYDEBUG */

-# define YYDPRINTF(Args)

-# define YYDSYMPRINT(Args)

-# define YYDSYMPRINTF(Title, Token, Value, Location)

-# define YY_STACK_PRINT(Bottom, Top)

-# define YY_REDUCE_PRINT(Rule)

-#endif /* !YYDEBUG */

-/* YYINITDEPTH -- initial size of the parser's stacks. */

-#ifndef YYINITDEPTH

-# define YYINITDEPTH 200

-#endif

-/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only

- if the built-in stack extension method is used).

- Do not make this value too large; the results are undefined if

- SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)

- evaluated with infinite-precision integer arithmetic. */

-#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0

-# undef YYMAXDEPTH

-#endif

-#ifndef YYMAXDEPTH

-# define YYMAXDEPTH 10000

-#endif

-#if YYERROR_VERBOSE

-# ifndef yystrlen

-# if defined (__GLIBC__) && defined (_STRING_H)

-# define yystrlen strlen

-# else

-/* Return the length of YYSTR. */

-static YYSIZE_T

-# if defined (__STDC__) || defined (__cplusplus)

-yystrlen (const char *yystr)

-# else

-yystrlen (yystr)

- const char *yystr;

-# endif

- register const char *yys = yystr;

- while (*yys++ != '\0')

- continue;

- return yys - yystr - 1;

-# endif

-# ifndef yystpcpy

-# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)

-# define yystpcpy stpcpy

-# else

-/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in

- YYDEST. */

-static char *

-# if defined (__STDC__) || defined (__cplusplus)

-yystpcpy (char *yydest, const char *yysrc)

-# else

-yystpcpy (yydest, yysrc)

- char *yydest;

- const char *yysrc;

-# endif

- register char *yyd = yydest;

- register const char *yys = yysrc;

- while ((*yyd++ = *yys++) != '\0')

- continue;

- return yyd - 1;

-# endif

-#endif /* !YYERROR_VERBOSE */

-#if YYDEBUG

-/*--------------------------------.

-| Print this symbol on YYOUTPUT. |

-`--------------------------------*/

-#if defined (__STDC__) || defined (__cplusplus)

-static void

-yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)

-#else

-static void

-yysymprint (yyoutput, yytype, yyvaluep)

- FILE *yyoutput;

- int yytype;

- YYSTYPE *yyvaluep;

-#endif

- /* Pacify ``unused variable'' warnings. */

- (void) yyvaluep;

- if (yytype < YYNTOKENS)

- {

- YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);

-# ifdef YYPRINT

- YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);

-# endif

- }

- else

- YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);

- switch (yytype)

- {

- default:

- break;

- }

- YYFPRINTF (yyoutput, ")");

-#endif /* ! YYDEBUG */

-/*-----------------------------------------------.

-| Release the memory associated to this symbol. |

-`-----------------------------------------------*/

-#if defined (__STDC__) || defined (__cplusplus)

-static void

-yydestruct (int yytype, YYSTYPE *yyvaluep)

-#else

-static void

-yydestruct (yytype, yyvaluep)

- int yytype;

- YYSTYPE *yyvaluep;

-#endif

- /* Pacify ``unused variable'' warnings. */

- (void) yyvaluep;

- switch (yytype)

- {

- default:

- break;

- }

-/* Prevent warnings from -Wmissing-prototypes. */

-#ifdef YYPARSE_PARAM

-# if defined (__STDC__) || defined (__cplusplus)

-int yyparse (void *YYPARSE_PARAM);

-# else

-int yyparse ();

-# endif

-#else /* ! YYPARSE_PARAM */

-#if defined (__STDC__) || defined (__cplusplus)

-int yyparse (void);

-#else

-int yyparse ();

-#endif

-#endif /* ! YYPARSE_PARAM */

-/* The lookahead symbol. */

-int yychar;

-/* The semantic value of the lookahead symbol. */

-YYSTYPE yylval;

-/* Number of syntax errors so far. */

-int yynerrs;

-/*----------.

-| yyparse. |

-`----------*/

-#ifdef YYPARSE_PARAM

-# if defined (__STDC__) || defined (__cplusplus)

-int yyparse (void *YYPARSE_PARAM)

-# else

-int yyparse (YYPARSE_PARAM)

- void *YYPARSE_PARAM;

-# endif

-#else /* ! YYPARSE_PARAM */

-#if defined (__STDC__) || defined (__cplusplus)

-int

-yyparse (void)

-#else

-int

-yyparse ()

-#endif

- register int yystate;

- register int yyn;

- int yyresult;

- /* Number of tokens to shift before error messages enabled. */

- int yyerrstatus;

- /* Lookahead token as an internal (translated) token number. */

- int yytoken = 0;

- /* Three stacks and their tools:

- `yyss': related to states,

- `yyvs': related to semantic values,

- `yyls': related to locations.

- Refer to the stacks thru separate pointers, to allow yyoverflow

- to xreallocate them elsewhere. */

- /* The state stack. */

- short yyssa[YYINITDEPTH];

- short *yyss = yyssa;

- register short *yyssp;

- /* The semantic value stack. */

- YYSTYPE yyvsa[YYINITDEPTH];

- YYSTYPE *yyvs = yyvsa;

- register YYSTYPE *yyvsp;

-#define YYPOPSTACK (yyvsp--, yyssp--)

- YYSIZE_T yystacksize = YYINITDEPTH;

- /* The variables used to return semantic value and location from the

- action routines. */

- YYSTYPE yyval;

- /* When reducing, the number of symbols on the RHS of the reduced

- rule. */

- int yylen;

- YYDPRINTF ((stderr, "Starting parse\n"));

- yystate = 0;

- yyerrstatus = 0;

- yynerrs = 0;

- yychar = YYEMPTY; /* Cause a token to be read. */

- /* Initialize stack pointers.

- Waste one element of value and location stack

- so that they stay on the same level as the state stack.

- The wasted elements are never initialized. */

- yyssp = yyss;

- yyvsp = yyvs;

- goto yysetstate;

-/*------------------------------------------------------------.

-| yynewstate -- Push a new state, which is found in yystate. |

-`------------------------------------------------------------*/

- yynewstate:

- /* In all cases, when you get here, the value and location stacks

- have just been pushed. so pushing a state here evens the stacks.

- */

- yyssp++;

- yysetstate:

- *yyssp = yystate;

- if (yyss + yystacksize - 1 <= yyssp)

- {

- /* Get the current used size of the three stacks, in elements. */

- YYSIZE_T yysize = yyssp - yyss + 1;

-#ifdef yyoverflow

- {

- /* Give user a chance to xreallocate the stack. Use copies of

- these so that the &'s don't force the real ones into

- memory. */

- YYSTYPE *yyvs1 = yyvs;

- short *yyss1 = yyss;

- /* Each stack pointer address is followed by the size of the

- data in use in that stack, in bytes. This used to be a

- conditional around just the two extra args, but that might

- be undefined if yyoverflow is a macro. */

- yyoverflow ("parser stack overflow",

- &yyss1, yysize * sizeof (*yyssp),

- &yyvs1, yysize * sizeof (*yyvsp),

- &yystacksize);

- yyss = yyss1;

- yyvs = yyvs1;

- }

-#else /* no yyoverflow */

-# ifndef YYSTACK_RELOCATE

- goto yyoverflowlab;

-# else

- /* Extend the stack our own way. */

- if (YYMAXDEPTH <= yystacksize)

- goto yyoverflowlab;

- yystacksize *= 2;

- if (YYMAXDEPTH < yystacksize)

- yystacksize = YYMAXDEPTH;

- {

- short *yyss1 = yyss;

- union yyalloc *yyptr =

- (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));

- if (! yyptr)

- goto yyoverflowlab;

- YYSTACK_RELOCATE (yyss);

- YYSTACK_RELOCATE (yyvs);

-# undef YYSTACK_RELOCATE

- if (yyss1 != yyssa)

- YYSTACK_FREE (yyss1);

- }

-# endif

-#endif /* no yyoverflow */

- yyssp = yyss + yysize - 1;

- yyvsp = yyvs + yysize - 1;

- YYDPRINTF ((stderr, "Stack size increased to %lu\n",

- (unsigned long int) yystacksize));

- if (yyss + yystacksize - 1 <= yyssp)

- YYABORT;

- }

- YYDPRINTF ((stderr, "Entering state %d\n", yystate));

- goto yybackup;

-/*-----------.

-| yybackup. |

-`-----------*/

-yybackup:

-/* Do appropriate processing given the current state. */

-/* Read a lookahead token if we need one and don't already have one. */

-/* yyresume: */

- /* First try to decide what to do without reference to lookahead token. */

- yyn = yypact[yystate];

- if (yyn == YYPACT_NINF)

- goto yydefault;

- /* Not known => get a lookahead token if don't already have one. */

- /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */

- if (yychar == YYEMPTY)

- {

- YYDPRINTF ((stderr, "Reading a token: "));

- yychar = YYLEX;

- }

- if (yychar <= YYEOF)

- {

- yychar = yytoken = YYEOF;

- YYDPRINTF ((stderr, "Now at end of input.\n"));

- }

- else

- {

- yytoken = YYTRANSLATE (yychar);

- YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);

- }

- /* If the proper action on seeing token YYTOKEN is to reduce or to

- detect an error, take that action. */

- yyn += yytoken;

- if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)

- goto yydefault;

- yyn = yytable[yyn];

- if (yyn <= 0)

- {

- if (yyn == 0 || yyn == YYTABLE_NINF)

- goto yyerrlab;

- yyn = -yyn;

- goto yyreduce;

- }

- if (yyn == YYFINAL)

- YYACCEPT;

- /* Shift the lookahead token. */

- YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));

- /* Discard the token being shifted unless it is eof. */

- if (yychar != YYEOF)

- yychar = YYEMPTY;

- *++yyvsp = yylval;

- /* Count tokens shifted since error; after three, turn off error

- status. */

- if (yyerrstatus)

- yyerrstatus--;

- yystate = yyn;

- goto yynewstate;

-/*-----------------------------------------------------------.

-| yydefault -- do the default action for the current state. |

-`-----------------------------------------------------------*/

-yydefault:

- yyn = yydefact[yystate];

- if (yyn == 0)

- goto yyerrlab;

- goto yyreduce;

-/*-----------------------------.

-| yyreduce -- Do a reduction. |

-`-----------------------------*/

-yyreduce:

- /* yyn is the number of a rule to reduce with. */

- yylen = yyr2[yyn];

- /* If YYLEN is nonzero, implement the default value of the action:

- `$$ = $1'.

- Otherwise, the following line sets YYVAL to garbage.

- This behavior is undocumented and Bison

- users should not rely upon it. Assigning to YYVAL

- unconditionally makes the parser a bit smaller, and it avoids a

- GCC warning that YYVAL may be used uninitialized. */

- yyval = yyvsp[1-yylen];

- YY_REDUCE_PRINT (yyn);

- switch (yyn)

- {

- case 2:

-#line 240 "p-exp.y"

- { current_type = NULL;

- intvar = NULL;

- search_field = 0;

- leftdiv_is_integer = 0;

- }

- break;

- case 3:

-#line 245 "p-exp.y"

- {}

- break;

- case 6:

-#line 254 "p-exp.y"

- { write_exp_elt_opcode(OP_TYPE);

- write_exp_elt_type(yyvsp[0].tval);

- write_exp_elt_opcode(OP_TYPE);

- current_type = yyvsp[0].tval; }

- break;

- case 8:

-#line 262 "p-exp.y"

- { write_exp_elt_opcode (BINOP_COMMA); }

- break;

- case 9:

-#line 267 "p-exp.y"

- { write_exp_elt_opcode (UNOP_IND);

- if (current_type)

- current_type = TYPE_TARGET_TYPE (current_type); }

- break;

- case 10:

-#line 273 "p-exp.y"

- { write_exp_elt_opcode (UNOP_ADDR);

- if (current_type)

- current_type = TYPE_POINTER_TYPE (current_type); }

- break;

- case 11:

-#line 279 "p-exp.y"

- { write_exp_elt_opcode (UNOP_NEG); }

- break;

- case 12:

-#line 283 "p-exp.y"

- { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }

- break;

- case 13:

-#line 287 "p-exp.y"

- { write_exp_elt_opcode (UNOP_PREINCREMENT); }

- break;

- case 14:

-#line 291 "p-exp.y"

- { write_exp_elt_opcode (UNOP_PREDECREMENT); }

- break;

- case 15:

-#line 296 "p-exp.y"

- { search_field = 1; }

- break;

- case 16:

-#line 300 "p-exp.y"

- { write_exp_elt_opcode (STRUCTOP_STRUCT);

- write_exp_string (yyvsp[0].sval);

- write_exp_elt_opcode (STRUCTOP_STRUCT);

- search_field = 0;

- if (current_type)

- {

- while (TYPE_CODE (current_type)

- == TYPE_CODE_PTR)

- current_type =

- TYPE_TARGET_TYPE (current_type);

- current_type = lookup_struct_elt_type (

- current_type, yyvsp[0].sval.ptr, 0);

- }

- break;

- case 17:

-#line 318 "p-exp.y"

- { mark_struct_expression ();

- write_exp_elt_opcode (STRUCTOP_STRUCT);

- write_exp_string (yyvsp[0].sval);

- write_exp_elt_opcode (STRUCTOP_STRUCT);

- search_field = 0;

- if (current_type)

- {

- while (TYPE_CODE (current_type)

- == TYPE_CODE_PTR)

- current_type =

- TYPE_TARGET_TYPE (current_type);

- current_type = lookup_struct_elt_type (

- current_type, yyvsp[0].sval.ptr, 0);

- }

- break;

- case 18:

-#line 336 "p-exp.y"

- { struct stoken s;

- mark_struct_expression ();

- write_exp_elt_opcode (STRUCTOP_STRUCT);

- s.ptr = "";

- s.length = 0;

- write_exp_string (s);

- write_exp_elt_opcode (STRUCTOP_STRUCT); }

- break;

- case 19:

-#line 347 "p-exp.y"

- { const char *arrayname;

- int arrayfieldindex;

- arrayfieldindex = is_pascal_string_type (

- current_type, NULL, NULL,

- NULL, NULL, &arrayname);

- if (arrayfieldindex)

- {

- struct stoken stringsval;

- stringsval.ptr = alloca (strlen (arrayname) + 1);

- stringsval.length = strlen (arrayname);

- strcpy (stringsval.ptr, arrayname);

- current_type = TYPE_FIELD_TYPE (current_type,

- arrayfieldindex - 1);

- write_exp_elt_opcode (STRUCTOP_STRUCT);

- write_exp_string (stringsval);

- write_exp_elt_opcode (STRUCTOP_STRUCT);

- }

- push_current_type (); }

- break;

- case 20:

-#line 366 "p-exp.y"

- { pop_current_type ();

- write_exp_elt_opcode (BINOP_SUBSCRIPT);

- if (current_type)

- current_type = TYPE_TARGET_TYPE (current_type); }

- break;

- case 21:

-#line 375 "p-exp.y"

- { push_current_type ();

- start_arglist (); }

- break;

- case 22:

-#line 378 "p-exp.y"

- { write_exp_elt_opcode (OP_FUNCALL);

- write_exp_elt_longcst ((LONGEST) end_arglist ());

- write_exp_elt_opcode (OP_FUNCALL);

- pop_current_type ();

- if (current_type)

- current_type = TYPE_TARGET_TYPE (current_type);

- }

- break;

- case 24:

-#line 389 "p-exp.y"

- { arglist_len = 1; }

- break;

- case 25:

-#line 391 "p-exp.y"

- { arglist_len++; }

- break;

- case 26:

-#line 395 "p-exp.y"

- { if (current_type)

- {

- /* Allow automatic dereference of classes. */

- if ((TYPE_CODE (current_type) == TYPE_CODE_PTR)

- && (TYPE_CODE (TYPE_TARGET_TYPE (current_type)) == TYPE_CODE_CLASS)

- && (TYPE_CODE (yyvsp[-3].tval) == TYPE_CODE_CLASS))

- write_exp_elt_opcode (UNOP_IND);

- }

- write_exp_elt_opcode (UNOP_CAST);

- write_exp_elt_type (yyvsp[-3].tval);

- write_exp_elt_opcode (UNOP_CAST);

- current_type = yyvsp[-3].tval; }

- break;

- case 27:

-#line 410 "p-exp.y"

- { }

- break;

- case 28:

-#line 416 "p-exp.y"

- { write_exp_elt_opcode (BINOP_MUL); }

- break;

- case 29:

-#line 419 "p-exp.y"

- {

- if (current_type && is_integral_type (current_type))

- leftdiv_is_integer = 1;

- }

- break;

- case 30:

-#line 424 "p-exp.y"

- {

- if (leftdiv_is_integer && current_type

- && is_integral_type (current_type))

- {

- write_exp_elt_opcode (UNOP_CAST);

- write_exp_elt_type (parse_type->builtin_long_double);

- current_type = parse_type->builtin_long_double;

- write_exp_elt_opcode (UNOP_CAST);

- leftdiv_is_integer = 0;

- }

- write_exp_elt_opcode (BINOP_DIV);

- }

- break;

- case 31:

-#line 440 "p-exp.y"

- { write_exp_elt_opcode (BINOP_INTDIV); }

- break;

- case 32:

-#line 444 "p-exp.y"

- { write_exp_elt_opcode (BINOP_REM); }

- break;

- case 33:

-#line 448 "p-exp.y"

- { write_exp_elt_opcode (BINOP_ADD); }

- break;

- case 34:

-#line 452 "p-exp.y"

- { write_exp_elt_opcode (BINOP_SUB); }

- break;

- case 35:

-#line 456 "p-exp.y"

- { write_exp_elt_opcode (BINOP_LSH); }

- break;

- case 36:

-#line 460 "p-exp.y"

- { write_exp_elt_opcode (BINOP_RSH); }

- break;

- case 37:

-#line 464 "p-exp.y"

- { write_exp_elt_opcode (BINOP_EQUAL);

- current_type = parse_type->builtin_bool;

- }

- break;

- case 38:

-#line 470 "p-exp.y"

- { write_exp_elt_opcode (BINOP_NOTEQUAL);

- current_type = parse_type->builtin_bool;

- }

- break;

- case 39:

-#line 476 "p-exp.y"

- { write_exp_elt_opcode (BINOP_LEQ);

- current_type = parse_type->builtin_bool;

- }

- break;

- case 40:

-#line 482 "p-exp.y"

- { write_exp_elt_opcode (BINOP_GEQ);

- current_type = parse_type->builtin_bool;

- }

- break;

- case 41:

-#line 488 "p-exp.y"

- { write_exp_elt_opcode (BINOP_LESS);

- current_type = parse_type->builtin_bool;

- }

- break;

- case 42:

-#line 494 "p-exp.y"

- { write_exp_elt_opcode (BINOP_GTR);

- current_type = parse_type->builtin_bool;

- }

- break;

- case 43:

-#line 500 "p-exp.y"

- { write_exp_elt_opcode (BINOP_BITWISE_AND); }

- break;

- case 44:

-#line 504 "p-exp.y"

- { write_exp_elt_opcode (BINOP_BITWISE_XOR); }

- break;

- case 45:

-#line 508 "p-exp.y"

- { write_exp_elt_opcode (BINOP_BITWISE_IOR); }

- break;

- case 46:

-#line 512 "p-exp.y"

- { write_exp_elt_opcode (BINOP_ASSIGN); }

- break;

- case 47:

-#line 516 "p-exp.y"

- { write_exp_elt_opcode (OP_BOOL);

- write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);

- current_type = parse_type->builtin_bool;

- write_exp_elt_opcode (OP_BOOL); }

- break;

- case 48:

-#line 523 "p-exp.y"

- { write_exp_elt_opcode (OP_BOOL);

- write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);

- current_type = parse_type->builtin_bool;

- write_exp_elt_opcode (OP_BOOL); }

- break;

- case 49:

-#line 530 "p-exp.y"

- { write_exp_elt_opcode (OP_LONG);

- write_exp_elt_type (yyvsp[0].typed_val_int.type);

- current_type = yyvsp[0].typed_val_int.type;

- write_exp_elt_longcst ((LONGEST)(yyvsp[0].typed_val_int.val));

- write_exp_elt_opcode (OP_LONG); }

- break;

- case 50:

-#line 538 "p-exp.y"

- { YYSTYPE val;

- parse_number (yyvsp[0].ssym.stoken.ptr,

- yyvsp[0].ssym.stoken.length, 0, &val);

- write_exp_elt_opcode (OP_LONG);

- write_exp_elt_type (val.typed_val_int.type);

- current_type = val.typed_val_int.type;

- write_exp_elt_longcst ((LONGEST)

- val.typed_val_int.val);

- write_exp_elt_opcode (OP_LONG);

- }

- break;

- case 51:

-#line 552 "p-exp.y"

- { write_exp_elt_opcode (OP_DOUBLE);

- write_exp_elt_type (yyvsp[0].typed_val_float.type);

- current_type = yyvsp[0].typed_val_float.type;

- write_exp_elt_dblcst (yyvsp[0].typed_val_float.dval);

- write_exp_elt_opcode (OP_DOUBLE); }

- break;

- case 53:

-#line 565 "p-exp.y"

- { if (intvar) {

- struct value * val, * mark;

- mark = value_mark ();

- val = value_of_internalvar (parse_gdbarch,

- intvar);

- current_type = value_type (val);

- value_release_to_mark (mark);

- }

- break;

- case 54:

-#line 578 "p-exp.y"

- { write_exp_elt_opcode (OP_LONG);

- write_exp_elt_type (parse_type->builtin_int);

- CHECK_TYPEDEF (yyvsp[-1].tval);

- write_exp_elt_longcst ((LONGEST) TYPE_LENGTH (yyvsp[-1].tval));

- write_exp_elt_opcode (OP_LONG); }

- break;

- case 55:

-#line 586 "p-exp.y"

- { write_exp_elt_opcode (UNOP_SIZEOF); }

- break;

- case 56:

-#line 589 "p-exp.y"

- { /* C strings are converted into array constants with

- an explicit null byte added at the end. Thus

- the array upper bound is the string length.

- There is no such thing in C as a completely empty

- string. */

- char *sp = yyvsp[0].sval.ptr; int count = yyvsp[0].sval.length;

- while (count-- > 0)

- {

- write_exp_elt_opcode (OP_LONG);

- write_exp_elt_type (parse_type->builtin_char);

- write_exp_elt_longcst ((LONGEST)(*sp++));

- write_exp_elt_opcode (OP_LONG);

- }

- write_exp_elt_opcode (OP_LONG);

- write_exp_elt_type (parse_type->builtin_char);

- write_exp_elt_longcst ((LONGEST)'\0');

- write_exp_elt_opcode (OP_LONG);

- write_exp_elt_opcode (OP_ARRAY);

- write_exp_elt_longcst ((LONGEST) 0);

- write_exp_elt_longcst ((LONGEST) (yyvsp[0].sval.length));

- write_exp_elt_opcode (OP_ARRAY); }

- break;

- case 57:

-#line 614 "p-exp.y"

- {

- struct value * this_val;

- struct type * this_type;

- write_exp_elt_opcode (OP_THIS);

- /* We need type of this. */

- this_val = value_of_this_silent (parse_language);

- if (this_val)

- this_type = value_type (this_val);

- else

- this_type = NULL;

- if (this_type)

- {

- if (TYPE_CODE (this_type) == TYPE_CODE_PTR)

- {

- this_type = TYPE_TARGET_TYPE (this_type);

- write_exp_elt_opcode (UNOP_IND);

- }

- current_type = this_type;

- }

- break;

- case 58:

-#line 641 "p-exp.y"

- {

- if (yyvsp[0].ssym.sym != 0)

- yyval.bval = SYMBOL_BLOCK_VALUE (yyvsp[0].ssym.sym);

- else

- {

- struct symtab *tem =

- lookup_symtab (copy_name (yyvsp[0].ssym.stoken));

- if (tem)

- yyval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem),

- STATIC_BLOCK);

- else

- error (_("No file or function \"%s\"."),

- copy_name (yyvsp[0].ssym.stoken));

- }

- break;

- case 59:

-#line 659 "p-exp.y"

- { struct symbol *tem

- = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval,

- VAR_DOMAIN, (int *) NULL);

- if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)

- error (_("No function \"%s\" in specified context."),

- copy_name (yyvsp[0].sval));

- yyval.bval = SYMBOL_BLOCK_VALUE (tem); }

- break;

- case 60:

-#line 669 "p-exp.y"

- { struct symbol *sym;

- sym = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval,

- VAR_DOMAIN, (int *) NULL);

- if (sym == 0)

- error (_("No symbol \"%s\" in specified context."),

- copy_name (yyvsp[0].sval));

- write_exp_elt_opcode (OP_VAR_VALUE);

- /* block_found is set by lookup_symbol. */

- write_exp_elt_block (block_found);

- write_exp_elt_sym (sym);

- write_exp_elt_opcode (OP_VAR_VALUE); }

- break;

- case 61:

-#line 684 "p-exp.y"

- {

- struct type *type = yyvsp[-2].tval;

- if (TYPE_CODE (type) != TYPE_CODE_STRUCT

- && TYPE_CODE (type) != TYPE_CODE_UNION)

- error (_("`%s' is not defined as an aggregate type."),

- TYPE_NAME (type));

- write_exp_elt_opcode (OP_SCOPE);

- write_exp_elt_type (type);

- write_exp_string (yyvsp[0].sval);

- write_exp_elt_opcode (OP_SCOPE);

- }

- break;

- case 63:

-#line 700 "p-exp.y"

- {

- char *name = copy_name (yyvsp[0].sval);

- struct symbol *sym;

- struct minimal_symbol *msymbol;

- sym =

- lookup_symbol (name, (const struct block *) NULL,

- VAR_DOMAIN, (int *) NULL);

- if (sym)

- {

- write_exp_elt_opcode (OP_VAR_VALUE);

- write_exp_elt_block (NULL);

- write_exp_elt_sym (sym);

- write_exp_elt_opcode (OP_VAR_VALUE);

- break;

- }

- msymbol = lookup_minimal_symbol (name, NULL, NULL);

- if (msymbol != NULL)

- write_exp_msymbol (msymbol);

- else if (!have_full_symbols ()

- && !have_partial_symbols ())

- error (_("No symbol table is loaded. "

- "Use the \"file\" command."));

- else

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

- name);

- }

- break;

- case 64:

-#line 731 "p-exp.y"

- { struct symbol *sym = yyvsp[0].ssym.sym;

- if (sym)

- {

- if (symbol_read_needs_frame (sym))

- {

- if (innermost_block == 0

- || contained_in (block_found,

- innermost_block))

- innermost_block = block_found;

- }

- write_exp_elt_opcode (OP_VAR_VALUE);

- /* We want to use the selected frame, not

- another more inner frame which happens to

- be in the same block. */

- write_exp_elt_block (NULL);

- write_exp_elt_sym (sym);

- write_exp_elt_opcode (OP_VAR_VALUE);

- current_type = sym->type; }

- else if (yyvsp[0].ssym.is_a_field_of_this)

- {

- struct value * this_val;

- struct type * this_type;

- /* Object pascal: it hangs off of `this'. Must

- not inadvertently convert from a method call

- to data ref. */

- if (innermost_block == 0

- || contained_in (block_found,

- innermost_block))

- innermost_block = block_found;

- write_exp_elt_opcode (OP_THIS);

- write_exp_elt_opcode (STRUCTOP_PTR);

- write_exp_string (yyvsp[0].ssym.stoken);

- write_exp_elt_opcode (STRUCTOP_PTR);

- /* We need type of this. */

- this_val = value_of_this_silent (parse_language);

- if (this_val)

- this_type = value_type (this_val);

- else

- this_type = NULL;

- if (this_type)

- current_type = lookup_struct_elt_type (

- this_type,

- copy_name (yyvsp[0].ssym.stoken), 0);

- else

- current_type = NULL;

- }

- else

- {

- struct minimal_symbol *msymbol;

- char *arg = copy_name (yyvsp[0].ssym.stoken);

- msymbol =

- lookup_minimal_symbol (arg, NULL, NULL);

- if (msymbol != NULL)

- write_exp_msymbol (msymbol);

- else if (!have_full_symbols ()

- && !have_partial_symbols ())

- error (_("No symbol table is loaded. "

- "Use the \"file\" command."));

- else

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

- copy_name (yyvsp[0].ssym.stoken));

- }

- break;

- case 67:

-#line 817 "p-exp.y"

- { yyval.tval = lookup_pointer_type (yyvsp[0].tval); }

- break;

- case 68:

-#line 819 "p-exp.y"

- { yyval.tval = yyvsp[0].tsym.type; }

- break;

- case 69:

-#line 821 "p-exp.y"

- { yyval.tval = lookup_struct (copy_name (yyvsp[0].sval),

- expression_context_block); }

- break;

- case 70:

-#line 824 "p-exp.y"

- { yyval.tval = lookup_struct (copy_name (yyvsp[0].sval),

- expression_context_block); }

- break;

- case 71:

-#line 831 "p-exp.y"

- { yyval.sval = yyvsp[0].ssym.stoken; }

- break;

- case 72:

-#line 832 "p-exp.y"

- { yyval.sval = yyvsp[0].ssym.stoken; }

- break;

- case 73:

-#line 833 "p-exp.y"

- { yyval.sval = yyvsp[0].tsym.stoken; }

- break;

- case 74:

-#line 834 "p-exp.y"

- { yyval.sval = yyvsp[0].ssym.stoken; }

- break;

- }

-/* Line 1000 of yacc.c. */

-#line 1982 "p-exp.c"

- yyvsp -= yylen;

- yyssp -= yylen;

- YY_STACK_PRINT (yyss, yyssp);

- *++yyvsp = yyval;

- /* Now `shift' the result of the reduction. Determine what state

- that goes to, based on the state we popped back to and the rule

- number reduced by. */

- yyn = yyr1[yyn];

- yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;

- if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)

- yystate = yytable[yystate];

- else

- yystate = yydefgoto[yyn - YYNTOKENS];

- goto yynewstate;

-/*------------------------------------.

-| yyerrlab -- here on detecting error |

-`------------------------------------*/

-yyerrlab:

- /* If not already recovering from an error, report this error. */

- if (!yyerrstatus)

- {

- ++yynerrs;

-#if YYERROR_VERBOSE

- yyn = yypact[yystate];

- if (YYPACT_NINF < yyn && yyn < YYLAST)

- {

- YYSIZE_T yysize = 0;

- int yytype = YYTRANSLATE (yychar);

- const char* yyprefix;

- char *yymsg;

- int yyx;

- /* Start YYX at -YYN if negative to avoid negative indexes in

- YYCHECK. */

- int yyxbegin = yyn < 0 ? -yyn : 0;

- /* Stay within bounds of both yycheck and yytname. */

- int yychecklim = YYLAST - yyn;

- int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;

- int yycount = 0;

- yyprefix = ", expecting ";

- for (yyx = yyxbegin; yyx < yyxend; ++yyx)

- if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)

- {

- yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);

- yycount += 1;

- if (yycount == 5)

- {

- yysize = 0;

- break;

- }

- yysize += (sizeof ("syntax error, unexpected ")

- + yystrlen (yytname[yytype]));

- yymsg = (char *) YYSTACK_ALLOC (yysize);

- if (yymsg != 0)

- {

- char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");

- yyp = yystpcpy (yyp, yytname[yytype]);

- if (yycount < 5)

- {

- yyprefix = ", expecting ";

- for (yyx = yyxbegin; yyx < yyxend; ++yyx)

- if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)

- {

- yyp = yystpcpy (yyp, yyprefix);

- yyp = yystpcpy (yyp, yytname[yyx]);

- yyprefix = " or ";

- }

- yyerror (yymsg);

- YYSTACK_FREE (yymsg);

- }

- else

- yyerror ("syntax error; also virtual memory exhausted");

- }

- else

-#endif /* YYERROR_VERBOSE */

- yyerror ("syntax error");

- }

- if (yyerrstatus == 3)

- {

- /* If just tried and failed to reuse lookahead token after an

- error, discard it. */

- if (yychar <= YYEOF)

- {

- /* If at end of input, pop the error token,

- then the rest of the stack, then return failure. */

- if (yychar == YYEOF)

- for (;;)

- {

- YYPOPSTACK;

- if (yyssp == yyss)

- YYABORT;

- YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);

- yydestruct (yystos[*yyssp], yyvsp);

- }

- else

- {

- YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);

- yydestruct (yytoken, &yylval);

- yychar = YYEMPTY;

- }

- /* Else will try to reuse lookahead token after shifting the error

- token. */

- goto yyerrlab1;

-/*---------------------------------------------------.

-| yyerrorlab -- error raised explicitly by YYERROR. |

-`---------------------------------------------------*/

-yyerrorlab:

-#ifdef __GNUC__

- /* Pacify GCC when the user code never invokes YYERROR and the label

- yyerrorlab therefore never appears in user code. */

- if (0)

- goto yyerrorlab;

-#endif

- yyvsp -= yylen;

- yyssp -= yylen;

- yystate = *yyssp;

- goto yyerrlab1;

-/*-------------------------------------------------------------.

-| yyerrlab1 -- common code for both syntax error and YYERROR. |

-`-------------------------------------------------------------*/

-yyerrlab1:

- yyerrstatus = 3; /* Each real token shifted decrements this. */

- for (;;)

- {

- yyn = yypact[yystate];

- if (yyn != YYPACT_NINF)

- {

- yyn += YYTERROR;

- if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)

- {

- yyn = yytable[yyn];

- if (0 < yyn)

- break;

- }

- /* Pop the current state because it cannot handle the error token. */

- if (yyssp == yyss)

- YYABORT;

- YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);

- yydestruct (yystos[yystate], yyvsp);

- YYPOPSTACK;

- yystate = *yyssp;

- YY_STACK_PRINT (yyss, yyssp);

- }

- if (yyn == YYFINAL)

- YYACCEPT;

- YYDPRINTF ((stderr, "Shifting error token, "));

- *++yyvsp = yylval;

- yystate = yyn;

- goto yynewstate;

-/*-------------------------------------.

-| yyacceptlab -- YYACCEPT comes here. |

-`-------------------------------------*/

-yyacceptlab:

- yyresult = 0;

- goto yyreturn;

-/*-----------------------------------.

-| yyabortlab -- YYABORT comes here. |

-`-----------------------------------*/

-yyabortlab:

- yyresult = 1;

- goto yyreturn;

-#ifndef yyoverflow

-/*----------------------------------------------.

-| yyoverflowlab -- parser overflow comes here. |

-`----------------------------------------------*/

-yyoverflowlab:

- yyerror ("parser stack overflow");

- yyresult = 2;

- /* Fall through. */

-#endif

-yyreturn:

-#ifndef yyoverflow

- if (yyss != yyssa)

- YYSTACK_FREE (yyss);

-#endif

- return yyresult;

-#line 848 "p-exp.y"

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

- Set yylval and return the token type; update lexptr.

- LEN is the number of characters in it. */

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

-static int

-parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)

- /* FIXME: Shouldn't these be unsigned? We don't deal with negative values

- here, and we do kind of silly things like cast to unsigned. */

- LONGEST n = 0;

- LONGEST prevn = 0;

- ULONGEST un;

- int i = 0;

- int c;

- int base = input_radix;

- int unsigned_p = 0;

- /* Number of "L" suffixes encountered. */

- int long_p = 0;

- /* We have found a "L" or "U" suffix. */

- int found_suffix = 0;

- ULONGEST high_bit;

- struct type *signed_type;

- struct type *unsigned_type;

- if (parsed_float)

- {

- if (! parse_c_float (parse_gdbarch, p, len,

- &putithere->typed_val_float.dval,

- &putithere->typed_val_float.type))

- return ERROR;

- return FLOAT;

- }

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

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

- switch (p[1])

- {

- case 'x':

- case 'X':

- if (len >= 3)

- {

- p += 2;

- base = 16;

- len -= 2;

- }

- break;

- case 't':

- case 'T':

- case 'd':

- case 'D':

- if (len >= 3)

- {

- p += 2;

- base = 10;

- len -= 2;

- }

- break;

- default:

- base = 8;

- break;

- }

- while (len-- > 0)

- {

- c = *p++;

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

- c += 'a' - 'A';

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

- n *= base;

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

- {

- if (found_suffix)

- return ERROR;

- n += i = c - '0';

- }

- else

- {

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

- {

- if (found_suffix)

- return ERROR;

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

- }

- else if (c == 'l')

- {

- ++long_p;

- found_suffix = 1;

- }

- else if (c == 'u')

- {

- unsigned_p = 1;

- found_suffix = 1;

- }

- else

- return ERROR; /* Char not a digit */

- }

- if (i >= base)

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

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

- a second check for zero). FIXME: Can't we just make n and prevn

- unsigned and avoid this? */

- if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)

- unsigned_p = 1; /* Try something unsigned. */

- /* Portably test for unsigned overflow.

- FIXME: This check is wrong; for example it doesn't find overflow

- on 0x123456789 when LONGEST is 32 bits. */

- if (c != 'l' && c != 'u' && n != 0)

- {

- if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))

- error (_("Numeric constant too large."));

- }

- prevn = n;

- }

- /* An integer constant is an int, a long, or a long long. An L

- suffix forces it to be long; an LL suffix forces it to be long

- long. If not forced to a larger size, it gets the first type of

- the above that it fits in. To figure out whether it fits, we

- shift it right and see whether anything remains. Note that we

- can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one

- operation, because many compilers will warn about such a shift

- (which always produces a zero result). Sometimes gdbarch_int_bit

- or gdbarch_long_bit will be that big, sometimes not. To deal with

- the case where it is we just always shift the value more than

- once, with fewer bits each time. */

- un = (ULONGEST)n >> 2;

- if (long_p == 0

- && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0)

- {

- high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1);

- /* A large decimal (not hex or octal) constant (between INT_MAX

- and UINT_MAX) is a long or unsigned long, according to ANSI,

- never an unsigned int, but this code treats it as unsigned

- int. This probably should be fixed. GCC gives a warning on

- such constants. */

- unsigned_type = parse_type->builtin_unsigned_int;

- signed_type = parse_type->builtin_int;

- }

- else if (long_p <= 1

- && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0)

- {

- high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch) - 1);

- unsigned_type = parse_type->builtin_unsigned_long;

- signed_type = parse_type->builtin_long;

- }

- else

- {

- int shift;

- if (sizeof (ULONGEST) * HOST_CHAR_BIT

- < gdbarch_long_long_bit (parse_gdbarch))

- /* A long long does not fit in a LONGEST. */

- shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);

- else

- shift = (gdbarch_long_long_bit (parse_gdbarch) - 1);

- high_bit = (ULONGEST) 1 << shift;

- unsigned_type = parse_type->builtin_unsigned_long_long;

- signed_type = parse_type->builtin_long_long;

- }

- putithere->typed_val_int.val = n;

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

- has to be unsigned. */

- if (unsigned_p || (n & high_bit))

- {

- putithere->typed_val_int.type = unsigned_type;

- }

- else

- {

- putithere->typed_val_int.type = signed_type;

- }

- return INT;

-struct type_push

- struct type *stored;

- struct type_push *next;

-};

-static struct type_push *tp_top = NULL;

-static void

-push_current_type (void)

- struct type_push *tpnew;

- tpnew = (struct type_push *) xmalloc (sizeof (struct type_push));

- tpnew->next = tp_top;

- tpnew->stored = current_type;

- current_type = NULL;

- tp_top = tpnew;

-static void

-pop_current_type (void)

- struct type_push *tp = tp_top;

- if (tp)

- {

- current_type = tp->stored;

- tp_top = tp->next;

- xfree (tp);

- }

-struct token

- char *operator;

- int token;

- enum exp_opcode opcode;

-};

-static const struct token tokentab3[] =

- {

- {"shr", RSH, BINOP_END},

- {"shl", LSH, BINOP_END},

- {"and", ANDAND, BINOP_END},

- {"div", DIV, BINOP_END},

- {"not", NOT, BINOP_END},

- {"mod", MOD, BINOP_END},

- {"inc", INCREMENT, BINOP_END},

- {"dec", DECREMENT, BINOP_END},

- {"xor", XOR, BINOP_END}

- };

-static const struct token tokentab2[] =

- {

- {"or", OR, BINOP_END},

- {"<>", NOTEQUAL, BINOP_END},

- {"<=", LEQ, BINOP_END},

- {">=", GEQ, BINOP_END},

- {":=", ASSIGN, BINOP_END},

- {"::", COLONCOLON, BINOP_END} };

-/* Allocate uppercased var: */

-/* make an uppercased copy of tokstart. */

-static char *

-uptok (char *tokstart, int namelen)

- int i;

- char *uptokstart = (char *)xmalloc(namelen+1);

- for (i = 0;i <= namelen;i++)

- {

- if ((tokstart[i]>='a' && tokstart[i]<='z'))

- uptokstart[i] = tokstart[i]-('a'-'A');

- else

- uptokstart[i] = tokstart[i];

- }

- uptokstart[namelen]='\0';

- return uptokstart;

-/* This is set if the previously-returned token was a structure

- operator '.'. This is used only when parsing to

- do field name completion. */

-static int last_was_structop;

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

-static int

-yylex (void)

- int c;

- int namelen;

- unsigned int i;

- char *tokstart;

- char *uptokstart;

- char *tokptr;

- int explen, tempbufindex;

- static char *tempbuf;

- static int tempbufsize;

- int saw_structop = last_was_structop;

- last_was_structop = 0;

- retry:

- prev_lexptr = lexptr;

- tokstart = lexptr;

- explen = strlen (lexptr);

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

- if (explen > 2)

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

- if (strncasecmp (tokstart, tokentab3[i].operator, 3) == 0

- && (!isalpha (tokentab3[i].operator[0]) || explen == 3

- || (!isalpha (tokstart[3])

- && !isdigit (tokstart[3]) && tokstart[3] != '_')))

- {

- lexptr += 3;

- yylval.opcode = tokentab3[i].opcode;

- return tokentab3[i].token;

- }

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

- if (explen > 1)

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

- if (strncasecmp (tokstart, tokentab2[i].operator, 2) == 0

- && (!isalpha (tokentab2[i].operator[0]) || explen == 2

- || (!isalpha (tokstart[2])

- && !isdigit (tokstart[2]) && tokstart[2] != '_')))

- {

- lexptr += 2;

- yylval.opcode = tokentab2[i].opcode;

- return tokentab2[i].token;

- }

- switch (c = *tokstart)

- {

- case 0:

- if (saw_structop && search_field)

- return COMPLETE;

- else

- return 0;

- case ' ':

- case '\t':

- case '\n':

- lexptr++;

- goto retry;

- case '\'':

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

- or we have a quoted symbol reference ('foo(int,int)' in object pascal

- for example). */

- lexptr++;

- c = *lexptr++;

- if (c == '\\')

- c = parse_escape (parse_gdbarch, &lexptr);

- else if (c == '\'')

- error (_("Empty character constant."));

- yylval.typed_val_int.val = c;

- yylval.typed_val_int.type = parse_type->builtin_char;

- c = *lexptr++;

- if (c != '\'')

- {

- namelen = skip_quoted (tokstart) - tokstart;

- if (namelen > 2)

- {

- lexptr = tokstart + namelen;

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

- error (_("Unmatched single quote."));

- namelen -= 2;

- tokstart++;

- uptokstart = uptok(tokstart,namelen);

- goto tryname;

- }

- error (_("Invalid character constant."));

- }

- return INT;

- case '(':

- paren_depth++;

- lexptr++;

- return c;

- case ')':

- if (paren_depth == 0)

- return 0;

- paren_depth--;

- lexptr++;

- return c;

- case ',':

- if (comma_terminates && paren_depth == 0)

- return 0;

- lexptr++;

- return c;

- case '.':

- /* Might be a floating point number. */

- if (lexptr[1] < '0' || lexptr[1] > '9')

- {

- if (in_parse_field)

- last_was_structop = 1;

- goto symbol; /* Nope, must be a symbol. */

- }

- /* FALL THRU into number case. */

- case '0':

- case '1':

- case '2':

- case '3':

- case '4':

- case '5':

- case '6':

- case '7':

- case '8':

- case '9':

- {

- /* It's a number. */

- int got_dot = 0, got_e = 0, toktype;

- char *p = tokstart;

- int hex = input_radix > 10;

- if (c == '0' && (p[1] == 'x' || p[1] == 'X'))

- {

- p += 2;

- hex = 1;

- }

- else if (c == '0' && (p[1]=='t' || p[1]=='T'

- || p[1]=='d' || p[1]=='D'))

- {

- p += 2;

- hex = 0;

- }

- for (;; ++p)

- {

- /* This test includes !hex because 'e' is a valid hex digit

- and thus does not indicate a floating point number when

- the radix is hex. */

- if (!hex && !got_e && (*p == 'e' || *p == 'E'))

- got_dot = got_e = 1;

- /* This test does not include !hex, because a '.' always indicates

- a decimal floating point number regardless of the radix. */

- else if (!got_dot && *p == '.')

- got_dot = 1;

- else if (got_e && (p[-1] == 'e' || p[-1] == 'E')

- && (*p == '-' || *p == '+'))

- /* This is the sign of the exponent, not the end of the

- number. */

- continue;

- /* We will take any letters or digits. parse_number will

- complain if past the radix, or if L or U are not final. */

- else if ((*p < '0' || *p > '9')

- && ((*p < 'a' || *p > 'z')

- && (*p < 'A' || *p > 'Z')))

- break;

- }

- toktype = parse_number (tokstart,

- p - tokstart, got_dot | got_e, &yylval);

- if (toktype == ERROR)

- {

- char *err_copy = (char *) alloca (p - tokstart + 1);

- memcpy (err_copy, tokstart, p - tokstart);

- err_copy[p - tokstart] = 0;

- error (_("Invalid number \"%s\"."), err_copy);

- }

- lexptr = p;

- return toktype;

- }

- case '+':

- case '-':

- case '*':

- case '/':

- case '|':

- case '&':

- case '^':

- case '~':

- case '!':

- case '@':

- case '<':

- case '>':

- case '[':

- case ']':

- case '?':

- case ':':

- case '=':

- case '{':

- case '}':

- symbol:

- lexptr++;

- return c;

- case '"':

- /* Build the gdb internal form of the input string in tempbuf,

- translating any standard C escape forms seen. Note that the

- buffer is null byte terminated *only* for the convenience of

- debugging gdb itself and printing the buffer contents when

- the buffer contains no embedded nulls. Gdb does not depend

- upon the buffer being null byte terminated, it uses the length

- string instead. This allows gdb to handle C strings (as well

- as strings in other languages) with embedded null bytes. */

- tokptr = ++tokstart;

- tempbufindex = 0;

- do {

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

- the first one on demand. */

- if (tempbufindex + 1 >= tempbufsize)

- {

- tempbuf = (char *) xrealloc (tempbuf, tempbufsize += 64);

- }

- switch (*tokptr)

- {

- case '\0':

- case '"':

- /* Do nothing, loop will terminate. */

- break;

- case '\\':

- tokptr++;

- c = parse_escape (parse_gdbarch, &tokptr);

- if (c == -1)

- {

- continue;

- }

- tempbuf[tempbufindex++] = c;

- break;

- default:

- tempbuf[tempbufindex++] = *tokptr++;

- break;

- }

- } while ((*tokptr != '"') && (*tokptr != '\0'));

- if (*tokptr++ != '"')

- {

- error (_("Unterminated string in expression."));

- }

- tempbuf[tempbufindex] = '\0'; /* See note above. */

- yylval.sval.ptr = tempbuf;

- yylval.sval.length = tempbufindex;

- lexptr = tokptr;

- return (STRING);

- }

- if (!(c == '_' || c == '$'

- || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))

- /* We must have come across a bad character (e.g. ';'). */

- error (_("Invalid character '%c' in expression."), c);

- /* It's a name. See how long it is. */

- namelen = 0;

- for (c = tokstart[namelen];

- (c == '_' || c == '$' || (c >= '0' && c <= '9')

- || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)

- {

- /* Template parameter lists are part of the name.

- FIXME: This mishandles `print $a<4&&$a>3'. */

- if (c == '<')

- {

- int i = namelen;

- int nesting_level = 1;

- while (tokstart[++i])

- {

- if (tokstart[i] == '<')

- nesting_level++;

- else if (tokstart[i] == '>')

- {

- if (--nesting_level == 0)

- break;

- }

- if (tokstart[i] == '>')

- namelen = i;

- else

- break;

- }

- /* do NOT uppercase internals because of registers !!! */

- c = tokstart[++namelen];

- }

- uptokstart = uptok(tokstart,namelen);

- /* The token "if" terminates the expression and is NOT

- removed from the input stream. */

- if (namelen == 2 && uptokstart[0] == 'I' && uptokstart[1] == 'F')

- {

- xfree (uptokstart);

- return 0;

- }

- lexptr += namelen;

- tryname:

- /* Catch specific keywords. Should be done with a data structure. */

- switch (namelen)

- {

- case 6:

- if (strcmp (uptokstart, "OBJECT") == 0)

- {

- xfree (uptokstart);

- return CLASS;

- }

- if (strcmp (uptokstart, "RECORD") == 0)

- {

- xfree (uptokstart);

- return STRUCT;

- }

- if (strcmp (uptokstart, "SIZEOF") == 0)

- {

- xfree (uptokstart);

- return SIZEOF;

- }

- break;

- case 5:

- if (strcmp (uptokstart, "CLASS") == 0)

- {

- xfree (uptokstart);

- return CLASS;

- }

- if (strcmp (uptokstart, "FALSE") == 0)

- {

- yylval.lval = 0;

- xfree (uptokstart);

- return FALSEKEYWORD;

- }

- break;

- case 4:

- if (strcmp (uptokstart, "TRUE") == 0)

- {

- yylval.lval = 1;

- xfree (uptokstart);

- return TRUEKEYWORD;

- }

- if (strcmp (uptokstart, "SELF") == 0)

- {

- /* Here we search for 'this' like

- inserted in FPC stabs debug info. */

- static const char this_name[] = "this";

- if (lookup_symbol (this_name, expression_context_block,

- VAR_DOMAIN, (int *) NULL))

- {

- xfree (uptokstart);

- return THIS;

- }

- break;

- default:

- break;

- }

- yylval.sval.ptr = tokstart;

- yylval.sval.length = namelen;

- if (*tokstart == '$')

- {

- char c;

- /* $ is the normal prefix for pascal hexadecimal values

- but this conflicts with the GDB use for debugger variables

- so in expression to enter hexadecimal values

- we still need to use C syntax with 0xff */

- write_dollar_variable (yylval.sval);

- c = tokstart[namelen];

- tokstart[namelen] = 0;

- intvar = lookup_only_internalvar (++tokstart);

- --tokstart;

- tokstart[namelen] = c;

- xfree (uptokstart);

- return VARIABLE;

- }

- /* Use token-type BLOCKNAME for symbols that happen to be defined as

- functions or symtabs. If this is not so, then ...

- Use token-type TYPENAME for symbols that happen to be defined

- currently as names of types; NAME for other symbols.

- The caller is not constrained to care about the distinction. */

- {

- char *tmp = copy_name (yylval.sval);

- struct symbol *sym;

- int is_a_field_of_this = 0;

- int is_a_field = 0;

- int hextype;

- if (search_field && current_type)

- is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL);

- if (is_a_field || in_parse_field)

- sym = NULL;

- else

- sym = lookup_symbol (tmp, expression_context_block,

- VAR_DOMAIN, &is_a_field_of_this);

- /* second chance uppercased (as Free Pascal does). */

- if (!sym && !is_a_field_of_this && !is_a_field)

- {

- for (i = 0; i <= namelen; i++)

- {

- if ((tmp[i] >= 'a' && tmp[i] <= 'z'))

- tmp[i] -= ('a'-'A');

- }

- if (search_field && current_type)

- is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL);

- if (is_a_field || in_parse_field)

- sym = NULL;

- else

- sym = lookup_symbol (tmp, expression_context_block,

- VAR_DOMAIN, &is_a_field_of_this);

- if (sym || is_a_field_of_this || is_a_field)

- for (i = 0; i <= namelen; i++)

- {

- if ((tokstart[i] >= 'a' && tokstart[i] <= 'z'))

- tokstart[i] -= ('a'-'A');

- }

- /* Third chance Capitalized (as GPC does). */

- if (!sym && !is_a_field_of_this && !is_a_field)

- {

- for (i = 0; i <= namelen; i++)

- {

- if (i == 0)

- {

- if ((tmp[i] >= 'a' && tmp[i] <= 'z'))

- tmp[i] -= ('a'-'A');

- }

- else

- if ((tmp[i] >= 'A' && tmp[i] <= 'Z'))

- tmp[i] -= ('A'-'a');

- }

- if (search_field && current_type)

- is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL);

- if (is_a_field || in_parse_field)

- sym = NULL;

- else

- sym = lookup_symbol (tmp, expression_context_block,

- VAR_DOMAIN, &is_a_field_of_this);

- if (sym || is_a_field_of_this || is_a_field)

- for (i = 0; i <= namelen; i++)

- {

- if (i == 0)

- {

- if ((tokstart[i] >= 'a' && tokstart[i] <= 'z'))

- tokstart[i] -= ('a'-'A');

- }

- else

- if ((tokstart[i] >= 'A' && tokstart[i] <= 'Z'))

- tokstart[i] -= ('A'-'a');

- }

- if (is_a_field)

- {

- tempbuf = (char *) xrealloc (tempbuf, namelen + 1);

- strncpy (tempbuf, tokstart, namelen); tempbuf [namelen] = 0;

- yylval.sval.ptr = tempbuf;

- yylval.sval.length = namelen;

- xfree (uptokstart);

- return FIELDNAME;

- }

- /* Call lookup_symtab, not lookup_partial_symtab, in case there are

- no psymtabs (coff, xcoff, or some future change to blow away the

- psymtabs once once symbols are read). */

- if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK)

- || lookup_symtab (tmp))

- {

- yylval.ssym.sym = sym;

- yylval.ssym.is_a_field_of_this = is_a_field_of_this;

- xfree (uptokstart);

- return BLOCKNAME;

- }

- if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)

- {

-#if 1

- /* Despite the following flaw, we need to keep this code enabled.

- Because we can get called from check_stub_method, if we don't

- handle nested types then it screws many operations in any

- program which uses nested types. */

- /* In "A::x", if x is a member function of A and there happens

- to be a type (nested or not, since the stabs don't make that

- distinction) named x, then this code incorrectly thinks we

- are dealing with nested types rather than a member function. */

- char *p;

- char *namestart;

- struct symbol *best_sym;

- /* Look ahead to detect nested types. This probably should be

- done in the grammar, but trying seemed to introduce a lot

- of shift/reduce and reduce/reduce conflicts. It's possible

- that it could be done, though. Or perhaps a non-grammar, but

- less ad hoc, approach would work well. */

- /* Since we do not currently have any way of distinguishing

- a nested type from a non-nested one (the stabs don't tell

- us whether a type is nested), we just ignore the

- containing type. */

- p = lexptr;

- best_sym = sym;

- while (1)

- {

- /* Skip whitespace. */

- while (*p == ' ' || *p == '\t' || *p == '\n')

- ++p;

- if (*p == ':' && p[1] == ':')

- {

- /* Skip the `::'. */

- p += 2;

- /* Skip whitespace. */

- while (*p == ' ' || *p == '\t' || *p == '\n')

- ++p;

- namestart = p;

- while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')

- || (*p >= 'a' && *p <= 'z')

- || (*p >= 'A' && *p <= 'Z'))

- ++p;

- if (p != namestart)

- {

- struct symbol *cur_sym;

- /* As big as the whole rest of the expression, which is

- at least big enough. */

- char *ncopy = alloca (strlen (tmp)+strlen (namestart)+3);

- char *tmp1;

- tmp1 = ncopy;

- memcpy (tmp1, tmp, strlen (tmp));

- tmp1 += strlen (tmp);

- memcpy (tmp1, "::", 2);

- tmp1 += 2;

- memcpy (tmp1, namestart, p - namestart);

- tmp1[p - namestart] = '\0';

- cur_sym = lookup_symbol (ncopy, expression_context_block,

- VAR_DOMAIN, (int *) NULL);

- if (cur_sym)

- {

- if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)

- {

- best_sym = cur_sym;

- lexptr = p;

- }

- else

- break;

- }

- else

- break;

- }

- else

- break;

- }

- else

- break;

- }

- yylval.tsym.type = SYMBOL_TYPE (best_sym);

-#else /* not 0 */

- yylval.tsym.type = SYMBOL_TYPE (sym);

-#endif /* not 0 */

- xfree (uptokstart);

- return TYPENAME;

- }

- yylval.tsym.type

- = language_lookup_primitive_type_by_name (parse_language,

- parse_gdbarch, tmp);

- if (yylval.tsym.type != NULL)

- {

- xfree (uptokstart);

- return TYPENAME;

- }

- /* Input names that aren't symbols but ARE valid hex numbers,

- when the input radix permits them, can be names or numbers

- depending on the parse. Note we support radixes > 16 here. */

- if (!sym

- && ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)

- || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))

- {

- YYSTYPE newlval; /* Its value is ignored. */

- hextype = parse_number (tokstart, namelen, 0, &newlval);

- if (hextype == INT)

- {

- yylval.ssym.sym = sym;

- yylval.ssym.is_a_field_of_this = is_a_field_of_this;

- xfree (uptokstart);

- return NAME_OR_INT;

- }

- xfree(uptokstart);

- /* Any other kind of symbol. */

- yylval.ssym.sym = sym;

- yylval.ssym.is_a_field_of_this = is_a_field_of_this;

- return NAME;

- }

-void

-yyerror (char *msg)

- if (prev_lexptr)

- lexptr = prev_lexptr;

- error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);

« no previous file with comments | « gdb/osf-share/cma_util.h ('k') | gdb/p-exp.y » ('j') | no next file with comments »