From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 2663 invoked by alias); 15 Jan 2012 19:10:25 -0000 Received: (qmail 2644 invoked by uid 22791); 15 Jan 2012 19:10:22 -0000 X-SWARE-Spam-Status: No, hits=-6.6 required=5.0 tests=AWL,BAYES_00,RCVD_IN_DNSWL_HI,SPF_HELO_PASS,TW_CP,TW_XF,TW_YY,T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Sun, 15 Jan 2012 19:10:06 +0000 Received: from int-mx11.intmail.prod.int.phx2.redhat.com (int-mx11.intmail.prod.int.phx2.redhat.com [10.5.11.24]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id q0FJA6Mi028790 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK) for ; Sun, 15 Jan 2012 14:10:06 -0500 Received: from psique ([10.3.112.11]) by int-mx11.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id q0FJA2YM018805 for ; Sun, 15 Jan 2012 14:10:04 -0500 From: Sergio Durigan Junior To: gdb-patches@sourceware.org Subject: [RFC 8/8] Pascal language References: X-URL: http://www.redhat.com Date: Sun, 15 Jan 2012 20:34:00 -0000 In-Reply-To: (Sergio Durigan Junior's message of "Sun, 15 Jan 2012 16:48:52 -0200") Message-ID: User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/23.3 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2012-01/txt/msg00534.txt.bz2 Hello, This is the patch for the Pascal language. I forgot to mention in the other patches: I also took the liberty (in all files) to cleanup #if 0 functions, and to convert old-style function declarations to use the "new" style, i.e.: static void foo (bar) int bar; { /* ... */ } becomes: static void foo (int bar) { /* ... */ } Thanks, Sergio. diff --git a/gdb/p-exp.y b/gdb/p-exp.y index 7b05d58..a3d75e4 100644 --- a/gdb/p-exp.y +++ b/gdb/p-exp.y @@ -56,7 +56,7 @@ #include "objfiles.h" /* For have_full_symbols and have_partial_symbols. */ #include "block.h" -#define parse_type builtin_type (parse_gdbarch) +#define parse_type(ps) builtin_type (parse_gdbarch (ps)) /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc), as well as gratuitiously global symbol names, so we can have multiple @@ -112,15 +112,18 @@ #define YYFPRINTF parser_fprintf -int yyparse (void); +int yyparse (struct parser_state *); -static int yylex (void); +static int yylex (struct parser_state *); -void yyerror (char *); +void yyerror (struct parser_state *, char *); static char * uptok (char *, int); %} +%parse-param {struct parser_state *ps} +%lex-param {struct parser_state *ps} + /* Although the yacc "value" of an expression is not used, since the result is stored in the structure being created, other node types do have values. */ @@ -152,7 +155,7 @@ static char * uptok (char *, int); %{ /* YYSTYPE gets defined by %union */ -static int parse_number (char *, int, int, YYSTYPE *); +static int parse_number (struct parser_state *, char *, int, int, YYSTYPE *); static struct type *current_type; static struct internalvar *intvar; @@ -245,44 +248,44 @@ normal_start : ; type_exp: type - { write_exp_elt_opcode(OP_TYPE); - write_exp_elt_type($1); - write_exp_elt_opcode(OP_TYPE); + { write_exp_elt_opcode (ps, OP_TYPE); + write_exp_elt_type (ps, $1); + write_exp_elt_opcode (ps, OP_TYPE); current_type = $1; } ; /* Expressions, including the comma operator. */ exp1 : exp | exp1 ',' exp - { write_exp_elt_opcode (BINOP_COMMA); } + { write_exp_elt_opcode (ps, BINOP_COMMA); } ; /* Expressions, not including the comma operator. */ exp : exp '^' %prec UNARY - { write_exp_elt_opcode (UNOP_IND); + { write_exp_elt_opcode (ps, UNOP_IND); if (current_type) current_type = TYPE_TARGET_TYPE (current_type); } ; exp : '@' exp %prec UNARY - { write_exp_elt_opcode (UNOP_ADDR); + { write_exp_elt_opcode (ps, UNOP_ADDR); if (current_type) current_type = TYPE_POINTER_TYPE (current_type); } ; exp : '-' exp %prec UNARY - { write_exp_elt_opcode (UNOP_NEG); } + { write_exp_elt_opcode (ps, UNOP_NEG); } ; exp : NOT exp %prec UNARY - { write_exp_elt_opcode (UNOP_LOGICAL_NOT); } + { write_exp_elt_opcode (ps, UNOP_LOGICAL_NOT); } ; exp : INCREMENT '(' exp ')' %prec UNARY - { write_exp_elt_opcode (UNOP_PREINCREMENT); } + { write_exp_elt_opcode (ps, UNOP_PREINCREMENT); } ; exp : DECREMENT '(' exp ')' %prec UNARY - { write_exp_elt_opcode (UNOP_PREDECREMENT); } + { write_exp_elt_opcode (ps, UNOP_PREDECREMENT); } ; @@ -291,9 +294,9 @@ field_exp : exp '.' %prec UNARY ; exp : field_exp FIELDNAME - { write_exp_elt_opcode (STRUCTOP_STRUCT); - write_exp_string ($2); - write_exp_elt_opcode (STRUCTOP_STRUCT); + { write_exp_elt_opcode (ps, STRUCTOP_STRUCT); + write_exp_string (ps, $2); + write_exp_elt_opcode (ps, STRUCTOP_STRUCT); search_field = 0; if (current_type) { @@ -309,10 +312,10 @@ exp : field_exp FIELDNAME exp : field_exp name - { mark_struct_expression (); - write_exp_elt_opcode (STRUCTOP_STRUCT); - write_exp_string ($2); - write_exp_elt_opcode (STRUCTOP_STRUCT); + { mark_struct_expression (ps); + write_exp_elt_opcode (ps, STRUCTOP_STRUCT); + write_exp_string (ps, $2); + write_exp_elt_opcode (ps, STRUCTOP_STRUCT); search_field = 0; if (current_type) { @@ -328,12 +331,12 @@ exp : field_exp name exp : field_exp COMPLETE { struct stoken s; - mark_struct_expression (); - write_exp_elt_opcode (STRUCTOP_STRUCT); + mark_struct_expression (ps); + write_exp_elt_opcode (ps, STRUCTOP_STRUCT); s.ptr = ""; s.length = 0; - write_exp_string (s); - write_exp_elt_opcode (STRUCTOP_STRUCT); } + write_exp_string (ps, s); + write_exp_elt_opcode (ps, STRUCTOP_STRUCT); } ; exp : exp '[' @@ -351,14 +354,14 @@ exp : exp '[' 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); + write_exp_elt_opcode (ps, STRUCTOP_STRUCT); + write_exp_string (ps, stringsval); + write_exp_elt_opcode (ps, STRUCTOP_STRUCT); } push_current_type (); } exp1 ']' { pop_current_type (); - write_exp_elt_opcode (BINOP_SUBSCRIPT); + write_exp_elt_opcode (ps, BINOP_SUBSCRIPT); if (current_type) current_type = TYPE_TARGET_TYPE (current_type); } ; @@ -369,9 +372,9 @@ exp : exp '(' { push_current_type (); start_arglist (); } arglist ')' %prec ARROW - { write_exp_elt_opcode (OP_FUNCALL); - write_exp_elt_longcst ((LONGEST) end_arglist ()); - write_exp_elt_opcode (OP_FUNCALL); + { write_exp_elt_opcode (ps, OP_FUNCALL); + write_exp_elt_longcst (ps, (LONGEST) end_arglist ()); + write_exp_elt_opcode (ps, OP_FUNCALL); pop_current_type (); if (current_type) current_type = TYPE_TARGET_TYPE (current_type); @@ -392,11 +395,11 @@ exp : type '(' exp ')' %prec UNARY if ((TYPE_CODE (current_type) == TYPE_CODE_PTR) && (TYPE_CODE (TYPE_TARGET_TYPE (current_type)) == TYPE_CODE_CLASS) && (TYPE_CODE ($1) == TYPE_CODE_CLASS)) - write_exp_elt_opcode (UNOP_IND); + write_exp_elt_opcode (ps, UNOP_IND); } - write_exp_elt_opcode (UNOP_CAST); - write_exp_elt_type ($1); - write_exp_elt_opcode (UNOP_CAST); + write_exp_elt_opcode (ps, UNOP_CAST); + write_exp_elt_type (ps, $1); + write_exp_elt_opcode (ps, UNOP_CAST); current_type = $1; } ; @@ -407,7 +410,7 @@ exp : '(' exp1 ')' /* Binary operators in order of decreasing precedence. */ exp : exp '*' exp - { write_exp_elt_opcode (BINOP_MUL); } + { write_exp_elt_opcode (ps, BINOP_MUL); } ; exp : exp '/' { @@ -419,135 +422,137 @@ exp : exp '/' { 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); + write_exp_elt_opcode (ps, UNOP_CAST); + write_exp_elt_type (ps, + parse_type (ps) + ->builtin_long_double); + current_type = parse_type (ps)->builtin_long_double; + write_exp_elt_opcode (ps, UNOP_CAST); leftdiv_is_integer = 0; } - write_exp_elt_opcode (BINOP_DIV); + write_exp_elt_opcode (ps, BINOP_DIV); } ; exp : exp DIV exp - { write_exp_elt_opcode (BINOP_INTDIV); } + { write_exp_elt_opcode (ps, BINOP_INTDIV); } ; exp : exp MOD exp - { write_exp_elt_opcode (BINOP_REM); } + { write_exp_elt_opcode (ps, BINOP_REM); } ; exp : exp '+' exp - { write_exp_elt_opcode (BINOP_ADD); } + { write_exp_elt_opcode (ps, BINOP_ADD); } ; exp : exp '-' exp - { write_exp_elt_opcode (BINOP_SUB); } + { write_exp_elt_opcode (ps, BINOP_SUB); } ; exp : exp LSH exp - { write_exp_elt_opcode (BINOP_LSH); } + { write_exp_elt_opcode (ps, BINOP_LSH); } ; exp : exp RSH exp - { write_exp_elt_opcode (BINOP_RSH); } + { write_exp_elt_opcode (ps, BINOP_RSH); } ; exp : exp '=' exp - { write_exp_elt_opcode (BINOP_EQUAL); - current_type = parse_type->builtin_bool; + { write_exp_elt_opcode (ps, BINOP_EQUAL); + current_type = parse_type (ps)->builtin_bool; } ; exp : exp NOTEQUAL exp - { write_exp_elt_opcode (BINOP_NOTEQUAL); - current_type = parse_type->builtin_bool; + { write_exp_elt_opcode (ps, BINOP_NOTEQUAL); + current_type = parse_type (ps)->builtin_bool; } ; exp : exp LEQ exp - { write_exp_elt_opcode (BINOP_LEQ); - current_type = parse_type->builtin_bool; + { write_exp_elt_opcode (ps, BINOP_LEQ); + current_type = parse_type (ps)->builtin_bool; } ; exp : exp GEQ exp - { write_exp_elt_opcode (BINOP_GEQ); - current_type = parse_type->builtin_bool; + { write_exp_elt_opcode (ps, BINOP_GEQ); + current_type = parse_type (ps)->builtin_bool; } ; exp : exp '<' exp - { write_exp_elt_opcode (BINOP_LESS); - current_type = parse_type->builtin_bool; + { write_exp_elt_opcode (ps, BINOP_LESS); + current_type = parse_type (ps)->builtin_bool; } ; exp : exp '>' exp - { write_exp_elt_opcode (BINOP_GTR); - current_type = parse_type->builtin_bool; + { write_exp_elt_opcode (ps, BINOP_GTR); + current_type = parse_type (ps)->builtin_bool; } ; exp : exp ANDAND exp - { write_exp_elt_opcode (BINOP_BITWISE_AND); } + { write_exp_elt_opcode (ps, BINOP_BITWISE_AND); } ; exp : exp XOR exp - { write_exp_elt_opcode (BINOP_BITWISE_XOR); } + { write_exp_elt_opcode (ps, BINOP_BITWISE_XOR); } ; exp : exp OR exp - { write_exp_elt_opcode (BINOP_BITWISE_IOR); } + { write_exp_elt_opcode (ps, BINOP_BITWISE_IOR); } ; exp : exp ASSIGN exp - { write_exp_elt_opcode (BINOP_ASSIGN); } + { write_exp_elt_opcode (ps, BINOP_ASSIGN); } ; exp : TRUEKEYWORD - { write_exp_elt_opcode (OP_BOOL); - write_exp_elt_longcst ((LONGEST) $1); - current_type = parse_type->builtin_bool; - write_exp_elt_opcode (OP_BOOL); } + { write_exp_elt_opcode (ps, OP_BOOL); + write_exp_elt_longcst (ps, (LONGEST) $1); + current_type = parse_type (ps)->builtin_bool; + write_exp_elt_opcode (ps, OP_BOOL); } ; exp : FALSEKEYWORD - { write_exp_elt_opcode (OP_BOOL); - write_exp_elt_longcst ((LONGEST) $1); - current_type = parse_type->builtin_bool; - write_exp_elt_opcode (OP_BOOL); } + { write_exp_elt_opcode (ps, OP_BOOL); + write_exp_elt_longcst (ps, (LONGEST) $1); + current_type = parse_type (ps)->builtin_bool; + write_exp_elt_opcode (ps, OP_BOOL); } ; exp : INT - { write_exp_elt_opcode (OP_LONG); - write_exp_elt_type ($1.type); + { write_exp_elt_opcode (ps, OP_LONG); + write_exp_elt_type (ps, $1.type); current_type = $1.type; - write_exp_elt_longcst ((LONGEST)($1.val)); - write_exp_elt_opcode (OP_LONG); } + write_exp_elt_longcst (ps, (LONGEST)($1.val)); + write_exp_elt_opcode (ps, OP_LONG); } ; exp : NAME_OR_INT { YYSTYPE val; - parse_number ($1.stoken.ptr, + parse_number (ps, $1.stoken.ptr, $1.stoken.length, 0, &val); - write_exp_elt_opcode (OP_LONG); - write_exp_elt_type (val.typed_val_int.type); + write_exp_elt_opcode (ps, OP_LONG); + write_exp_elt_type (ps, val.typed_val_int.type); current_type = val.typed_val_int.type; - write_exp_elt_longcst ((LONGEST) + write_exp_elt_longcst (ps, (LONGEST) val.typed_val_int.val); - write_exp_elt_opcode (OP_LONG); + write_exp_elt_opcode (ps, OP_LONG); } ; exp : FLOAT - { write_exp_elt_opcode (OP_DOUBLE); - write_exp_elt_type ($1.type); + { write_exp_elt_opcode (ps, OP_DOUBLE); + write_exp_elt_type (ps, $1.type); current_type = $1.type; - write_exp_elt_dblcst ($1.dval); - write_exp_elt_opcode (OP_DOUBLE); } + write_exp_elt_dblcst (ps, $1.dval); + write_exp_elt_opcode (ps, OP_DOUBLE); } ; exp : variable @@ -560,7 +565,7 @@ exp : VARIABLE struct value * val, * mark; mark = value_mark (); - val = value_of_internalvar (parse_gdbarch, + val = value_of_internalvar (parse_gdbarch (ps), intvar); current_type = value_type (val); value_release_to_mark (mark); @@ -569,15 +574,16 @@ exp : VARIABLE ; exp : SIZEOF '(' type ')' %prec UNARY - { write_exp_elt_opcode (OP_LONG); - write_exp_elt_type (parse_type->builtin_int); + { write_exp_elt_opcode (ps, OP_LONG); + write_exp_elt_type (ps, parse_type (ps)->builtin_int); CHECK_TYPEDEF ($3); - write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3)); - write_exp_elt_opcode (OP_LONG); } + write_exp_elt_longcst (ps, + (LONGEST) TYPE_LENGTH ($3)); + write_exp_elt_opcode (ps, OP_LONG); } ; exp : SIZEOF '(' exp ')' %prec UNARY - { write_exp_elt_opcode (UNOP_SIZEOF); } + { write_exp_elt_opcode (ps, UNOP_SIZEOF); } exp : STRING { /* C strings are converted into array constants with @@ -588,19 +594,23 @@ exp : STRING char *sp = $1.ptr; int count = $1.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 (ps, OP_LONG); + write_exp_elt_type (ps, + parse_type (ps) + ->builtin_char); + write_exp_elt_longcst (ps, (LONGEST) (*sp++)); + write_exp_elt_opcode (ps, 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) ($1.length)); - write_exp_elt_opcode (OP_ARRAY); } + write_exp_elt_opcode (ps, OP_LONG); + write_exp_elt_type (ps, + parse_type (ps) + ->builtin_char); + write_exp_elt_longcst (ps, (LONGEST)'\0'); + write_exp_elt_opcode (ps, OP_LONG); + write_exp_elt_opcode (ps, OP_ARRAY); + write_exp_elt_longcst (ps, (LONGEST) 0); + write_exp_elt_longcst (ps, (LONGEST) ($1.length)); + write_exp_elt_opcode (ps, OP_ARRAY); } ; /* Object pascal */ @@ -608,10 +618,10 @@ exp : THIS { struct value * this_val; struct type * this_type; - write_exp_elt_opcode (OP_THIS); - write_exp_elt_opcode (OP_THIS); + write_exp_elt_opcode (ps, OP_THIS); + write_exp_elt_opcode (ps, OP_THIS); /* We need type of this. */ - this_val = value_of_this_silent (parse_language); + this_val = value_of_this_silent (parse_language (ps)); if (this_val) this_type = value_type (this_val); else @@ -621,7 +631,7 @@ exp : THIS if (TYPE_CODE (this_type) == TYPE_CODE_PTR) { this_type = TYPE_TARGET_TYPE (this_type); - write_exp_elt_opcode (UNOP_IND); + write_exp_elt_opcode (ps, UNOP_IND); } } @@ -667,11 +677,11 @@ variable: block COLONCOLON name error (_("No symbol \"%s\" in specified context."), copy_name ($3)); - write_exp_elt_opcode (OP_VAR_VALUE); + write_exp_elt_opcode (ps, 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); } + write_exp_elt_block (ps, block_found); + write_exp_elt_sym (ps, sym); + write_exp_elt_opcode (ps, OP_VAR_VALUE); } ; qualified_name: typebase COLONCOLON name @@ -682,10 +692,10 @@ qualified_name: typebase COLONCOLON name 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 ($3); - write_exp_elt_opcode (OP_SCOPE); + write_exp_elt_opcode (ps, OP_SCOPE); + write_exp_elt_type (ps, type); + write_exp_string (ps, $3); + write_exp_elt_opcode (ps, OP_SCOPE); } ; @@ -701,16 +711,16 @@ variable: qualified_name 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); + write_exp_elt_opcode (ps, OP_VAR_VALUE); + write_exp_elt_block (ps, NULL); + write_exp_elt_sym (ps, sym); + write_exp_elt_opcode (ps, OP_VAR_VALUE); break; } msymbol = lookup_minimal_symbol (name, NULL, NULL); if (msymbol != NULL) - write_exp_msymbol (msymbol); + write_exp_msymbol (ps, msymbol); else if (!have_full_symbols () && !have_partial_symbols ()) error (_("No symbol table is loaded. " @@ -734,13 +744,13 @@ variable: name_not_typename innermost_block = block_found; } - write_exp_elt_opcode (OP_VAR_VALUE); + write_exp_elt_opcode (ps, 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); + write_exp_elt_block (ps, NULL); + write_exp_elt_sym (ps, sym); + write_exp_elt_opcode (ps, OP_VAR_VALUE); current_type = sym->type; } else if ($1.is_a_field_of_this) { @@ -753,13 +763,13 @@ variable: name_not_typename || contained_in (block_found, innermost_block)) innermost_block = block_found; - write_exp_elt_opcode (OP_THIS); - write_exp_elt_opcode (OP_THIS); - write_exp_elt_opcode (STRUCTOP_PTR); - write_exp_string ($1.stoken); - write_exp_elt_opcode (STRUCTOP_PTR); + write_exp_elt_opcode (ps, OP_THIS); + write_exp_elt_opcode (ps, OP_THIS); + write_exp_elt_opcode (ps, STRUCTOP_PTR); + write_exp_string (ps, $1.stoken); + write_exp_elt_opcode (ps, STRUCTOP_PTR); /* We need type of this. */ - this_val = value_of_this_silent (parse_language); + this_val = value_of_this_silent (parse_language (ps)); if (this_val) this_type = value_type (this_val); else @@ -779,7 +789,7 @@ variable: name_not_typename msymbol = lookup_minimal_symbol (arg, NULL, NULL); if (msymbol != NULL) - write_exp_msymbol (msymbol); + write_exp_msymbol (ps, msymbol); else if (!have_full_symbols () && !have_partial_symbols ()) error (_("No symbol table is loaded. " @@ -848,7 +858,8 @@ name_not_typename : NAME /*** Needs some error checking for the float case ***/ static int -parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere) +parse_number (struct parser_state *ps, 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. */ @@ -873,7 +884,7 @@ parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere) if (parsed_float) { - if (! parse_c_float (parse_gdbarch, p, len, + if (! parse_c_float (parse_gdbarch (ps), p, len, &putithere->typed_val_float.dval, &putithere->typed_val_float.type)) return ERROR; @@ -979,9 +990,9 @@ parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere) un = (ULONGEST)n >> 2; if (long_p == 0 - && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0) + && (un >> (gdbarch_int_bit (parse_gdbarch (ps)) - 2)) == 0) { - high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1); + high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch (ps)) - 1); /* A large decimal (not hex or octal) constant (between INT_MAX and UINT_MAX) is a long or unsigned long, according to ANSI, @@ -989,28 +1000,28 @@ parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere) 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; + unsigned_type = parse_type (ps)->builtin_unsigned_int; + signed_type = parse_type (ps)->builtin_int; } else if (long_p <= 1 - && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0) + && (un >> (gdbarch_long_bit (parse_gdbarch (ps)) - 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; + high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch (ps)) - 1); + unsigned_type = parse_type (ps)->builtin_unsigned_long; + signed_type = parse_type (ps)->builtin_long; } else { int shift; if (sizeof (ULONGEST) * HOST_CHAR_BIT - < gdbarch_long_long_bit (parse_gdbarch)) + < gdbarch_long_long_bit (parse_gdbarch (ps))) /* 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); + shift = (gdbarch_long_long_bit (parse_gdbarch (ps)) - 1); high_bit = (ULONGEST) 1 << shift; - unsigned_type = parse_type->builtin_unsigned_long_long; - signed_type = parse_type->builtin_long_long; + unsigned_type = parse_type (ps)->builtin_unsigned_long_long; + signed_type = parse_type (ps)->builtin_long_long; } putithere->typed_val_int.val = n; @@ -1093,9 +1104,7 @@ static const struct token tokentab2[] = /* Allocate uppercased var: */ /* make an uppercased copy of tokstart. */ -static char * uptok (tokstart, namelen) - char *tokstart; - int namelen; +static char * uptok (char *tokstart, int namelen) { int i; char *uptokstart = (char *)malloc(namelen+1); @@ -1118,7 +1127,7 @@ static int last_was_structop; /* Read one token, getting characters through lexptr. */ static int -yylex (void) +yylex (struct parser_state *ps) { int c; int namelen; @@ -1185,12 +1194,12 @@ yylex (void) lexptr++; c = *lexptr++; if (c == '\\') - c = parse_escape (parse_gdbarch, &lexptr); + c = parse_escape (parse_gdbarch (ps), &lexptr); else if (c == '\'') error (_("Empty character constant.")); yylval.typed_val_int.val = c; - yylval.typed_val_int.type = parse_type->builtin_char; + yylval.typed_val_int.type = parse_type (ps)->builtin_char; c = *lexptr++; if (c != '\'') @@ -1290,7 +1299,7 @@ yylex (void) && (*p < 'A' || *p > 'Z'))) break; } - toktype = parse_number (tokstart, + toktype = parse_number (ps, tokstart, p - tokstart, got_dot | got_e, &yylval); if (toktype == ERROR) { @@ -1357,7 +1366,7 @@ yylex (void) break; case '\\': tokptr++; - c = parse_escape (parse_gdbarch, &tokptr); + c = parse_escape (parse_gdbarch (ps), &tokptr); if (c == -1) { continue; @@ -1499,7 +1508,7 @@ yylex (void) 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); + write_dollar_variable (ps, yylval.sval); c = tokstart[namelen]; tokstart[namelen] = 0; intvar = lookup_only_internalvar (++tokstart); @@ -1697,8 +1706,8 @@ yylex (void) return TYPENAME; } yylval.tsym.type - = language_lookup_primitive_type_by_name (parse_language, - parse_gdbarch, tmp); + = language_lookup_primitive_type_by_name (parse_language (ps), + parse_gdbarch (ps), tmp); if (yylval.tsym.type != NULL) { free (uptokstart); @@ -1713,7 +1722,7 @@ yylex (void) || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10))) { YYSTYPE newlval; /* Its value is ignored. */ - hextype = parse_number (tokstart, namelen, 0, &newlval); + hextype = parse_number (ps, tokstart, namelen, 0, &newlval); if (hextype == INT) { yylval.ssym.sym = sym; @@ -1732,8 +1741,7 @@ yylex (void) } void -yyerror (msg) - char *msg; +yyerror (struct parser_state *ps, char *msg) { if (prev_lexptr) lexptr = prev_lexptr; diff --git a/gdb/p-lang.h b/gdb/p-lang.h index 308b7b5..d07a249 100644 --- a/gdb/p-lang.h +++ b/gdb/p-lang.h @@ -20,13 +20,15 @@ /* This file is derived from c-lang.h */ struct value; +struct parser_state; /* Defined in p-lang.c */ extern const char *pascal_main_name (void); -extern int pascal_parse (void); /* Defined in p-exp.y */ +extern int pascal_parse (struct parser_state *); /* Defined in p-exp.y */ -extern void pascal_error (char *); /* Defined in p-exp.y */ +extern void pascal_error (struct parser_state *, char *); /* Defined + in p-exp.y */ /* Defined in p-typeprint.c */ extern void pascal_print_type (struct type *, const char *, struct ui_file *,