From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 21132 invoked by alias); 1 Sep 2003 09:39:45 -0000 Mailing-List: contact gdb-patches-help@sources.redhat.com; run by ezmlm Precedence: bulk List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sources.redhat.com Received: (qmail 21077 invoked from network); 1 Sep 2003 09:39:42 -0000 Received: from unknown (HELO nile.gnat.com) (205.232.38.5) by sources.redhat.com with SMTP; 1 Sep 2003 09:39:42 -0000 Received: by nile.gnat.com (Postfix, from userid 1345) id 0D2E9F2A64; Mon, 1 Sep 2003 05:39:41 -0400 (EDT) From: Paul Hilfinger To: gdb-patches@sources.redhat.com Subject: RFA: Changes to allow extensions to operator set Message-Id: <20030901093941.0D2E9F2A64@nile.gnat.com> Date: Mon, 01 Sep 2003 09:39:00 -0000 X-SW-Source: 2003-09/txt/msg00001.txt.bz2 After a long hiatus, I am back. In response to the last time I started to submit Ada-related patches, Andrew Cagney wrote that it really ought not be necessary to extend the set of operators in expression.h to add Ada (or any other language, presumably). OK, here is a set of non-Ada-specific patches that allow one to add new language modules without adding to the operators in expression.h. While I was in here, I made a few other modifications that I hope meet with general approval: 1. There was essentially duplicate code in prefixify_subexp and length_of_subexp. I have factored out the duplication. [In the process, by the way, I happened to notice that BINOP_VAL was defined only in length_of_subexp, and indeed that there appears to be no code anywhere to handle its evaluation.] 2. Currently, the function dump_prefix_expression is used to dump postfix expressions and dump_postfix_expression is used to dump prefix expressions. It is probably a sign of the weakening effects of age on the intellect that I found this confusing, and have renamed dump_prefix_expression to dump_raw_expression (because in principle it doesn't really care whether the expression is pre- or postfix), and dump_postfix_expression to dump_prefix_expression. 3. The current dump_prefix_expression tries to first print the expression it is dumping with print_expression. This doesn't work, however, because print_expression operates on prefix expressions, and the current dump_prefix_expression is only used on postfix expressions. I simply removed the print_expression. 4. I removed register declarations in routines I touched, just on general principles. [I believe that all register declarations in GDB and much other GNU software are anachronistic holdovers from some bygone era. GCC ignores them, or so I'm told, except to insure that & is not applied to register variables. Furthermore, my impression is that many of these declarations would be inappropriate even in non-optimizing compilers, since they often seem to be used rather indiscriminantly in ways that are likely to favor putting the wrong things into registers.] One explanatory comment as to technique: I bundled up a related set of function pointers into a new type (struct exp_descriptor) and put a pointer to the structure into the language_defn vectors (i.e., as opposed to just adding the four functions contained in it to the language_defn vector). I thought it looked neater, but more to the point, it avoided some awkward dependency issues. I leave it to other interested parties to move language-specific operators currently in expression.h, eval.c, etc., back into their respective language-specific files, should they wish to do so. We only intend to use this change for the Ada-related operators. No test suite regressions seen on GNU Linux. P. Hilfinger Ada Core Technologies, Inc. ChangeLog: 2003-09-01 Paul N. Hilfinger * parser-defs.h (struct exp_descriptor): New definition, containing language-specific info for printing, prefixifying, and dumping expressions. (exp_descriptor_standard): Declare new variable. (print_subexp): Make global and declare here (from expprint.c). (dump_subexp): Ditto. (dump_subexp_body_standard): Declare. (operator_length): Declare. (operator_length_standard): Declare. (op_name_standard): Declare. (print_subexp): Declare. (print_subexp_standard): Declare. * language.h (struct language_defn): Add la_exp_desc field to hold pointer to table for language-specific operators. * parse.c (length_of_subexp): Use operator_length to get operator lengths and arities for operators. Remove register declarations. Move most code to new operator_length_standard function. (operator_length_standard): New function taking most code from length_of_subexp. (prefixify_expression): Remove register declarations. (prefixify_subexp): Remove large case and use operator_length instead. Remove register declarations. (operator_length): New function. Uses language-specific information. (exp_descriptor_standard): New constant. (parse_exp_1): Use renamings: dump_prefix_expression => dump_raw_expression and dump_postfix_expression => dump_prefix_expression. * expression.h (enum exp_opcode): Add definitions of OP_EXTENDED0 and OP_EXTENDED_LAST. (dump_prefix_expression): Rename to ... (dump_raw_expression): New name. (dump_postfix_expression): Rename to ... (dump_prefix_expression): New name. * expprint.c (print_subexp): Make global, remove static declaration. Remove register declarations. Use language-specific print_subexp. Move most existing code to print_subexp_standard. (print_subexp_standard): New function, containing code formerly in print_subexp. (op_name): Add expression to argument signature. Use langauge-specific op_name. Move most code to op_name_standard. (op_name_standard): New function, containing code formerly in op_name. (dump_subexp): Make global. Add comment. Use new version of op_name function. Use language-specific dump_subexp_body, and move most existing code to dump_subexp_body_standard. (dump_subexp_body): New function. (dump_subexp_body_standard): New function, containing code formerly in dump_subexp. (dump_prefix_expression): Rename to dump_raw_expression. Remove attempt to print the expression via print_expression: it can't work before the expression is prefixified! Use new version of op_name. (dump_raw_expression): Renamed from dump_prefix_expression. (dump_postfix_expression): Rename to dump_prefix_expression, since that's what it does! Remove 'note' parameter, since this routine must be used on prefixified expression. (dump_prefix_expression): Renamed from dump_postfix_expression. * language.c (unknown_language): Add default la_exp_desc field. (auto_language): Ditto. (local_language): Ditto. * jv-lang.c (java_language): Ditto. * f-lang.c (f_language_defn): Ditto. * c-lang.c (c_language_defn): Ditto. (cplus_language_defn): Ditto. (asm_language_defn): Ditto. (minimal_language_defn): Ditto. * p-lang.c (pascal_language_defn): Ditto. * m2-lang.c (m2_language_defn): Ditto. * scm-lang.c (scm_language_defn): Ditto. * objc-lang.c (objc_language_defn): Ditto. Index: current-public.21/gdb/p-lang.c --- current-public.21/gdb/p-lang.c Tue, 17 Jun 2003 02:39:19 -0700 hilfingr (GdbPub/e/26_p-lang.c 1.1.1.2 644) +++ submit.8(w)/gdb/p-lang.c Sat, 26 Jul 2003 22:59:24 -0700 hilfingr (GdbPub/e/26_p-lang.c 1.1.1.3 644) @@ -451,6 +451,7 @@ const struct language_defn pascal_langua range_check_on, type_check_on, case_sensitive_on, + &exp_descriptor_standard, pascal_parse, pascal_error, evaluate_subexp_standard, Index: current-public.21/gdb/c-lang.c --- current-public.21/gdb/c-lang.c Tue, 17 Jun 2003 02:39:19 -0700 hilfingr (GdbPub/g/28_c-lang.c 1.1.1.3 644) +++ submit.8(w)/gdb/c-lang.c Sat, 26 Jul 2003 22:59:24 -0700 hilfingr (GdbPub/g/28_c-lang.c 1.1.1.4 644) @@ -543,6 +543,7 @@ const struct language_defn c_language_de range_check_off, type_check_off, case_sensitive_on, + &exp_descriptor_standard, c_preprocess_and_parse, c_error, evaluate_subexp_standard, @@ -599,6 +600,7 @@ const struct language_defn cplus_languag range_check_off, type_check_off, case_sensitive_on, + &exp_descriptor_standard, c_preprocess_and_parse, c_error, evaluate_subexp_standard, @@ -632,6 +634,7 @@ const struct language_defn asm_language_ range_check_off, type_check_off, case_sensitive_on, + &exp_descriptor_standard, c_preprocess_and_parse, c_error, evaluate_subexp_standard, @@ -670,6 +673,7 @@ const struct language_defn minimal_langu range_check_off, type_check_off, case_sensitive_on, + &exp_descriptor_standard, c_preprocess_and_parse, c_error, evaluate_subexp_standard, Index: current-public.21/gdb/expprint.c --- current-public.21/gdb/expprint.c Fri, 18 Jul 2003 23:35:25 -0700 hilfingr (GdbPub/h/29_expprint.c 1.1.1.3 644) +++ submit.8(w)/gdb/expprint.c Tue, 26 Aug 2003 03:08:13 -0700 hilfingr (GdbPub/h/29_expprint.c 1.1.1.3.1.2 644) @@ -36,11 +36,6 @@ #include #endif -/* Prototypes for local functions */ - -static void print_subexp (struct expression *, int *, struct ui_file *, - enum precedence); - void print_expression (struct expression *exp, struct ui_file *stream) { @@ -53,13 +48,21 @@ print_expression (struct expression *exp if the precedence of the main operator of this subexpression is less, parentheses are needed here. */ -static void -print_subexp (register struct expression *exp, register int *pos, +void +print_subexp (struct expression *exp, int *pos, struct ui_file *stream, enum precedence prec) { - register unsigned tem; - register const struct op_print *op_print_tab; - register int pc; + exp->language_defn->la_exp_desc->print_subexp (exp, pos, stream, prec); +} + +/* Standard implementation of print_subexp for use in language_defn vectors. */ +void +print_subexp_standard (struct expression *exp, int *pos, + struct ui_file *stream, enum precedence prec) +{ + unsigned tem; + const struct op_print *op_print_tab; + int pc; unsigned nargs; register char *op_str; int assign_modify = 0; @@ -547,10 +550,22 @@ op_string (enum exp_opcode op) /* Support for dumping the raw data from expressions in a human readable form. */ -static char *op_name (int opcode); +static char *op_name (struct expression *, enum exp_opcode); +static int dump_subexp_body (struct expression *exp, struct ui_file *, int); + +/* Name for OPCODE, when it appears in expression EXP. */ static char * -op_name (int opcode) +op_name (struct expression *exp, enum exp_opcode opcode) +{ + return exp->language_defn->la_exp_desc->op_name (opcode); +} + +/* Default name for the standard operator OPCODE (i.e., one defined in + the definition of enum exp_opcode). */ + +char * +op_name_standard (enum exp_opcode opcode) { switch (opcode) { @@ -737,8 +752,8 @@ op_name (int opcode) } void -dump_prefix_expression (struct expression *exp, struct ui_file *stream, - char *note) +dump_raw_expression (struct expression *exp, struct ui_file *stream, + char *note) { int elt; char *opcode_name; @@ -747,11 +762,6 @@ dump_prefix_expression (struct expressio fprintf_filtered (stream, "Dump of expression @ "); gdb_print_host_address (exp, stream); - fprintf_filtered (stream, ", %s:\nExpression: `", note); - if (exp->elts[0].opcode != OP_TYPE) - print_expression (exp, stream); - else - fprintf_filtered (stream, "Type printing not yet supported...."); fprintf_filtered (stream, "'\n\tLanguage %s, %d elements, %ld bytes each.\n", exp->language_defn->la_name, exp->nelts, (long) sizeof (union exp_element)); @@ -760,7 +770,7 @@ dump_prefix_expression (struct expressio for (elt = 0; elt < exp->nelts; elt++) { fprintf_filtered (stream, "\t%5d ", elt); - opcode_name = op_name (exp->elts[elt].opcode); + opcode_name = op_name (exp, exp->elts[elt].opcode); fprintf_filtered (stream, "%20s ", opcode_name); print_longest (stream, 'd', 0, exp->elts[elt].longconst); @@ -778,10 +788,11 @@ dump_prefix_expression (struct expressio } } -static int dump_subexp (struct expression *exp, struct ui_file *stream, - int elt); +/* Dump the subexpression of prefix expression EXP whose operator is at + position ELT onto STREAM. Returns the position of the next + subexpression in EXP. */ -static int +int dump_subexp (struct expression *exp, struct ui_file *stream, int elt) { static int indent = 0; @@ -794,9 +805,34 @@ dump_subexp (struct expression *exp, str fprintf_filtered (stream, " "); indent += 2; - fprintf_filtered (stream, "%-20s ", op_name (exp->elts[elt].opcode)); + fprintf_filtered (stream, "%-20s ", op_name (exp, exp->elts[elt].opcode)); + + elt = dump_subexp_body (exp, stream, elt); - switch (exp->elts[elt++].opcode) + indent -= 2; + + return elt; +} + +/* Dump the operands of prefix expression EXP whose opcode is at + position ELT onto STREAM. Returns the position of the next + subexpression in EXP. */ + +static int +dump_subexp_body (struct expression *exp, struct ui_file *stream, int elt) +{ + return exp->language_defn->la_exp_desc->dump_subexp_body (exp, stream, elt); +} + +/* Default value for subexp_body in exp_descriptor vector. */ + +int +dump_subexp_body_standard (struct expression *exp, + struct ui_file *stream, int elt) +{ + int opcode = exp->elts[elt++].opcode; + + switch (opcode) { case TERNOP_COND: case TERNOP_SLICE: @@ -914,7 +950,7 @@ dump_subexp (struct expression *exp, str break; case OP_FUNCALL: { - int nargs; + int i, nargs; nargs = longest_to_int (exp->elts[elt].longconst); @@ -1006,20 +1042,17 @@ dump_subexp (struct expression *exp, str fprintf_filtered (stream, "Unknown format"); } - indent -= 2; - return elt; } void -dump_postfix_expression (struct expression *exp, struct ui_file *stream, - char *note) +dump_prefix_expression (struct expression *exp, struct ui_file *stream) { int elt; fprintf_filtered (stream, "Dump of expression @ "); gdb_print_host_address (exp, stream); - fprintf_filtered (stream, ", %s:\nExpression: `", note); + fputs_filtered (", after conversion to prefix form:\nExpression: `", stream); if (exp->elts[0].opcode != OP_TYPE) print_expression (exp, stream); else Index: current-public.21/gdb/expression.h --- current-public.21/gdb/expression.h Tue, 17 Jun 2003 02:35:33 -0700 hilfingr (GdbPub/h/30_expression 1.1.1.2 644) +++ submit.8(w)/gdb/expression.h Wed, 27 Aug 2003 00:24:54 -0700 hilfingr (GdbPub/h/30_expression 1.1.1.5 644) @@ -322,7 +322,22 @@ enum exp_opcode OP_EXPRSTRING, /* An Objective C Foundation Class NSString constant */ - OP_OBJC_NSSTRING + OP_OBJC_NSSTRING, + + /* First extension operator. Individual language modules define + extra operators they need as constants with values + OP_LANGUAGE_SPECIFIC0 + k, for k >= 0, using a separate + enumerated type definition: + enum foo_extension_operator { + BINOP_MOGRIFY = OP_EXTENDED0, + BINOP_FROB, + ... + }; */ + OP_EXTENDED0, + + /* Last possible extension operator. Defined simply to specify a + minimum range for the representation. */ + OP_EXTENDED_LAST = 0xff }; union exp_element @@ -393,11 +408,7 @@ extern void print_expression (struct exp extern char *op_string (enum exp_opcode); -extern void dump_prefix_expression (struct expression *, - struct ui_file *, - char *); -extern void dump_postfix_expression (struct expression *, - struct ui_file *, - char *); +extern void dump_raw_expression (struct expression *, struct ui_file *, char *); +extern void dump_prefix_expression (struct expression *, struct ui_file *); #endif /* !defined (EXPRESSION_H) */ Index: current-public.21/gdb/f-lang.c --- current-public.21/gdb/f-lang.c Tue, 17 Jun 2003 02:39:19 -0700 hilfingr (GdbPub/h/32_f-lang.c 1.1.1.2 644) +++ submit.8(w)/gdb/f-lang.c Sat, 26 Jul 2003 22:59:24 -0700 hilfingr (GdbPub/h/32_f-lang.c 1.1.1.3 644) @@ -462,6 +462,7 @@ const struct language_defn f_language_de range_check_on, type_check_on, case_sensitive_off, + &exp_descriptor_standard, f_parse, /* parser */ f_error, /* parser error function */ evaluate_subexp_standard, Index: current-public.21/gdb/jv-lang.c --- current-public.21/gdb/jv-lang.c Tue, 17 Jun 2003 02:41:56 -0700 hilfingr (GdbPub/i/30_jv-lang.c 1.1.1.3 644) +++ submit.8(w)/gdb/jv-lang.c Sat, 26 Jul 2003 22:59:24 -0700 hilfingr (GdbPub/i/30_jv-lang.c 1.1.1.3.1.1 644) @@ -1047,6 +1047,7 @@ const struct language_defn java_language range_check_off, type_check_off, case_sensitive_on, + &exp_descriptor_standard, java_parse, java_error, evaluate_subexp_java, Index: current-public.21/gdb/language.c --- current-public.21/gdb/language.c Fri, 22 Aug 2003 00:46:52 -0700 hilfingr (GdbPub/i/34_language.c 1.1.1.3.1.1 644) +++ submit.8(w)/gdb/language.c Fri, 22 Aug 2003 10:47:57 -0700 hilfingr (GdbPub/i/34_language.c 1.1.1.3.1.1.1.1 644) @@ -1267,6 +1267,7 @@ const struct language_defn unknown_langu range_check_off, type_check_off, case_sensitive_on, + &exp_descriptor_standard, unk_lang_parser, unk_lang_error, evaluate_subexp_standard, @@ -1301,6 +1302,7 @@ const struct language_defn auto_language range_check_off, type_check_off, case_sensitive_on, + &exp_descriptor_standard, unk_lang_parser, unk_lang_error, evaluate_subexp_standard, @@ -1334,6 +1336,7 @@ const struct language_defn local_languag range_check_off, type_check_off, case_sensitive_on, + &exp_descriptor_standard, unk_lang_parser, unk_lang_error, evaluate_subexp_standard, Index: current-public.21/gdb/language.h --- current-public.21/gdb/language.h Fri, 22 Aug 2003 00:46:52 -0700 hilfingr (GdbPub/i/35_language.h 1.1.1.3.1.1 644) +++ submit.8(w)/gdb/language.h Fri, 22 Aug 2003 10:48:02 -0700 hilfingr (GdbPub/i/35_language.h 1.1.1.3.1.1.1.1 644) @@ -167,6 +167,11 @@ struct language_defn /* Default case sensitivity */ enum case_sensitivity la_case_sensitivity; + /* Definitions related to expression printing, prefixifying, and + dumping */ + + const struct exp_descriptor *la_exp_desc; + /* Parser function. */ int (*la_parser) (void); Index: current-public.21/gdb/m2-lang.c --- current-public.21/gdb/m2-lang.c Tue, 17 Jun 2003 02:39:19 -0700 hilfingr (GdbPub/i/38_m2-lang.c 1.1.1.2 644) +++ submit.8(w)/gdb/m2-lang.c Sat, 26 Jul 2003 22:59:24 -0700 hilfingr (GdbPub/i/38_m2-lang.c 1.1.1.3 644) @@ -415,6 +415,7 @@ const struct language_defn m2_language_d range_check_on, type_check_on, case_sensitive_on, + &exp_descriptor_standard, m2_parse, /* parser */ m2_error, /* parser error function */ evaluate_subexp_standard, Index: current-public.21/gdb/parse.c --- current-public.21/gdb/parse.c Fri, 18 Jul 2003 23:35:25 -0700 hilfingr (GdbPub/j/29_parse.c 1.1.1.4 644) +++ submit.8(w)/gdb/parse.c Mon, 01 Sep 2003 00:10:14 -0700 hilfingr (GdbPub/j/29_parse.c 1.1.1.4.1.2 644) @@ -50,6 +50,16 @@ #include "gdb_assert.h" #include "block.h" +/* Standard set of definitions for printing, dumping, and prefixifying + * expressions. */ + +const struct exp_descriptor exp_descriptor_standard = + { + print_subexp_standard, + operator_length_standard, + op_name_standard, + dump_subexp_body_standard + }; /* Symbols which architectures can redefine. */ @@ -769,12 +779,11 @@ copy_name (struct stoken token) to prefix form (in which we can conveniently print or execute it). */ static void -prefixify_expression (register struct expression *expr) +prefixify_expression (struct expression *expr) { - register int len = - sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts); - register struct expression *temp; - register int inpos = expr->nelts, outpos = 0; + int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts); + struct expression *temp; + int inpos = expr->nelts, outpos = 0; temp = (struct expression *) alloca (len); @@ -784,18 +793,48 @@ prefixify_expression (register struct ex prefixify_subexp (temp, expr, inpos, outpos); } -/* Return the number of exp_elements in the subexpression of EXPR - whose last exp_element is at index ENDPOS - 1 in EXPR. */ +/* Return the number of exp_elements in the postfix subexpression + of EXPR whose operator is at index ENDPOS - 1 in EXPR. */ int -length_of_subexp (register struct expression *expr, register int endpos) +length_of_subexp (struct expression *expr, int endpos) +{ + int oplen, args, i; + + operator_length (expr, endpos, &oplen, &args); + + while (args > 0) + { + oplen += length_of_subexp (expr, endpos - oplen); + args--; + } + + return oplen; +} + +/* Sets *OPLENP to the length of the operator whose (last) index is + ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that + operator takes. */ + +void +operator_length (struct expression *expr, int endpos, int *oplenp, int *argsp) { - register int oplen = 1; - register int args = 0; - register int i; + expr->language_defn->la_exp_desc->operator_length (expr, endpos, + oplenp, argsp); +} + +/* Default value for operator_length in exp_descriptor vectors. */ + +void +operator_length_standard (struct expression *expr, int endpos, + int *oplenp, int *argsp) +{ + int oplen = 1; + int args = 0; + int i; if (endpos < 1) - error ("?error in length_of_subexp"); + error ("?error in operator_length_standard"); i = (int) expr->elts[endpos - 1].opcode; @@ -916,13 +955,8 @@ length_of_subexp (register struct expres args = 1 + (i < (int) BINOP_END); } - while (args > 0) - { - oplen += length_of_subexp (expr, endpos - oplen); - args--; - } - - return oplen; + *oplenp = oplen; + *argsp = args; } /* Copy the subexpression ending just before index INEND in INEXPR @@ -930,135 +964,16 @@ length_of_subexp (register struct expres In the process, convert it from suffix to prefix form. */ static void -prefixify_subexp (register struct expression *inexpr, - struct expression *outexpr, register int inend, int outbeg) +prefixify_subexp (struct expression *inexpr, + struct expression *outexpr, int inend, int outbeg) { - register int oplen = 1; - register int args = 0; - register int i; + int oplen; + int args; + int i; int *arglens; enum exp_opcode opcode; - /* Compute how long the last operation is (in OPLEN), - and also how many preceding subexpressions serve as - arguments for it (in ARGS). */ - - opcode = inexpr->elts[inend - 1].opcode; - switch (opcode) - { - /* C++ */ - case OP_SCOPE: - oplen = longest_to_int (inexpr->elts[inend - 2].longconst); - oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1); - break; - - case OP_LONG: - case OP_DOUBLE: - case OP_VAR_VALUE: - oplen = 4; - break; - - case OP_TYPE: - case OP_BOOL: - case OP_LAST: - case OP_REGISTER: - case OP_INTERNALVAR: - oplen = 3; - break; - - case OP_COMPLEX: - oplen = 1; - args = 2; - break; - - case OP_FUNCALL: - case OP_F77_UNDETERMINED_ARGLIST: - oplen = 3; - args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst); - break; - - case OP_OBJC_MSGCALL: /* Objective C message (method) call */ - oplen = 4; - args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst); - break; - - case UNOP_MIN: - case UNOP_MAX: - oplen = 3; - break; - - case UNOP_CAST: - case UNOP_MEMVAL: - oplen = 3; - args = 1; - break; - - case UNOP_ABS: - case UNOP_CAP: - case UNOP_CHR: - case UNOP_FLOAT: - case UNOP_HIGH: - case UNOP_ODD: - case UNOP_ORD: - case UNOP_TRUNC: - oplen = 1; - args = 1; - break; - - case STRUCTOP_STRUCT: - case STRUCTOP_PTR: - case OP_LABELED: - args = 1; - /* fall through */ - case OP_M2_STRING: - case OP_STRING: - case OP_OBJC_NSSTRING: /* Objective C Foundation Class NSString constant */ - case OP_OBJC_SELECTOR: /* Objective C "@selector" pseudo-op */ - case OP_NAME: - case OP_EXPRSTRING: - oplen = longest_to_int (inexpr->elts[inend - 2].longconst); - oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1); - break; - - case OP_BITSTRING: - oplen = longest_to_int (inexpr->elts[inend - 2].longconst); - oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT; - oplen = 4 + BYTES_TO_EXP_ELEM (oplen); - break; - - case OP_ARRAY: - oplen = 4; - args = longest_to_int (inexpr->elts[inend - 2].longconst); - args -= longest_to_int (inexpr->elts[inend - 3].longconst); - args += 1; - break; - - case TERNOP_COND: - case TERNOP_SLICE: - case TERNOP_SLICE_COUNT: - args = 3; - break; - - case BINOP_ASSIGN_MODIFY: - oplen = 3; - args = 2; - break; - - /* Modula-2 */ - case MULTI_SUBSCRIPT: - oplen = 3; - args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst); - break; - - /* C++ */ - case OP_THIS: - case OP_OBJC_SELF: - oplen = 2; - break; - - default: - args = 1 + ((int) opcode < (int) BINOP_END); - } + operator_length (inexpr, inend, &oplen, &args); /* Copy the final operator itself, from the end of the input to the beginning of the output. */ @@ -1156,14 +1071,13 @@ parse_exp_1 (char **stringptr, struct bl parser, to a prefix form. */ if (expressiondebug) - dump_prefix_expression (expout, gdb_stdlog, - "before conversion to prefix form"); + dump_raw_expression (expout, gdb_stdlog, + "before conversion to prefix form"); prefixify_expression (expout); if (expressiondebug) - dump_postfix_expression (expout, gdb_stdlog, - "after conversion to prefix form"); + dump_prefix_expression (expout, gdb_stdlog); *stringptr = lexptr; return expout; Index: current-public.21/gdb/parser-defs.h --- current-public.21/gdb/parser-defs.h Tue, 17 Jun 2003 02:35:33 -0700 hilfingr (GdbPub/j/30_parser-def 1.1.1.2 644) +++ submit.8(w)/gdb/parser-defs.h Mon, 01 Sep 2003 00:08:49 -0700 hilfingr (GdbPub/j/30_parser-def 1.1.1.2.1.2 644) @@ -159,6 +159,17 @@ extern int pop_type_int (void); extern int length_of_subexp (struct expression *, int); +extern int dump_subexp (struct expression *, struct ui_file *, int); + +extern int dump_subexp_body_standard (struct expression *, + struct ui_file *, int); + +extern void operator_length (struct expression *, int, int *, int *); + +extern void operator_length_standard (struct expression *, int, int *, int *); + +extern char *op_name_standard (enum exp_opcode); + extern struct type *follow_types (struct type *); /* During parsing of a C expression, the pointer to the next character @@ -219,6 +230,42 @@ struct op_print For a unary operator: 1 iff postfix. */ int right_assoc; }; + +/* Information needed to print and prefixify expressions for a given + language. */ + +struct exp_descriptor + { + /* Print subexpression */ + void (*print_subexp) (struct expression *, int *, struct ui_file *, + enum precedence); + + /* Returns number of exp_elements needed to represent an operator and + the number of subexpressions it takes. */ + void (*operator_length) (struct expression*, int, int*, int *); + + /* Name of this operator for dumping purposes. */ + char *(*op_name) (enum exp_opcode); + + /* Dump the rest of this (prefix) expression after the operator + itself has been printed. See dump_subexp_body_standard in + (expprint.c). */ + int (*dump_subexp_body) (struct expression *, struct ui_file *, int); + }; + + +/* Default descriptor containing standard definitions of all + elements. */ +extern const struct exp_descriptor exp_descriptor_standard; + +/* Functions used by language-specific extended operators to (recursively) + print/dump subexpressions */ + +extern void print_subexp (struct expression *, int *, struct ui_file *, + enum precedence); + +extern void print_subexp_standard (struct expression *, int *, + struct ui_file *, enum precedence); /* Function used to avoid direct calls to fprintf in the code generated by the bison parser. */ Index: current-public.21/gdb/scm-lang.c --- current-public.21/gdb/scm-lang.c Tue, 17 Jun 2003 02:39:19 -0700 hilfingr (GdbPub/k/14_scm-lang.c 1.1.1.3 644) +++ submit.8(w)/gdb/scm-lang.c Sat, 26 Jul 2003 22:59:24 -0700 hilfingr (GdbPub/k/14_scm-lang.c 1.1.1.4 644) @@ -241,6 +241,7 @@ const struct language_defn scm_language_ range_check_off, type_check_off, case_sensitive_off, + &exp_descriptor_standard, scm_parse, c_error, evaluate_subexp_scm, Index: current-public.21/gdb/objc-lang.c --- current-public.21/gdb/objc-lang.c Tue, 17 Jun 2003 02:41:56 -0700 hilfingr (GdbPub/C/b/24_objc-lang. 1.4 644) +++ submit.8(w)/gdb/objc-lang.c Sat, 26 Jul 2003 22:59:24 -0700 hilfingr (GdbPub/C/b/24_objc-lang. 1.4.1.1 644) @@ -659,6 +659,7 @@ const struct language_defn objc_language range_check_off, type_check_off, case_sensitive_on, + &exp_descriptor_standard, objc_parse, objc_error, evaluate_subexp_standard,