![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to valprint.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GNU Debugger] / gdb|
Return to valprint.c CVS log | Up to [GNU Debugger] / gdb |
1.1 root 1: /* Print values for GNU debugger gdb. 1.1.1.6 ! root 2: Copyright (C) 1986, 1988 Free Software Foundation, Inc. 1.1 root 3: 4: GDB is distributed in the hope that it will be useful, but WITHOUT ANY 5: WARRANTY. No author or distributor accepts responsibility to anyone 6: for the consequences of using it or for whether it serves any 7: particular purpose or works at all, unless he says so in writing. 8: Refer to the GDB General Public License for full details. 9: 10: Everyone is granted permission to copy, modify and redistribute GDB, 11: but only under the conditions described in the GDB General Public 12: License. A copy of this license is supposed to have been given to you 13: along with GDB so you can know your rights and responsibilities. It 14: should be in a file named COPYING. Among other things, the copyright 15: notice and this notice must be preserved on all copies. 16: 17: In other words, go ahead and share GDB, but don't try to stop 18: anyone else from sharing it farther. Help stamp out software hoarding! 19: */ 20: 21: #include <stdio.h> 22: #include "defs.h" 23: #include "initialize.h" 1.1.1.6 ! root 24: #include "param.h" 1.1 root 25: #include "symtab.h" 26: #include "value.h" 27: 28: /* Maximum number of chars to print for a string pointer value 29: or vector contents. */ 30: 31: static int print_max; 32: 33: static void type_print_varspec_suffix (); 34: static void type_print_varspec_prefix (); 35: static void type_print_base (); 36: 37: START_FILE 38: 39: char **unsigned_type_table; 40: char **signed_type_table; 41: char **float_type_table; 42: 43: /* Print the value VAL in C-ish syntax on stream STREAM. 1.1.1.6 ! root 44: FORMAT is a format-letter, or 0 for print in natural format of data type. 1.1 root 45: If the object printed is a string pointer, returns 46: the number of string bytes printed. */ 47: 1.1.1.6 ! root 48: value_print (val, stream, format) 1.1 root 49: value val; 50: FILE *stream; 1.1.1.6 ! root 51: char format; 1.1 root 52: { 53: register int i, n, typelen; 54: 55: /* A "repeated" value really contains several values in a row. 56: They are made by the @ operator. 57: Print such values as if they were arrays. */ 58: 59: if (VALUE_REPEATED (val)) 60: { 61: n = VALUE_REPETITIONS (val); 62: typelen = TYPE_LENGTH (VALUE_TYPE (val)); 63: fputc ('{', stream); 64: /* Print arrays of characters using string syntax. */ 1.1.1.6 ! root 65: if (typelen == 1 && TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT ! 66: && format == 0) 1.1 root 67: { 68: fputc ('"', stream); 69: for (i = 0; i < n && i < print_max; i++) 70: { 71: QUIT; 1.1.1.6 ! root 72: printchar (VALUE_CONTENTS (val)[i], stream, '"'); 1.1 root 73: } 74: if (i < n) 75: fprintf (stream, "..."); 76: fputc ('"', stream); 77: } 78: else 79: { 80: for (i = 0; i < n && i < print_max; i++) 81: { 82: if (i) 83: fprintf (stream, ", "); 84: val_print (VALUE_TYPE (val), VALUE_CONTENTS (val) + typelen * i, 1.1.1.6 ! root 85: VALUE_ADDRESS (val) + typelen * i, stream, format); 1.1 root 86: } 87: if (i < n) 88: fprintf (stream, "..."); 89: } 90: fputc ('}', stream); 91: } 92: else 93: { 1.1.1.6 ! root 94: /* A simple (nonrepeated) value */ ! 95: /* If it is a pointer, indicate what it points to. */ 1.1 root 96: if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_PTR) 97: { 98: fprintf (stream, "("); 99: type_print (VALUE_TYPE (val), "", stream, -1); 100: fprintf (stream, ") "); 101: } 102: return val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), 1.1.1.6 ! root 103: VALUE_ADDRESS (val), stream, format); 1.1 root 104: } 105: } 106: 1.1.1.6 ! root 107: /* Print data of type TYPE located at VALADDR (within GDB), ! 108: which came from the inferior at address ADDRESS, ! 109: onto stdio stream STREAM according to FORMAT ! 110: (a letter or 0 for natural format). 1.1 root 111: 112: If the data are a string pointer, returns the number of 113: sting characters printed. */ 114: 115: int 1.1.1.6 ! root 116: val_print (type, valaddr, address, stream, format) 1.1 root 117: struct type *type; 118: char *valaddr; 119: CORE_ADDR address; 120: FILE *stream; 1.1.1.6 ! root 121: char format; 1.1 root 122: { 123: register int i; 124: int len; 125: struct type *elttype; 126: int eltlen; 127: int val; 128: unsigned char c; 129: 130: QUIT; 131: 132: switch (TYPE_CODE (type)) 133: { 134: case TYPE_CODE_ARRAY: 135: if (TYPE_LENGTH (type) >= 0) 136: { 137: elttype = TYPE_TARGET_TYPE (type); 138: eltlen = TYPE_LENGTH (elttype); 139: len = TYPE_LENGTH (type) / eltlen; 140: fprintf (stream, "{"); 141: /* For an array of chars, print with string syntax. */ 1.1.1.6 ! root 142: if (eltlen == 1 && TYPE_CODE (elttype) == TYPE_CODE_INT ! 143: && format == 0) 1.1 root 144: { 145: fputc ('"', stream); 146: for (i = 0; i < len && i < print_max; i++) 147: { 148: QUIT; 1.1.1.6 ! root 149: printchar (valaddr[i], stream, '"'); 1.1 root 150: } 151: if (i < len) 152: fprintf (stream, "..."); 153: fputc ('"', stream); 154: } 155: else 156: { 157: for (i = 0; i < len && i < print_max; i++) 158: { 159: if (i) fprintf (stream, ", "); 160: val_print (elttype, valaddr + i * eltlen, 1.1.1.6 ! root 161: 0, stream, format); 1.1 root 162: } 163: if (i < len) 164: fprintf (stream, "..."); 165: } 166: fprintf (stream, "}"); 167: break; 168: } 169: /* Array of unspecified length: treat like pointer. */ 170: 171: case TYPE_CODE_PTR: 1.1.1.6 ! root 172: if (format) 1.1.1.4 root 173: { 1.1.1.6 ! root 174: print_scalar_formatted (valaddr, type, format, 0, stream); ! 175: break; 1.1.1.4 root 176: } 1.1.1.6 ! root 177: fprintf (stream, "0x%x", * (int *) valaddr); ! 178: /* For a pointer to char or unsigned char, ! 179: also print the string pointed to, unless pointer is null. */ ! 180: ! 181: /* For an array of chars, print with string syntax. */ ! 182: elttype = TYPE_TARGET_TYPE (type); ! 183: if (TYPE_LENGTH (elttype) == 1 && TYPE_CODE (elttype) == TYPE_CODE_INT ! 184: && format == 0 ! 185: && unpack_long (type, valaddr) != 0) 1.1.1.4 root 186: { 1.1.1.6 ! root 187: fputc (' ', stream); ! 188: fputc ('"', stream); ! 189: for (i = 0; i < print_max; i++) 1.1.1.4 root 190: { 1.1.1.6 ! root 191: QUIT; ! 192: read_memory (unpack_long (type, valaddr) + i, &c, 1); ! 193: if (c == 0) ! 194: break; ! 195: printchar (c, stream, '"'); 1.1.1.4 root 196: } 1.1.1.6 ! root 197: fputc ('"', stream); ! 198: if (i == print_max) ! 199: fprintf (stream, "..."); ! 200: fflush (stream); ! 201: /* Return number of characters printed, plus one for the ! 202: terminating null if we have "reached the end". */ ! 203: return i + (i != print_max); 1.1.1.4 root 204: } 205: break; 206: 1.1 root 207: case TYPE_CODE_STRUCT: 208: case TYPE_CODE_UNION: 209: fprintf (stream, "{"); 210: len = TYPE_NFIELDS (type); 1.1.1.6 ! root 211: for (i = 0; i < len; i++) 1.1 root 212: { 213: if (i) fprintf (stream, ", "); 214: fprintf (stream, "%s = ", TYPE_FIELD_NAME (type, i)); 1.1.1.6 ! root 215: if (TYPE_FIELD_PACKED (type, i)) 1.1 root 216: { 217: val = unpack_field_as_long (type, valaddr, i); 1.1.1.6 ! root 218: val_print (TYPE_FIELD_TYPE (type, i), &val, 0, stream, format); 1.1 root 219: } 220: else 1.1.1.6 ! root 221: val_print (TYPE_FIELD_TYPE (type, i), ! 222: valaddr + TYPE_FIELD_BITPOS (type, i) / 8, ! 223: 0, stream, format); 1.1 root 224: } 225: fprintf (stream, "}"); 226: break; 227: 228: case TYPE_CODE_ENUM: 1.1.1.6 ! root 229: if (format) ! 230: { ! 231: print_scalar_formatted (valaddr, type, format, 0, stream); ! 232: break; ! 233: } 1.1 root 234: len = TYPE_NFIELDS (type); 235: val = unpack_long (builtin_type_int, valaddr); 236: for (i = 0; i < len; i++) 237: { 238: QUIT; 239: if (val == TYPE_FIELD_VALUE (type, i)) 240: break; 241: } 242: if (i < len) 243: fprintf (stream, "%s", TYPE_FIELD_NAME (type, i)); 244: else 245: fprintf (stream, "%d", val); 246: break; 247: 248: case TYPE_CODE_FUNC: 1.1.1.6 ! root 249: if (format) ! 250: { ! 251: print_scalar_formatted (valaddr, type, format, 0, stream); ! 252: break; ! 253: } 1.1 root 254: fprintf (stream, "{"); 255: type_print (type, "", stream, -1); 256: fprintf (stream, "} "); 257: fprintf (stream, "0x%x", address); 258: break; 259: 260: case TYPE_CODE_INT: 1.1.1.6 ! root 261: if (format) ! 262: { ! 263: print_scalar_formatted (valaddr, type, format, 0, stream); ! 264: break; ! 265: } 1.1 root 266: fprintf (stream, 267: TYPE_UNSIGNED (type) ? "%u" : "%d", 268: unpack_long (type, valaddr)); 1.1.1.6 ! root 269: if (TYPE_LENGTH (type) == 1) 1.1 root 270: { 271: fprintf (stream, " '"); 1.1.1.6 ! root 272: printchar (unpack_long (type, valaddr), stream, '\''); 1.1 root 273: fputc ('\'', stream); 274: } 275: break; 276: 277: case TYPE_CODE_FLT: 1.1.1.6 ! root 278: if (format) ! 279: { ! 280: print_scalar_formatted (valaddr, type, format, 0, stream); ! 281: break; ! 282: } 1.1.1.2 root 283: #ifdef IEEE_FLOAT 284: if (is_nan (unpack_double (type, valaddr))) 285: { 286: fprintf (stream, "Nan"); 287: break; 288: } 289: #endif 1.1 root 290: fprintf (stream, "%g", unpack_double (type, valaddr)); 291: break; 292: 293: case TYPE_CODE_VOID: 294: fprintf (stream, "void"); 295: break; 296: 297: default: 298: error ("Invalid type code in symbol table."); 299: } 300: fflush (stream); 301: } 302: 1.1.1.2 root 303: #ifdef IEEE_FLOAT 304: 305: union ieee { 306: int i[2]; 307: double d; 308: }; 309: 310: /* Nonzero if ARG (a double) is a NAN. */ 311: 312: int 313: is_nan (arg) 314: union ieee arg; 315: { 316: int lowhalf, highhalf; 317: union { int i; char c; } test; 318: 319: /* Separate the high and low words of the double. 320: Distinguish big and little-endian machines. */ 321: test.i = 1; 322: if (test.c != 1) 323: /* Big-endian machine */ 324: lowhalf = arg.i[1], highhalf = arg.i[0]; 325: else 326: lowhalf = arg.i[0], highhalf = arg.i[1]; 327: 328: /* Nan: exponent is the maximum possible, and fraction is nonzero. */ 329: return (((highhalf>>20) & 0x7ff) == 0x7ff 330: && 331: ! ((highhalf & 0xfffff == 0) && (lowhalf == 0))); 332: } 333: #endif 334: 1.1 root 335: /* Print a description of a type TYPE 336: in the form of a declaration of a variable named VARSTRING. 337: Output goes to STREAM (via stdio). 338: If SHOW is positive, we show the contents of the outermost level 339: of structure even if there is a type name that could be used instead. 340: If SHOW is negative, we never show the details of elements' types. */ 341: 342: type_print (type, varstring, stream, show) 343: struct type *type; 344: char *varstring; 345: FILE *stream; 346: int show; 347: { 348: type_print_1 (type, varstring, stream, show, 0); 349: } 350: 351: /* LEVEL is the depth to indent lines by. */ 352: 353: type_print_1 (type, varstring, stream, show, level) 354: struct type *type; 355: char *varstring; 356: FILE *stream; 357: int show; 358: int level; 359: { 360: register enum type_code code; 361: type_print_base (type, stream, show, level); 362: code = TYPE_CODE (type); 363: if ((varstring && *varstring) 364: || 365: /* Need a space if going to print stars or brackets; 366: but not if we will print just a type name. */ 367: ((show > 0 || TYPE_NAME (type) == 0) 368: && 369: (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC 1.1.1.6 ! root 370: || code == TYPE_CODE_ARRAY))) 1.1 root 371: fprintf (stream, " "); 372: type_print_varspec_prefix (type, stream, show, 0); 373: fprintf (stream, "%s", varstring); 374: type_print_varspec_suffix (type, stream, show, 0); 375: } 376: 377: /* Print any asterisks or open-parentheses needed before the 378: variable name (to describe its type). 379: 380: On outermost call, pass 0 for PASSED_A_PTR. 381: On outermost call, SHOW > 0 means should ignore 382: any typename for TYPE and show its details. 383: SHOW is always zero on recursive calls. */ 384: 385: static void 386: type_print_varspec_prefix (type, stream, show, passed_a_ptr) 387: struct type *type; 388: FILE *stream; 389: int show; 390: int passed_a_ptr; 391: { 1.1.1.6 ! root 392: if (type == 0) ! 393: return; ! 394: 1.1 root 395: if (TYPE_NAME (type) && show <= 0) 396: return; 397: 398: QUIT; 399: 400: switch (TYPE_CODE (type)) 401: { 402: case TYPE_CODE_PTR: 403: type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1); 404: fputc ('*', stream); 405: break; 406: 407: case TYPE_CODE_FUNC: 1.1.1.6 ! root 408: case TYPE_CODE_ARRAY: ! 409: type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 0); 1.1 root 410: if (passed_a_ptr) 411: fputc ('(', stream); 412: break; 413: } 414: } 415: 416: /* Print any array sizes, function arguments or close parentheses 417: needed after the variable name (to describe its type). 418: Args work like type_print_varspec_prefix. */ 419: 420: static void 421: type_print_varspec_suffix (type, stream, show, passed_a_ptr) 422: struct type *type; 423: FILE *stream; 424: int show; 425: int passed_a_ptr; 426: { 1.1.1.6 ! root 427: if (type == 0) ! 428: return; ! 429: 1.1 root 430: if (TYPE_NAME (type) && show <= 0) 431: return; 432: 433: QUIT; 434: 435: switch (TYPE_CODE (type)) 436: { 437: case TYPE_CODE_ARRAY: 1.1.1.6 ! root 438: type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0); ! 439: if (passed_a_ptr) ! 440: fprintf (stream, ")"); 1.1 root 441: fprintf (stream, "["); 442: if (TYPE_LENGTH (type) >= 0) 443: fprintf (stream, "%d", 444: TYPE_LENGTH (type) / TYPE_LENGTH (TYPE_TARGET_TYPE (type))); 445: fprintf (stream, "]"); 446: break; 447: 448: case TYPE_CODE_PTR: 449: type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 1); 450: break; 451: 452: case TYPE_CODE_FUNC: 1.1.1.6 ! root 453: type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0); 1.1 root 454: if (passed_a_ptr) 455: fprintf (stream, ")"); 456: fprintf (stream, "()"); 457: break; 458: } 459: } 460: 461: /* Print the name of the type (or the ultimate pointer target, 462: function value or array element), or the description of a 463: structure or union. 464: 465: SHOW nonzero means don't print this type as just its name; 466: show its real definition even if it has a name. 467: SHOW zero means print just typename or struct tag if there is one 468: SHOW negative means abbreviate structure elements. 469: SHOW is decremented for printing of structure elements. 470: 471: LEVEL is the depth to indent by. 472: We increase it for some recursive calls. */ 473: 474: static void 475: type_print_base (type, stream, show, level) 476: struct type *type; 477: FILE *stream; 478: int show; 479: int level; 480: { 481: char *name; 482: register int i; 483: register int len; 484: register int lastval; 485: 486: QUIT; 487: 1.1.1.6 ! root 488: if (type == 0) ! 489: { ! 490: fprintf (stream, "type unknown"); ! 491: return; ! 492: } ! 493: 1.1 root 494: if (TYPE_NAME (type) && show <= 0) 495: { 496: fprintf (stream, TYPE_NAME (type)); 497: return; 498: } 499: 500: switch (TYPE_CODE (type)) 501: { 502: case TYPE_CODE_ARRAY: 503: case TYPE_CODE_PTR: 504: case TYPE_CODE_FUNC: 505: type_print_base (TYPE_TARGET_TYPE (type), stream, show, level); 506: break; 507: 508: case TYPE_CODE_STRUCT: 509: fprintf (stream, "struct "); 510: goto struct_union; 511: 512: case TYPE_CODE_UNION: 513: fprintf (stream, "union "); 514: struct_union: 515: if (TYPE_NAME (type) && (name = TYPE_NAME (type))) 516: { 517: while (*name != ' ') name++; 518: fprintf (stream, "%s ", name + 1); 519: } 520: if (show < 0) 521: fprintf (stream, "{...}"); 522: else 523: { 524: fprintf (stream, "{"); 525: len = TYPE_NFIELDS (type); 1.1.1.6 ! root 526: fprintf (stream, "\n"); ! 527: for (i = 0; i < len; i++) 1.1 root 528: { 529: QUIT; 1.1.1.3 root 530: print_spaces (level + 4, stream); 1.1.1.6 ! root 531: ! 532: /* If this is a bit-field and there is a gap before it, ! 533: print a nameless field to account for the gap. */ ! 534: ! 535: if (TYPE_FIELD_PACKED (type, i)) 1.1.1.2 root 536: { 1.1.1.6 ! root 537: int gap = (TYPE_FIELD_BITPOS (type, i) ! 538: - (i > 0 ! 539: ? (TYPE_FIELD_BITPOS (type, i - 1) ! 540: + (TYPE_FIELD_PACKED (type, i - 1) ! 541: ? TYPE_FIELD_BITSIZE (type, i - 1) ! 542: : TYPE_LENGTH (TYPE_FIELD_TYPE (type, i - 1)) * 8)) ! 543: : 0)); ! 544: if (gap != 0) ! 545: { ! 546: fprintf (stream, "int : %d;\n", gap); ! 547: print_spaces (level + 4, stream); ! 548: } 1.1.1.2 root 549: } 1.1.1.6 ! root 550: ! 551: /* Print the declaration of this field. */ ! 552: 1.1 root 553: type_print_1 (TYPE_FIELD_TYPE (type, i), 554: TYPE_FIELD_NAME (type, i), 555: stream, show - 1, level + 4); 1.1.1.2 root 556: 1.1.1.6 ! root 557: /* Print the field width. */ 1.1.1.2 root 558: 1.1.1.6 ! root 559: if (TYPE_FIELD_PACKED (type, i)) ! 560: fprintf (stream, " : %d", TYPE_FIELD_BITSIZE (type, i)); 1.1.1.2 root 561: 1.1.1.6 ! root 562: fprintf (stream, ";\n"); 1.1 root 563: } 564: print_spaces (level, stream); 565: fputc ('}', stream); 566: } 567: break; 568: 569: case TYPE_CODE_ENUM: 570: fprintf (stream, "enum "); 571: if (TYPE_NAME (type)) 572: { 573: name = TYPE_NAME (type); 574: while (*name != ' ') name++; 575: fprintf (stream, "%s ", name + 1); 576: } 577: if (show < 0) 578: fprintf (stream, "{...}"); 579: else 580: { 581: fprintf (stream, "{"); 582: len = TYPE_NFIELDS (type); 583: lastval = 0; 584: for (i = 0; i < len; i++) 585: { 586: QUIT; 587: if (i) fprintf (stream, ", "); 588: fprintf (stream, "%s", TYPE_FIELD_NAME (type, i)); 589: if (lastval != TYPE_FIELD_VALUE (type, i)) 590: { 591: fprintf (stream, " : %d", TYPE_FIELD_VALUE (type, i)); 592: lastval = TYPE_FIELD_VALUE (type, i); 593: } 594: lastval++; 595: } 596: fprintf (stream, "}"); 597: } 598: break; 599: 600: case TYPE_CODE_INT: 601: if (TYPE_UNSIGNED (type)) 602: name = unsigned_type_table[TYPE_LENGTH (type)]; 603: else 604: name = signed_type_table[TYPE_LENGTH (type)]; 605: fprintf (stream, "%s", name); 606: break; 607: 608: case TYPE_CODE_FLT: 609: name = float_type_table[TYPE_LENGTH (type)]; 610: fprintf (stream, "%s", name); 611: break; 612: 613: case TYPE_CODE_VOID: 614: fprintf (stream, "void"); 615: break; 616: 617: case 0: 618: fprintf (stream, "struct unknown"); 619: break; 620: 621: default: 622: error ("Invalid type code in symbol table."); 623: } 624: } 625: 626: static void 627: set_maximum_command (arg) 628: char *arg; 629: { 630: if (!arg) error_no_arg ("value for maximum elements to print"); 631: print_max = atoi (arg); 632: } 633: 634: static 635: initialize () 636: { 637: add_com ("set-maximum", class_vars, set_maximum_command, 638: "Set NUMBER as limit on string chars or array elements to print."); 639: 640: print_max = 200; 641: 642: unsigned_type_table 643: = (char **) xmalloc ((1 + sizeof (unsigned long)) * sizeof (char *)); 644: bzero (unsigned_type_table, (1 + sizeof (unsigned long))); 645: unsigned_type_table[sizeof (unsigned char)] = "unsigned char"; 646: unsigned_type_table[sizeof (unsigned short)] = "unsigned short"; 647: unsigned_type_table[sizeof (unsigned long)] = "unsigned long"; 648: unsigned_type_table[sizeof (unsigned int)] = "unsigned int"; 649: 650: signed_type_table 651: = (char **) xmalloc ((1 + sizeof (long)) * sizeof (char *)); 652: bzero (signed_type_table, (1 + sizeof (long))); 653: signed_type_table[sizeof (char)] = "char"; 654: signed_type_table[sizeof (short)] = "short"; 655: signed_type_table[sizeof (long)] = "long"; 656: signed_type_table[sizeof (int)] = "int"; 657: 658: float_type_table 659: = (char **) xmalloc ((1 + sizeof (double)) * sizeof (char *)); 660: bzero (float_type_table, (1 + sizeof (double))); 661: float_type_table[sizeof (float)] = "float"; 662: float_type_table[sizeof (double)] = "double"; 663: } 664: 665: END_FILE
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.