From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 29731 invoked by alias); 15 Jan 2012 19:01:08 -0000 Received: (qmail 29369 invoked by uid 22791); 15 Jan 2012 19:00:58 -0000 X-SWARE-Spam-Status: No, hits=-3.9 required=5.0 tests=AWL,BAYES_00,KAM_STOCKTIP,RCVD_IN_DNSWL_HI,SPF_HELO_PASS,TW_CP,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:00:38 +0000 Received: from int-mx01.intmail.prod.int.phx2.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id q0FJ0c21027746 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK) for ; Sun, 15 Jan 2012 14:00:38 -0500 Received: from psique ([10.3.112.11]) by int-mx01.intmail.prod.int.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id q0FJ0Xmh017684 for ; Sun, 15 Jan 2012 14:00:35 -0500 From: Sergio Durigan Junior To: gdb-patches@sourceware.org Subject: [RFC 3/8] Ada language References: X-URL: http://www.redhat.com Date: Sun, 15 Jan 2012 19:04: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/msg00529.txt.bz2 Hi, This patch reflects the changes for Ada language files. Thanks, Sergio. diff --git a/gdb/ada-exp.y b/gdb/ada-exp.y index d8c21a4..7c3be14 100644 --- a/gdb/ada-exp.y +++ b/gdb/ada-exp.y @@ -50,7 +50,7 @@ #include "frame.h" #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 @@ -114,51 +114,58 @@ static struct stoken empty_stoken = { "", 0 }; * NULL. */ static struct type *type_qualifier; -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 struct stoken string_to_operator (struct stoken); -static void write_int (LONGEST, struct type *); +static void write_int (struct parser_state *, LONGEST, struct type *); -static void write_object_renaming (struct block *, const char *, int, +static void write_object_renaming (struct parser_state *, struct block *, + const char *, int, const char *, int); -static struct type* write_var_or_type (struct block *, struct stoken); +static struct type* write_var_or_type (struct parser_state *, struct block *, + struct stoken); -static void write_name_assoc (struct stoken); +static void write_name_assoc (struct parser_state *, struct stoken); -static void write_exp_op_with_string (enum exp_opcode, struct stoken); +static void write_exp_op_with_string (struct parser_state *, enum exp_opcode, + struct stoken); static struct block *block_lookup (struct block *, char *); static LONGEST convert_char_literal (struct type *, LONGEST); -static void write_ambiguous_var (struct block *, char *, int); +static void write_ambiguous_var (struct parser_state *, struct block *, + char *, int); -static struct type *type_int (void); +static struct type *type_int (struct parser_state *); -static struct type *type_long (void); +static struct type *type_long (struct parser_state *); -static struct type *type_long_long (void); +static struct type *type_long_long (struct parser_state *); -static struct type *type_float (void); +static struct type *type_float (struct parser_state *); -static struct type *type_double (void); +static struct type *type_double (struct parser_state *); -static struct type *type_long_double (void); +static struct type *type_long_double (struct parser_state *); -static struct type *type_char (void); +static struct type *type_char (struct parser_state *); -static struct type *type_boolean (void); +static struct type *type_boolean (struct parser_state *); -static struct type *type_system_address (void); +static struct type *type_system_address (struct parser_state *); %} +%parse-param {struct parser_state *ps} +%lex-param {struct parser_state *ps} + %union { LONGEST lval; @@ -231,25 +238,25 @@ start : exp1 /* Expressions, including the sequencing operator. */ exp1 : exp | exp1 ';' exp - { write_exp_elt_opcode (BINOP_COMMA); } + { write_exp_elt_opcode (ps, BINOP_COMMA); } | primary ASSIGN exp /* Extension for convenience */ - { write_exp_elt_opcode (BINOP_ASSIGN); } + { write_exp_elt_opcode (ps, BINOP_ASSIGN); } ; /* Expressions, not including the sequencing operator. */ primary : primary DOT_ALL - { write_exp_elt_opcode (UNOP_IND); } + { write_exp_elt_opcode (ps, UNOP_IND); } ; primary : primary DOT_ID - { write_exp_op_with_string (STRUCTOP_STRUCT, $2); } + { write_exp_op_with_string (ps, STRUCTOP_STRUCT, $2); } ; primary : primary '(' arglist ')' { - write_exp_elt_opcode (OP_FUNCALL); - write_exp_elt_longcst ($3); - write_exp_elt_opcode (OP_FUNCALL); + write_exp_elt_opcode (ps, OP_FUNCALL); + write_exp_elt_longcst (ps, $3); + write_exp_elt_opcode (ps, OP_FUNCALL); } | var_or_type '(' arglist ')' { @@ -257,15 +264,15 @@ primary : primary '(' arglist ')' { if ($3 != 1) error (_("Invalid conversion")); - 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); } else { - write_exp_elt_opcode (OP_FUNCALL); - write_exp_elt_longcst ($3); - write_exp_elt_opcode (OP_FUNCALL); + write_exp_elt_opcode (ps, OP_FUNCALL); + write_exp_elt_longcst (ps, $3); + write_exp_elt_opcode (ps, OP_FUNCALL); } } ; @@ -275,9 +282,9 @@ primary : var_or_type '\'' save_qualifier { type_qualifier = $1; } { if ($1 == NULL) error (_("Type required for qualification")); - write_exp_elt_opcode (UNOP_QUAL); - write_exp_elt_type ($1); - write_exp_elt_opcode (UNOP_QUAL); + write_exp_elt_opcode (ps, UNOP_QUAL); + write_exp_elt_type (ps, $1); + write_exp_elt_opcode (ps, UNOP_QUAL); type_qualifier = $3; } ; @@ -287,10 +294,10 @@ save_qualifier : { $$ = type_qualifier; } primary : primary '(' simple_exp DOTDOT simple_exp ')' - { write_exp_elt_opcode (TERNOP_SLICE); } + { write_exp_elt_opcode (ps, TERNOP_SLICE); } | var_or_type '(' simple_exp DOTDOT simple_exp ')' { if ($1 == NULL) - write_exp_elt_opcode (TERNOP_SLICE); + write_exp_elt_opcode (ps, TERNOP_SLICE); else error (_("Cannot slice a type")); } @@ -310,15 +317,15 @@ primary : '(' exp1 ')' { } primary : var_or_type %prec VAR { if ($1 != NULL) { - 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); } } ; primary : SPECIAL_VARIABLE /* Various GDB extensions */ - { write_dollar_variable ($1); } + { write_dollar_variable (ps, $1); } ; primary : aggregate @@ -328,19 +335,19 @@ simple_exp : primary ; simple_exp : '-' simple_exp %prec UNARY - { write_exp_elt_opcode (UNOP_NEG); } + { write_exp_elt_opcode (ps, UNOP_NEG); } ; simple_exp : '+' simple_exp %prec UNARY - { write_exp_elt_opcode (UNOP_PLUS); } + { write_exp_elt_opcode (ps, UNOP_PLUS); } ; simple_exp : NOT simple_exp %prec UNARY - { write_exp_elt_opcode (UNOP_LOGICAL_NOT); } + { write_exp_elt_opcode (ps, UNOP_LOGICAL_NOT); } ; simple_exp : ABS simple_exp %prec UNARY - { write_exp_elt_opcode (UNOP_ABS); } + { write_exp_elt_opcode (ps, UNOP_ABS); } ; arglist : { $$ = 0; } @@ -361,111 +368,111 @@ primary : '{' var_or_type '}' primary %prec '.' { if ($2 == NULL) error (_("Type required within braces in coercion")); - write_exp_elt_opcode (UNOP_MEMVAL); - write_exp_elt_type ($2); - write_exp_elt_opcode (UNOP_MEMVAL); + write_exp_elt_opcode (ps, UNOP_MEMVAL); + write_exp_elt_type (ps, $2); + write_exp_elt_opcode (ps, UNOP_MEMVAL); } ; /* Binary operators in order of decreasing precedence. */ simple_exp : simple_exp STARSTAR simple_exp - { write_exp_elt_opcode (BINOP_EXP); } + { write_exp_elt_opcode (ps, BINOP_EXP); } ; simple_exp : simple_exp '*' simple_exp - { write_exp_elt_opcode (BINOP_MUL); } + { write_exp_elt_opcode (ps, BINOP_MUL); } ; simple_exp : simple_exp '/' simple_exp - { write_exp_elt_opcode (BINOP_DIV); } + { write_exp_elt_opcode (ps, BINOP_DIV); } ; simple_exp : simple_exp REM simple_exp /* May need to be fixed to give correct Ada REM */ - { write_exp_elt_opcode (BINOP_REM); } + { write_exp_elt_opcode (ps, BINOP_REM); } ; simple_exp : simple_exp MOD simple_exp - { write_exp_elt_opcode (BINOP_MOD); } + { write_exp_elt_opcode (ps, BINOP_MOD); } ; simple_exp : simple_exp '@' simple_exp /* GDB extension */ - { write_exp_elt_opcode (BINOP_REPEAT); } + { write_exp_elt_opcode (ps, BINOP_REPEAT); } ; simple_exp : simple_exp '+' simple_exp - { write_exp_elt_opcode (BINOP_ADD); } + { write_exp_elt_opcode (ps, BINOP_ADD); } ; simple_exp : simple_exp '&' simple_exp - { write_exp_elt_opcode (BINOP_CONCAT); } + { write_exp_elt_opcode (ps, BINOP_CONCAT); } ; simple_exp : simple_exp '-' simple_exp - { write_exp_elt_opcode (BINOP_SUB); } + { write_exp_elt_opcode (ps, BINOP_SUB); } ; relation : simple_exp ; relation : simple_exp '=' simple_exp - { write_exp_elt_opcode (BINOP_EQUAL); } + { write_exp_elt_opcode (ps, BINOP_EQUAL); } ; relation : simple_exp NOTEQUAL simple_exp - { write_exp_elt_opcode (BINOP_NOTEQUAL); } + { write_exp_elt_opcode (ps, BINOP_NOTEQUAL); } ; relation : simple_exp LEQ simple_exp - { write_exp_elt_opcode (BINOP_LEQ); } + { write_exp_elt_opcode (ps, BINOP_LEQ); } ; relation : simple_exp IN simple_exp DOTDOT simple_exp - { write_exp_elt_opcode (TERNOP_IN_RANGE); } + { write_exp_elt_opcode (ps, TERNOP_IN_RANGE); } | simple_exp IN primary TICK_RANGE tick_arglist - { write_exp_elt_opcode (BINOP_IN_BOUNDS); - write_exp_elt_longcst ((LONGEST) $5); - write_exp_elt_opcode (BINOP_IN_BOUNDS); + { write_exp_elt_opcode (ps, BINOP_IN_BOUNDS); + write_exp_elt_longcst (ps, (LONGEST) $5); + write_exp_elt_opcode (ps, BINOP_IN_BOUNDS); } | simple_exp IN var_or_type %prec TICK_ACCESS { if ($3 == NULL) error (_("Right operand of 'in' must be type")); - write_exp_elt_opcode (UNOP_IN_RANGE); - write_exp_elt_type ($3); - write_exp_elt_opcode (UNOP_IN_RANGE); + write_exp_elt_opcode (ps, UNOP_IN_RANGE); + write_exp_elt_type (ps, $3); + write_exp_elt_opcode (ps, UNOP_IN_RANGE); } | simple_exp NOT IN simple_exp DOTDOT simple_exp - { write_exp_elt_opcode (TERNOP_IN_RANGE); - write_exp_elt_opcode (UNOP_LOGICAL_NOT); + { write_exp_elt_opcode (ps, TERNOP_IN_RANGE); + write_exp_elt_opcode (ps, UNOP_LOGICAL_NOT); } | simple_exp NOT IN primary TICK_RANGE tick_arglist - { write_exp_elt_opcode (BINOP_IN_BOUNDS); - write_exp_elt_longcst ((LONGEST) $6); - write_exp_elt_opcode (BINOP_IN_BOUNDS); - write_exp_elt_opcode (UNOP_LOGICAL_NOT); + { write_exp_elt_opcode (ps, BINOP_IN_BOUNDS); + write_exp_elt_longcst (ps, (LONGEST) $6); + write_exp_elt_opcode (ps, BINOP_IN_BOUNDS); + write_exp_elt_opcode (ps, UNOP_LOGICAL_NOT); } | simple_exp NOT IN var_or_type %prec TICK_ACCESS { if ($4 == NULL) error (_("Right operand of 'in' must be type")); - write_exp_elt_opcode (UNOP_IN_RANGE); - write_exp_elt_type ($4); - write_exp_elt_opcode (UNOP_IN_RANGE); - write_exp_elt_opcode (UNOP_LOGICAL_NOT); + write_exp_elt_opcode (ps, UNOP_IN_RANGE); + write_exp_elt_type (ps, $4); + write_exp_elt_opcode (ps, UNOP_IN_RANGE); + write_exp_elt_opcode (ps, UNOP_LOGICAL_NOT); } ; relation : simple_exp GEQ simple_exp - { write_exp_elt_opcode (BINOP_GEQ); } + { write_exp_elt_opcode (ps, BINOP_GEQ); } ; relation : simple_exp '<' simple_exp - { write_exp_elt_opcode (BINOP_LESS); } + { write_exp_elt_opcode (ps, BINOP_LESS); } ; relation : simple_exp '>' simple_exp - { write_exp_elt_opcode (BINOP_GTR); } + { write_exp_elt_opcode (ps, BINOP_GTR); } ; exp : relation @@ -478,36 +485,36 @@ exp : relation and_exp : relation _AND_ relation - { write_exp_elt_opcode (BINOP_BITWISE_AND); } + { write_exp_elt_opcode (ps, BINOP_BITWISE_AND); } | and_exp _AND_ relation - { write_exp_elt_opcode (BINOP_BITWISE_AND); } + { write_exp_elt_opcode (ps, BINOP_BITWISE_AND); } ; and_then_exp : relation _AND_ THEN relation - { write_exp_elt_opcode (BINOP_LOGICAL_AND); } + { write_exp_elt_opcode (ps, BINOP_LOGICAL_AND); } | and_then_exp _AND_ THEN relation - { write_exp_elt_opcode (BINOP_LOGICAL_AND); } + { write_exp_elt_opcode (ps, BINOP_LOGICAL_AND); } ; or_exp : relation OR relation - { write_exp_elt_opcode (BINOP_BITWISE_IOR); } + { write_exp_elt_opcode (ps, BINOP_BITWISE_IOR); } | or_exp OR relation - { write_exp_elt_opcode (BINOP_BITWISE_IOR); } + { write_exp_elt_opcode (ps, BINOP_BITWISE_IOR); } ; or_else_exp : relation OR ELSE relation - { write_exp_elt_opcode (BINOP_LOGICAL_OR); } + { write_exp_elt_opcode (ps, BINOP_LOGICAL_OR); } | or_else_exp OR ELSE relation - { write_exp_elt_opcode (BINOP_LOGICAL_OR); } + { write_exp_elt_opcode (ps, BINOP_LOGICAL_OR); } ; xor_exp : relation XOR relation - { write_exp_elt_opcode (BINOP_BITWISE_XOR); } + { write_exp_elt_opcode (ps, BINOP_BITWISE_XOR); } | xor_exp XOR relation - { write_exp_elt_opcode (BINOP_BITWISE_XOR); } + { write_exp_elt_opcode (ps, BINOP_BITWISE_XOR); } ; /* Primaries can denote types (OP_TYPE). In cases such as @@ -519,36 +526,36 @@ xor_exp : relation XOR relation aType'access evaluates to a type that evaluate_subexp attempts to evaluate. */ primary : primary TICK_ACCESS - { write_exp_elt_opcode (UNOP_ADDR); } + { write_exp_elt_opcode (ps, UNOP_ADDR); } | primary TICK_ADDRESS - { write_exp_elt_opcode (UNOP_ADDR); - write_exp_elt_opcode (UNOP_CAST); - write_exp_elt_type (type_system_address ()); - write_exp_elt_opcode (UNOP_CAST); + { write_exp_elt_opcode (ps, UNOP_ADDR); + write_exp_elt_opcode (ps, UNOP_CAST); + write_exp_elt_type (ps, type_system_address (ps)); + write_exp_elt_opcode (ps, UNOP_CAST); } | primary TICK_FIRST tick_arglist - { write_int ($3, type_int ()); - write_exp_elt_opcode (OP_ATR_FIRST); } + { write_int (ps, $3, type_int (ps)); + write_exp_elt_opcode (ps, OP_ATR_FIRST); } | primary TICK_LAST tick_arglist - { write_int ($3, type_int ()); - write_exp_elt_opcode (OP_ATR_LAST); } + { write_int (ps, $3, type_int (ps)); + write_exp_elt_opcode (ps, OP_ATR_LAST); } | primary TICK_LENGTH tick_arglist - { write_int ($3, type_int ()); - write_exp_elt_opcode (OP_ATR_LENGTH); } + { write_int (ps, $3, type_int (ps)); + write_exp_elt_opcode (ps, OP_ATR_LENGTH); } | primary TICK_SIZE - { write_exp_elt_opcode (OP_ATR_SIZE); } + { write_exp_elt_opcode (ps, OP_ATR_SIZE); } | primary TICK_TAG - { write_exp_elt_opcode (OP_ATR_TAG); } + { write_exp_elt_opcode (ps, OP_ATR_TAG); } | opt_type_prefix TICK_MIN '(' exp ',' exp ')' - { write_exp_elt_opcode (OP_ATR_MIN); } + { write_exp_elt_opcode (ps, OP_ATR_MIN); } | opt_type_prefix TICK_MAX '(' exp ',' exp ')' - { write_exp_elt_opcode (OP_ATR_MAX); } + { write_exp_elt_opcode (ps, OP_ATR_MAX); } | opt_type_prefix TICK_POS '(' exp ')' - { write_exp_elt_opcode (OP_ATR_POS); } + { write_exp_elt_opcode (ps, OP_ATR_POS); } | type_prefix TICK_VAL '(' exp ')' - { write_exp_elt_opcode (OP_ATR_VAL); } + { write_exp_elt_opcode (ps, OP_ATR_VAL); } | type_prefix TICK_MODULUS - { write_exp_elt_opcode (OP_ATR_MODULUS); } + { write_exp_elt_opcode (ps, OP_ATR_MODULUS); } ; tick_arglist : %prec '(' @@ -562,53 +569,55 @@ type_prefix : { if ($1 == NULL) error (_("Prefix must be 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); } ; opt_type_prefix : type_prefix | /* EMPTY */ - { write_exp_elt_opcode (OP_TYPE); - write_exp_elt_type (parse_type->builtin_void); - write_exp_elt_opcode (OP_TYPE); } + { write_exp_elt_opcode (ps, OP_TYPE); + write_exp_elt_type (ps, + parse_type (ps)->builtin_void); + write_exp_elt_opcode (ps, OP_TYPE); } ; primary : INT - { write_int ((LONGEST) $1.val, $1.type); } + { write_int (ps, (LONGEST) $1.val, $1.type); } ; primary : CHARLIT - { write_int (convert_char_literal (type_qualifier, $1.val), + { write_int (ps, + convert_char_literal (type_qualifier, $1.val), (type_qualifier == NULL) ? $1.type : type_qualifier); } ; primary : FLOAT - { write_exp_elt_opcode (OP_DOUBLE); - write_exp_elt_type ($1.type); - write_exp_elt_dblcst ($1.dval); - write_exp_elt_opcode (OP_DOUBLE); + { write_exp_elt_opcode (ps, OP_DOUBLE); + write_exp_elt_type (ps, $1.type); + write_exp_elt_dblcst (ps, $1.dval); + write_exp_elt_opcode (ps, OP_DOUBLE); } ; primary : NULL_PTR - { write_int (0, type_int ()); } + { write_int (ps, 0, type_int (ps)); } ; primary : STRING { - write_exp_op_with_string (OP_STRING, $1); + write_exp_op_with_string (ps, OP_STRING, $1); } ; primary : TRUEKEYWORD - { write_int (1, type_boolean ()); } + { write_int (ps, 1, type_boolean (ps)); } | FALSEKEYWORD - { write_int (0, type_boolean ()); } + { write_int (ps, 0, type_boolean (ps)); } ; primary : NEW NAME @@ -616,22 +625,22 @@ primary : NEW NAME ; var_or_type: NAME %prec VAR - { $$ = write_var_or_type (NULL, $1); } + { $$ = write_var_or_type (ps, NULL, $1); } | block NAME %prec VAR - { $$ = write_var_or_type ($1, $2); } + { $$ = write_var_or_type (ps, $1, $2); } | NAME TICK_ACCESS { - $$ = write_var_or_type (NULL, $1); + $$ = write_var_or_type (ps, NULL, $1); if ($$ == NULL) - write_exp_elt_opcode (UNOP_ADDR); + write_exp_elt_opcode (ps, UNOP_ADDR); else $$ = lookup_pointer_type ($$); } | block NAME TICK_ACCESS { - $$ = write_var_or_type ($1, $2); + $$ = write_var_or_type (ps, $1, $2); if ($$ == NULL) - write_exp_elt_opcode (UNOP_ADDR); + write_exp_elt_opcode (ps, UNOP_ADDR); else $$ = lookup_pointer_type ($$); } @@ -647,18 +656,18 @@ block : NAME COLONCOLON aggregate : '(' aggregate_component_list ')' { - write_exp_elt_opcode (OP_AGGREGATE); - write_exp_elt_longcst ($2); - write_exp_elt_opcode (OP_AGGREGATE); + write_exp_elt_opcode (ps, OP_AGGREGATE); + write_exp_elt_longcst (ps, $2); + write_exp_elt_opcode (ps, OP_AGGREGATE); } ; aggregate_component_list : component_groups { $$ = $1; } | positional_list exp - { write_exp_elt_opcode (OP_POSITIONAL); - write_exp_elt_longcst ($1); - write_exp_elt_opcode (OP_POSITIONAL); + { write_exp_elt_opcode (ps, OP_POSITIONAL); + write_exp_elt_longcst (ps, $1); + write_exp_elt_opcode (ps, OP_POSITIONAL); $$ = $1 + 1; } | positional_list component_groups @@ -667,15 +676,15 @@ aggregate_component_list : positional_list : exp ',' - { write_exp_elt_opcode (OP_POSITIONAL); - write_exp_elt_longcst (0); - write_exp_elt_opcode (OP_POSITIONAL); + { write_exp_elt_opcode (ps, OP_POSITIONAL); + write_exp_elt_longcst (ps, 0); + write_exp_elt_opcode (ps, OP_POSITIONAL); $$ = 1; } | positional_list exp ',' - { write_exp_elt_opcode (OP_POSITIONAL); - write_exp_elt_longcst ($1); - write_exp_elt_opcode (OP_POSITIONAL); + { write_exp_elt_opcode (ps, OP_POSITIONAL); + write_exp_elt_longcst (ps, $1); + write_exp_elt_opcode (ps, OP_POSITIONAL); $$ = $1 + 1; } ; @@ -688,15 +697,15 @@ component_groups: ; others : OTHERS ARROW exp - { write_exp_elt_opcode (OP_OTHERS); } + { write_exp_elt_opcode (ps, OP_OTHERS); } ; component_group : component_associations { - write_exp_elt_opcode (OP_CHOICES); - write_exp_elt_longcst ($1); - write_exp_elt_opcode (OP_CHOICES); + write_exp_elt_opcode (ps, OP_CHOICES); + write_exp_elt_longcst (ps, $1); + write_exp_elt_opcode (ps, OP_CHOICES); } ; @@ -707,22 +716,22 @@ component_group : resolved shift/reduce conflict. */ component_associations : NAME ARROW - { write_name_assoc ($1); } + { write_name_assoc (ps, $1); } exp { $$ = 1; } | simple_exp ARROW exp { $$ = 1; } | simple_exp DOTDOT simple_exp ARROW - { write_exp_elt_opcode (OP_DISCRETE_RANGE); - write_exp_op_with_string (OP_NAME, empty_stoken); + { write_exp_elt_opcode (ps, OP_DISCRETE_RANGE); + write_exp_op_with_string (ps, OP_NAME, empty_stoken); } exp { $$ = 1; } | NAME '|' - { write_name_assoc ($1); } + { write_name_assoc (ps, $1); } component_associations { $$ = $4 + 1; } | simple_exp '|' component_associations { $$ = $3 + 1; } | simple_exp DOTDOT simple_exp '|' - { write_exp_elt_opcode (OP_DISCRETE_RANGE); } + { write_exp_elt_opcode (ps, OP_DISCRETE_RANGE); } component_associations { $$ = $6 + 1; } ; @@ -730,11 +739,11 @@ component_associations : can't get used to Ada notation in GDB. */ primary : '*' primary %prec '.' - { write_exp_elt_opcode (UNOP_IND); } + { write_exp_elt_opcode (ps, UNOP_IND); } | '&' primary %prec '.' - { write_exp_elt_opcode (UNOP_ADDR); } + { write_exp_elt_opcode (ps, UNOP_ADDR); } | primary '[' exp ']' - { write_exp_elt_opcode (BINOP_SUBSCRIPT); } + { write_exp_elt_opcode (ps, BINOP_SUBSCRIPT); } ; %% @@ -765,18 +774,18 @@ static struct obstack temp_parse_space; #include "ada-lex.c" int -ada_parse (void) +ada_parse (struct parser_state *ps) { lexer_init (yyin); /* (Re-)initialize lexer. */ type_qualifier = NULL; obstack_free (&temp_parse_space, NULL); obstack_init (&temp_parse_space); - return _ada_parse (); + return _ada_parse (ps); } void -yyerror (char *msg) +yyerror (struct parser_state *ps, char *msg) { error (_("Error in expression, near `%s'."), lexptr); } @@ -812,7 +821,8 @@ string_to_operator (struct stoken string) /* Emit expression to access an instance of SYM, in block BLOCK (if * non-NULL), and with :: qualification ORIG_LEFT_CONTEXT. */ static void -write_var_from_sym (struct block *orig_left_context, +write_var_from_sym (struct parser_state *ps, + struct block *orig_left_context, struct block *block, struct symbol *sym) { @@ -823,30 +833,31 @@ write_var_from_sym (struct block *orig_left_context, innermost_block = block; } - write_exp_elt_opcode (OP_VAR_VALUE); - write_exp_elt_block (block); - 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, block); + write_exp_elt_sym (ps, sym); + write_exp_elt_opcode (ps, OP_VAR_VALUE); } /* Write integer or boolean constant ARG of type TYPE. */ static void -write_int (LONGEST arg, struct type *type) +write_int (struct parser_state *ps, LONGEST arg, struct type *type) { - write_exp_elt_opcode (OP_LONG); - write_exp_elt_type (type); - write_exp_elt_longcst (arg); - write_exp_elt_opcode (OP_LONG); + write_exp_elt_opcode (ps, OP_LONG); + write_exp_elt_type (ps, type); + write_exp_elt_longcst (ps, arg); + write_exp_elt_opcode (ps, OP_LONG); } /* Write an OPCODE, string, OPCODE sequence to the current expression. */ static void -write_exp_op_with_string (enum exp_opcode opcode, struct stoken token) +write_exp_op_with_string (struct parser_state *ps, enum exp_opcode opcode, + struct stoken token) { - write_exp_elt_opcode (opcode); - write_exp_string (token); - write_exp_elt_opcode (opcode); + write_exp_elt_opcode (ps, opcode); + write_exp_string (ps, token); + write_exp_elt_opcode (ps, opcode); } /* Emit expression corresponding to the renamed object named @@ -861,7 +872,8 @@ write_exp_op_with_string (enum exp_opcode opcode, struct stoken token) * new encoding entirely (FIXME pnh 7/20/2007). */ static void -write_object_renaming (struct block *orig_left_context, +write_object_renaming (struct parser_state *ps, + struct block *orig_left_context, const char *renamed_entity, int renamed_entity_len, const char *renaming_expr, int max_depth) { @@ -896,10 +908,10 @@ write_object_renaming (struct block *orig_left_context, &inner_renaming_expr)) { case ADA_NOT_RENAMING: - write_var_from_sym (orig_left_context, block, sym); + write_var_from_sym (ps, orig_left_context, block, sym); break; case ADA_OBJECT_RENAMING: - write_object_renaming (block, + write_object_renaming (ps, block, inner_renamed_entity, inner_renamed_entity_len, inner_renaming_expr, max_depth - 1); break; @@ -916,7 +928,7 @@ write_object_renaming (struct block *orig_left_context, switch (*renaming_expr) { case 'A': renaming_expr += 1; - write_exp_elt_opcode (UNOP_IND); + write_exp_elt_opcode (ps, UNOP_IND); break; case 'L': slice_state = LOWER_BOUND; @@ -930,10 +942,10 @@ write_object_renaming (struct block *orig_left_context, if (next == renaming_expr) goto BadEncoding; renaming_expr = next; - write_exp_elt_opcode (OP_LONG); - write_exp_elt_type (type_int ()); - write_exp_elt_longcst ((LONGEST) val); - write_exp_elt_opcode (OP_LONG); + write_exp_elt_opcode (ps, OP_LONG); + write_exp_elt_type (ps, type_int (ps)); + write_exp_elt_longcst (ps, (LONGEST) val); + write_exp_elt_opcode (ps, OP_LONG); } else { @@ -957,19 +969,19 @@ write_object_renaming (struct block *orig_left_context, else if (SYMBOL_CLASS (index_sym) == LOC_TYPEDEF) /* Index is an old-style renaming symbol. */ block = orig_left_context; - write_var_from_sym (NULL, block, index_sym); + write_var_from_sym (ps, NULL, block, index_sym); } if (slice_state == SIMPLE_INDEX) { - write_exp_elt_opcode (OP_FUNCALL); - write_exp_elt_longcst ((LONGEST) 1); - write_exp_elt_opcode (OP_FUNCALL); + write_exp_elt_opcode (ps, OP_FUNCALL); + write_exp_elt_longcst (ps, (LONGEST) 1); + write_exp_elt_opcode (ps, OP_FUNCALL); } else if (slice_state == LOWER_BOUND) slice_state = UPPER_BOUND; else if (slice_state == UPPER_BOUND) { - write_exp_elt_opcode (TERNOP_SLICE); + write_exp_elt_opcode (ps, TERNOP_SLICE); slice_state = SIMPLE_INDEX; } break; @@ -990,7 +1002,7 @@ write_object_renaming (struct block *orig_left_context, strncpy (field_name.ptr, renaming_expr, end - renaming_expr); field_name.ptr[end - renaming_expr] = '\000'; renaming_expr = end; - write_exp_op_with_string (STRUCTOP_STRUCT, field_name); + write_exp_op_with_string (ps, STRUCTOP_STRUCT, field_name); break; } @@ -1079,14 +1091,14 @@ select_possible_type_sym (struct ada_symbol_info *syms, int nsyms) } static struct type* -find_primitive_type (char *name) +find_primitive_type (struct parser_state *ps, char *name) { struct type *type; - type = language_lookup_primitive_type_by_name (parse_language, - parse_gdbarch, + type = language_lookup_primitive_type_by_name (parse_language (ps), + parse_gdbarch (ps), name); if (type == NULL && strcmp ("system__address", name) == 0) - type = type_system_address (); + type = type_system_address (ps); if (type != NULL) { @@ -1135,7 +1147,7 @@ chop_separator (char *name) is '__' or '.', write the indicated sequence of STRUCTOP_STRUCT expression operators. */ static void -write_selectors (char *sels) +write_selectors (struct parser_state *ps, char *sels) { while (*sels != '\0') { @@ -1147,7 +1159,7 @@ write_selectors (char *sels) sels += 1; field_name.length = sels - p; field_name.ptr = p; - write_exp_op_with_string (STRUCTOP_STRUCT, field_name); + write_exp_op_with_string (ps, STRUCTOP_STRUCT, field_name); } } @@ -1156,7 +1168,8 @@ write_selectors (char *sels) a temporary symbol that is valid until the next call to ada_parse. */ static void -write_ambiguous_var (struct block *block, char *name, int len) +write_ambiguous_var (struct parser_state *ps, struct block *block, char *name, + int len) { struct symbol *sym = obstack_alloc (&temp_parse_space, sizeof (struct symbol)); @@ -1165,10 +1178,10 @@ write_ambiguous_var (struct block *block, char *name, int len) SYMBOL_LINKAGE_NAME (sym) = obsavestring (name, len, &temp_parse_space); SYMBOL_LANGUAGE (sym) = language_ada; - write_exp_elt_opcode (OP_VAR_VALUE); - write_exp_elt_block (block); - 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, block); + write_exp_elt_sym (ps, sym); + write_exp_elt_opcode (ps, OP_VAR_VALUE); } /* A convenient wrapper around ada_get_field_index that takes @@ -1248,7 +1261,8 @@ get_symbol_field_type (struct symbol *sym, char *encoded_field_name) identifier). */ static struct type* -write_var_or_type (struct block *block, struct stoken name0) +write_var_or_type (struct parser_state *ps, struct block *block, + struct stoken name0) { int depth; char *encoded_name; @@ -1323,9 +1337,9 @@ write_var_or_type (struct block *block, struct stoken name0) goto TryAfterRenaming; } case ADA_OBJECT_RENAMING: - write_object_renaming (block, renaming, renaming_len, + write_object_renaming (ps, block, renaming, renaming_len, renaming_expr, MAX_RENAMING_CHAIN_LENGTH); - write_selectors (encoded_name + tail_index); + write_selectors (ps, encoded_name + tail_index); return NULL; default: internal_error (__FILE__, __LINE__, @@ -1352,7 +1366,7 @@ write_var_or_type (struct block *block, struct stoken name0) } else if (tail_index == name_len && nsyms == 0) { - struct type *type = find_primitive_type (encoded_name); + struct type *type = find_primitive_type (ps, encoded_name); if (type != NULL) return type; @@ -1360,8 +1374,8 @@ write_var_or_type (struct block *block, struct stoken name0) if (nsyms == 1) { - write_var_from_sym (block, syms[0].block, syms[0].sym); - write_selectors (encoded_name + tail_index); + write_var_from_sym (ps, block, syms[0].block, syms[0].sym); + write_selectors (ps, encoded_name + tail_index); return NULL; } else if (nsyms == 0) @@ -1370,9 +1384,9 @@ write_var_or_type (struct block *block, struct stoken name0) = ada_lookup_simple_minsym (encoded_name); if (msym != NULL) { - write_exp_msymbol (msym); + write_exp_msymbol (ps, msym); /* Maybe cause error here rather than later? FIXME? */ - write_selectors (encoded_name + tail_index); + write_selectors (ps, encoded_name + tail_index); return NULL; } @@ -1385,8 +1399,8 @@ write_var_or_type (struct block *block, struct stoken name0) } else { - write_ambiguous_var (block, encoded_name, tail_index); - write_selectors (encoded_name + tail_index); + write_ambiguous_var (ps, block, encoded_name, tail_index); + write_selectors (ps, encoded_name + tail_index); return NULL; } } @@ -1421,7 +1435,7 @@ write_var_or_type (struct block *block, struct stoken name0) ambiguous name, one must write instead ((R) => 42). */ static void -write_name_assoc (struct stoken name) +write_name_assoc (struct parser_state *ps, struct stoken name) { if (strchr (name.ptr, '.') == NULL) { @@ -1429,12 +1443,12 @@ write_name_assoc (struct stoken name) int nsyms = ada_lookup_symbol_list (name.ptr, expression_context_block, VAR_DOMAIN, &syms); if (nsyms != 1 || SYMBOL_CLASS (syms[0].sym) == LOC_TYPEDEF) - write_exp_op_with_string (OP_NAME, name); + write_exp_op_with_string (ps, OP_NAME, name); else - write_var_from_sym (NULL, syms[0].block, syms[0].sym); + write_var_from_sym (ps, NULL, syms[0].block, syms[0].sym); } else - if (write_var_or_type (NULL, name) != NULL) + if (write_var_or_type (ps, NULL, name) != NULL) error (_("Invalid use of type.")); } @@ -1465,61 +1479,61 @@ convert_char_literal (struct type *type, LONGEST val) } static struct type * -type_int (void) +type_int (struct parser_state *ps) { - return parse_type->builtin_int; + return parse_type (ps)->builtin_int; } static struct type * -type_long (void) +type_long (struct parser_state *ps) { - return parse_type->builtin_long; + return parse_type (ps)->builtin_long; } static struct type * -type_long_long (void) +type_long_long (struct parser_state *ps) { - return parse_type->builtin_long_long; + return parse_type (ps)->builtin_long_long; } static struct type * -type_float (void) +type_float (struct parser_state *ps) { - return parse_type->builtin_float; + return parse_type (ps)->builtin_float; } static struct type * -type_double (void) +type_double (struct parser_state *ps) { - return parse_type->builtin_double; + return parse_type (ps)->builtin_double; } static struct type * -type_long_double (void) +type_long_double (struct parser_state *ps) { - return parse_type->builtin_long_double; + return parse_type (ps)->builtin_long_double; } static struct type * -type_char (void) +type_char (struct parser_state *ps) { - return language_string_char_type (parse_language, parse_gdbarch); + return language_string_char_type (parse_language (ps), parse_gdbarch (ps)); } static struct type * -type_boolean (void) +type_boolean (struct parser_state *ps) { - return parse_type->builtin_bool; + return parse_type (ps)->builtin_bool; } static struct type * -type_system_address (void) +type_system_address (struct parser_state *ps) { struct type *type - = language_lookup_primitive_type_by_name (parse_language, - parse_gdbarch, + = language_lookup_primitive_type_by_name (parse_language (ps), + parse_gdbarch (ps), "system__address"); - return type != NULL ? type : parse_type->builtin_data_ptr; + return type != NULL ? type : parse_type (ps)->builtin_data_ptr; } /* Provide a prototype to silence -Wmissing-prototypes. */ diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c index 29956d7..38d58d3 100644 --- a/gdb/ada-lang.c +++ b/gdb/ada-lang.c @@ -12305,10 +12305,10 @@ emit_char (int c, struct type *type, struct ui_file *stream, int quoter) } static int -parse (void) +parse (struct parser_state *ps) { warnings_issued = 0; - return ada_parse (); + return ada_parse (ps); } static const struct exp_descriptor ada_exp_descriptor = { diff --git a/gdb/ada-lang.h b/gdb/ada-lang.h index 9ab7b2d..b4e85eb 100644 --- a/gdb/ada-lang.h +++ b/gdb/ada-lang.h @@ -23,6 +23,7 @@ struct frame_info; struct inferior; +struct parser_state; #include "value.h" #include "gdbtypes.h" @@ -153,9 +154,10 @@ extern int ada_get_field_index (const struct type *type, const char *field_name, int maybe_missing); -extern int ada_parse (void); /* Defined in ada-exp.y */ +extern int ada_parse (struct parser_state *); /* Defined in ada-exp.y */ -extern void ada_error (char *); /* Defined in ada-exp.y */ +extern void ada_error (struct parser_state *, char *); /* Defined in + ada-exp.y */ /* Defined in ada-typeprint.c */ extern void ada_print_type (struct type *, const char *, struct ui_file *, int, diff --git a/gdb/ada-lex.l b/gdb/ada-lex.l index 48667d0..b3fefd6 100644 --- a/gdb/ada-lex.l +++ b/gdb/ada-lex.l @@ -49,14 +49,15 @@ POSEXP (e"+"?{NUM10}) static char numbuf[NUMERAL_WIDTH]; static void canonicalizeNumeral (char *s1, const char *); static struct stoken processString (const char*, int); -static int processInt (const char *, const char *, const char *); -static int processReal (const char *); +static int processInt (struct parser_state *, const char *, const char *, + const char *); +static int processReal (struct parser_state *, const char *); static struct stoken processId (const char *, int); static int processAttribute (const char *); static int find_dot_all (const char *); #undef YY_DECL -#define YY_DECL static int yylex ( void ) +#define YY_DECL static int yylex ( struct parser_state *ps ) /* Flex generates a static function "input" which is not used. Defining YY_NO_INPUT comments it out. */ @@ -89,40 +90,42 @@ static int find_dot_all (const char *); {NUM10}{POSEXP} { canonicalizeNumeral (numbuf, yytext); - return processInt (NULL, numbuf, strrchr(numbuf, 'e')+1); + return processInt (ps, NULL, numbuf, + strrchr (numbuf, 'e') + 1); } {NUM10} { canonicalizeNumeral (numbuf, yytext); - return processInt (NULL, numbuf, NULL); + return processInt (ps, NULL, numbuf, NULL); } {NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#"{POSEXP} { canonicalizeNumeral (numbuf, yytext); - return processInt (numbuf, + return processInt (ps, numbuf, strchr (numbuf, '#') + 1, strrchr(numbuf, '#') + 1); } {NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#" { canonicalizeNumeral (numbuf, yytext); - return processInt (numbuf, strchr (numbuf, '#') + 1, NULL); + return processInt (ps, numbuf, strchr (numbuf, '#') + 1, + NULL); } "0x"{HEXDIG}+ { canonicalizeNumeral (numbuf, yytext+2); - return processInt ("16#", numbuf, NULL); + return processInt (ps, "16#", numbuf, NULL); } {NUM10}"."{NUM10}{EXP} { canonicalizeNumeral (numbuf, yytext); - return processReal (numbuf); + return processReal (ps, numbuf); } {NUM10}"."{NUM10} { canonicalizeNumeral (numbuf, yytext); - return processReal (numbuf); + return processReal (ps, numbuf); } {NUM10}"#"{NUM16}"."{NUM16}"#"{EXP} { @@ -134,14 +137,14 @@ static int find_dot_all (const char *); } "'"({GRAPHIC}|\")"'" { - yylval.typed_val.type = type_char (); + yylval.typed_val.type = type_char (ps); yylval.typed_val.val = yytext[1]; return CHARLIT; } "'[\""{HEXDIG}{2}"\"]'" { int v; - yylval.typed_val.type = type_char (); + yylval.typed_val.type = type_char (ps); sscanf (yytext+3, "%2x", &v); yylval.typed_val.val = v; return CHARLIT; @@ -325,7 +328,8 @@ canonicalizeNumeral (char *s1, const char *s2) */ static int -processInt (const char *base0, const char *num0, const char *exp0) +processInt (struct parser_state *ps, const char *base0, const char *num0, + const char *exp0) { ULONGEST result; long exp; @@ -362,11 +366,11 @@ processInt (const char *base0, const char *num0, const char *exp0) exp -= 1; } - if ((result >> (gdbarch_int_bit (parse_gdbarch)-1)) == 0) - yylval.typed_val.type = type_int (); - else if ((result >> (gdbarch_long_bit (parse_gdbarch)-1)) == 0) - yylval.typed_val.type = type_long (); - else if (((result >> (gdbarch_long_bit (parse_gdbarch)-1)) >> 1) == 0) + if ((result >> (gdbarch_int_bit (parse_gdbarch (ps))-1)) == 0) + yylval.typed_val.type = type_int (ps); + else if ((result >> (gdbarch_long_bit (parse_gdbarch (ps))-1)) == 0) + yylval.typed_val.type = type_long (ps); + else if (((result >> (gdbarch_long_bit (parse_gdbarch (ps))-1)) >> 1) == 0) { /* We have a number representable as an unsigned integer quantity. For consistency with the C treatment, we will treat it as an @@ -376,7 +380,7 @@ processInt (const char *base0, const char *num0, const char *exp0) assignment does the trick (no, it doesn't; read the reference manual). */ yylval.typed_val.type - = builtin_type (parse_gdbarch)->builtin_unsigned_long; + = builtin_type (parse_gdbarch (ps))->builtin_unsigned_long; if (result & LONGEST_SIGN) yylval.typed_val.val = (LONGEST) (result & ~LONGEST_SIGN) @@ -386,24 +390,24 @@ processInt (const char *base0, const char *num0, const char *exp0) return INT; } else - yylval.typed_val.type = type_long_long (); + yylval.typed_val.type = type_long_long (ps); yylval.typed_val.val = (LONGEST) result; return INT; } static int -processReal (const char *num0) +processReal (struct parser_state *ps, const char *num0) { sscanf (num0, "%" DOUBLEST_SCAN_FORMAT, &yylval.typed_val_float.dval); - yylval.typed_val_float.type = type_float (); - if (sizeof(DOUBLEST) >= gdbarch_double_bit (parse_gdbarch) + yylval.typed_val_float.type = type_float (ps); + if (sizeof(DOUBLEST) >= gdbarch_double_bit (parse_gdbarch (ps)) / TARGET_CHAR_BIT) - yylval.typed_val_float.type = type_double (); - if (sizeof(DOUBLEST) >= gdbarch_long_double_bit (parse_gdbarch) + yylval.typed_val_float.type = type_double (ps); + if (sizeof(DOUBLEST) >= gdbarch_long_double_bit (parse_gdbarch (ps)) / TARGET_CHAR_BIT) - yylval.typed_val_float.type = type_long_double (); + yylval.typed_val_float.type = type_long_double (ps); return FLOAT; }