X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fexpprint.c;h=4effea27c2483dc0d09049c7acd79dc66c04e07d;hb=d7cd1264695236f7bc59123655b9dc8f85e01cb1;hp=18b0ac766e76c0f3ff39f153960ca56031694515;hpb=f661c4ca088988b2ed56693d7d6c97f43e435600;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/expprint.c b/gdb/expprint.c index 18b0ac766e..4effea27c2 100644 --- a/gdb/expprint.c +++ b/gdb/expprint.c @@ -15,7 +15,7 @@ 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., 675 Mass Ave, Cambridge, MA 02139, USA. */ +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "defs.h" #include "symtab.h" @@ -28,15 +28,12 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Prototypes for local functions */ static void -print_subexp PARAMS ((struct expression *, int *, FILE *, enum precedence)); - -static void -print_simple_m2_func PARAMS ((char *, struct expression *, int *, FILE *)); +print_subexp PARAMS ((struct expression *, int *, GDB_FILE *, enum precedence)); void print_expression (exp, stream) struct expression *exp; - FILE *stream; + GDB_FILE *stream; { int pc = 0; print_subexp (exp, &pc, stream, PREC_NULL); @@ -51,7 +48,7 @@ static void print_subexp (exp, pos, stream, prec) register struct expression *exp; register int *pos; - FILE *stream; + GDB_FILE *stream; enum precedence prec; { register unsigned tem; @@ -61,11 +58,11 @@ print_subexp (exp, pos, stream, prec) register char *op_str; int assign_modify = 0; enum exp_opcode opcode; - enum precedence myprec; + enum precedence myprec = PREC_NULL; /* Set to 1 for a right-associative operator. */ - int assoc; - value val; - char *tempstr; + int assoc = 0; + value_ptr val; + char *tempstr = NULL; op_print_tab = exp->language_defn->la_op_print_tab; pc = (*pos)++; @@ -99,8 +96,19 @@ print_subexp (exp, pos, stream, prec) return; case OP_VAR_VALUE: - (*pos) += 2; - fputs_filtered (SYMBOL_SOURCE_NAME (exp->elts[pc + 1].symbol), stream); + { + struct block *b; + (*pos) += 3; + b = exp->elts[pc + 1].block; + if (b != NULL + && BLOCK_FUNCTION (b) != NULL + && SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b)) != NULL) + { + fputs_filtered (SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b)), stream); + fputs_filtered ("::", stream); + } + fputs_filtered (SYMBOL_SOURCE_NAME (exp->elts[pc + 2].symbol), stream); + } return; case OP_LAST: @@ -142,6 +150,13 @@ print_subexp (exp, pos, stream, prec) fputs_filtered (")", stream); return; + case OP_NAME: + case OP_EXPRSTRING: + nargs = longest_to_int (exp -> elts[pc + 1].longconst); + (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1); + fputs_filtered (&exp->elts[pc + 2].string, stream); + return; + case OP_STRING: nargs = longest_to_int (exp -> elts[pc + 1].longconst); (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1); @@ -152,8 +167,11 @@ print_subexp (exp, pos, stream, prec) return; case OP_BITSTRING: - error ("support for OP_BITSTRING unimplemented"); - break; + nargs = longest_to_int (exp -> elts[pc + 1].longconst); + (*pos) + += 3 + BYTES_TO_EXP_ELEM ((nargs + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT); + fprintf (stream, "B''"); + return; case OP_ARRAY: (*pos) += 3; @@ -198,7 +216,8 @@ print_subexp (exp, pos, stream, prec) } else { - fputs_filtered (" {", stream); + int is_chill = exp->language_defn->la_language == language_chill; + fputs_filtered (is_chill ? " [" : " {", stream); for (tem = 0; tem < nargs; tem++) { if (tem != 0) @@ -207,10 +226,37 @@ print_subexp (exp, pos, stream, prec) } print_subexp (exp, pos, stream, PREC_ABOVE_COMMA); } - fputs_filtered ("}", stream); + fputs_filtered (is_chill ? "]" : "}", stream); } return; + case OP_LABELED: + tem = longest_to_int (exp->elts[pc + 1].longconst); + (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1); + + if (exp->language_defn->la_language == language_chill) + { + fputs_filtered (".", stream); + fputs_filtered (&exp->elts[pc + 2].string, stream); + fputs_filtered (exp->elts[*pos].opcode == OP_LABELED ? ", " + : ": ", + stream); + } + else + { + /* Gcc support both these syntaxes. Unsure which is preferred. */ +#if 1 + fputs_filtered (&exp->elts[pc + 2].string, stream); + fputs_filtered (": ", stream); +#else + fputs_filtered (".", stream); + fputs_filtered (&exp->elts[pc + 2].string, stream); + fputs_filtered ("=", stream); +#endif + } + print_subexp (exp, pos, stream, PREC_SUFFIX); + return; + case TERNOP_COND: if ((int) prec > (int) PREC_COMMA) fputs_filtered ("(", stream); @@ -227,6 +273,16 @@ print_subexp (exp, pos, stream, prec) fputs_filtered (")", stream); return; + case TERNOP_SLICE: + case TERNOP_SLICE_COUNT: + print_subexp (exp, pos, stream, PREC_SUFFIX); + fputs_filtered ("(", stream); + print_subexp (exp, pos, stream, PREC_ABOVE_COMMA); + fputs_filtered (opcode == TERNOP_SLICE ? " : " : " UP ", stream); + print_subexp (exp, pos, stream, PREC_ABOVE_COMMA); + fputs_filtered (")", stream); + return; + case STRUCTOP_STRUCT: tem = longest_to_int (exp->elts[pc + 1].longconst); (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1); @@ -244,6 +300,19 @@ print_subexp (exp, pos, stream, prec) fputs_filtered (&exp->elts[pc + 2].string, stream); return; +/* start-sanitize-gm */ +#ifdef GENERAL_MAGIC_HACKS + case STRUCTOP_FIELD: + tem = longest_to_int (exp->elts[pc + 1].longconst); + (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1); + print_subexp (exp, pos, stream, PREC_SUFFIX); + fputs_filtered ("@", stream); + fputs_filtered (&exp->elts[pc + 2].string, stream); + return; + +#endif /* GENERAL_MAGIC_HACKS */ +/* end-sanitize-gm */ + case BINOP_SUBSCRIPT: print_subexp (exp, pos, stream, PREC_SUFFIX); fputs_filtered ("[", stream); @@ -329,63 +398,23 @@ print_subexp (exp, pos, stream, prec) (*pos) += 2; nargs = longest_to_int (exp->elts[pc + 1].longconst); print_subexp (exp, pos, stream, PREC_SUFFIX); - fprintf (stream, " ["); + fprintf_unfiltered (stream, " ["); for (tem = 0; tem < nargs; tem++) { if (tem != 0) - fprintf (stream, ", "); + fprintf_unfiltered (stream, ", "); print_subexp (exp, pos, stream, PREC_ABOVE_COMMA); } - fprintf (stream, "]"); + fprintf_unfiltered (stream, "]"); return; case BINOP_VAL: (*pos)+=2; - fprintf(stream,"VAL("); + fprintf_unfiltered(stream,"VAL("); type_print(exp->elts[pc+1].type,"",stream,0); - fprintf(stream,","); + fprintf_unfiltered(stream,","); print_subexp(exp,pos,stream,PREC_PREFIX); - fprintf(stream,")"); - return; - - case UNOP_CAP: - print_simple_m2_func("CAP",exp,pos,stream); - return; - - case UNOP_CHR: - print_simple_m2_func("CHR",exp,pos,stream); - return; - - case UNOP_ORD: - print_simple_m2_func("ORD",exp,pos,stream); - return; - - case UNOP_ABS: - print_simple_m2_func("ABS",exp,pos,stream); - return; - - case UNOP_FLOAT: - print_simple_m2_func("FLOAT",exp,pos,stream); - return; - - case UNOP_HIGH: - print_simple_m2_func("HIGH",exp,pos,stream); - return; - - case UNOP_MAX: - print_simple_m2_func("MAX",exp,pos,stream); - return; - - case UNOP_MIN: - print_simple_m2_func("MIN",exp,pos,stream); - return; - - case UNOP_ODD: - print_simple_m2_func("ODD",exp,pos,stream); - return; - - case UNOP_TRUNC: - print_simple_m2_func("TRUNC",exp,pos,stream); + fprintf_unfiltered(stream,")"); return; case BINOP_INCL: @@ -411,13 +440,27 @@ print_subexp (exp, pos, stream, prec) error ("Invalid expression"); } + /* Note that PREC_BUILTIN will always emit parentheses. */ if ((int) myprec < (int) prec) fputs_filtered ("(", stream); if ((int) opcode > (int) BINOP_END) { - /* Unary prefix operator. */ - fputs_filtered (op_str, stream); - print_subexp (exp, pos, stream, PREC_PREFIX); + if (assoc) + { + /* Unary postfix operator. */ + print_subexp (exp, pos, stream, PREC_SUFFIX); + fputs_filtered (op_str, stream); + } + else + { + /* Unary prefix operator. */ + fputs_filtered (op_str, stream); + if (myprec == PREC_BUILTIN_FUNCTION) + fputs_filtered ("(", stream); + print_subexp (exp, pos, stream, PREC_PREFIX); + if (myprec == PREC_BUILTIN_FUNCTION) + fputs_filtered (")", stream); + } } else { @@ -445,23 +488,6 @@ print_subexp (exp, pos, stream, prec) fputs_filtered (")", stream); } -/* Print out something of the form (). - This is used to print out some builtin Modula-2 - functions. - FIXME: There is probably some way to get the precedence - rules to do this (print a unary operand with parens around it). */ -static void -print_simple_m2_func(s,exp,pos,stream) - char *s; - register struct expression *exp; - register int *pos; - FILE *stream; -{ - fprintf(stream,"%s(",s); - print_subexp(exp,pos,stream,PREC_PREFIX); - fprintf(stream,")"); -} - /* Return the operator corresponding to opcode OP as a string. NULL indicates that the opcode was not found in the current language table. */ @@ -487,7 +513,7 @@ op_string(op) void dump_expression (exp, stream, note) struct expression *exp; - FILE *stream; + GDB_FILE *stream; char *note; { int elt; @@ -495,7 +521,9 @@ dump_expression (exp, stream, note) char *eltscan; int eltsize; - fprintf_filtered (stream, "Dump of expression @ 0x%x, %s:\n", exp, note); + fprintf_filtered (stream, "Dump of expression @ "); + gdb_print_address (exp, stream); + fprintf_filtered (stream, ", %s:\n", note); fprintf_filtered (stream, "\tLanguage %s, %d elements, %d bytes each.\n", exp->language_defn->la_name, exp -> nelts, sizeof (union exp_element)); @@ -546,6 +574,8 @@ dump_expression (exp, stream, note) case BINOP_CONCAT: opcode_name = "BINOP_CONCAT"; break; case BINOP_END: opcode_name = "BINOP_END"; break; case TERNOP_COND: opcode_name = "TERNOP_COND"; break; + case TERNOP_SLICE: opcode_name = "TERNOP_SLICE"; break; + case TERNOP_SLICE_COUNT: opcode_name = "TERNOP_SLICE_COUNT"; break; case OP_LONG: opcode_name = "OP_LONG"; break; case OP_DOUBLE: opcode_name = "OP_DOUBLE"; break; case OP_VAR_VALUE: opcode_name = "OP_VAR_VALUE"; break; @@ -568,6 +598,9 @@ dump_expression (exp, stream, note) case UNOP_PREDECREMENT: opcode_name = "UNOP_PREDECREMENT"; break; case UNOP_POSTDECREMENT: opcode_name = "UNOP_POSTDECREMENT"; break; case UNOP_SIZEOF: opcode_name = "UNOP_SIZEOF"; break; + case UNOP_LOWER: opcode_name = "UNOP_LOWER"; break; + case UNOP_UPPER: opcode_name = "UNOP_UPPER"; break; + case UNOP_LENGTH: opcode_name = "UNOP_LENGTH"; break; case UNOP_PLUS: opcode_name = "UNOP_PLUS"; break; case UNOP_CAP: opcode_name = "UNOP_CAP"; break; case UNOP_CHR: opcode_name = "UNOP_CHR"; break; @@ -583,13 +616,19 @@ dump_expression (exp, stream, note) case OP_M2_STRING: opcode_name = "OP_M2_STRING"; break; case STRUCTOP_STRUCT: opcode_name = "STRUCTOP_STRUCT"; break; case STRUCTOP_PTR: opcode_name = "STRUCTOP_PTR"; break; +/* start-sanitize-gm */ +#ifdef GENERAL_MAGIC_HACKS ++ case STRUCTOP_FIELD: opcode_name = "STRUCTOP_FIELD"; break; +#endif /* GENERAL_MAGIC_HACKS */ +/* end-sanitize-gm */ case OP_THIS: opcode_name = "OP_THIS"; break; case OP_SCOPE: opcode_name = "OP_SCOPE"; break; case OP_TYPE: opcode_name = "OP_TYPE"; break; + case OP_LABELED: opcode_name = "OP_LABELED"; break; } fprintf_filtered (stream, "%20s ", opcode_name); fprintf_filtered (stream, -#if defined (LONG_LONG) +#if defined (PRINTF_HAS_LONG_LONG) "%ll16x ", #else "%l16x ",