![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to print-tree.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to print-tree.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Prints out tree in human readable form - GNU C-compiler 1.1.1.4 ! root 2: Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. 1.1 root 3: 4: This file is part of GNU CC. 5: 6: GNU CC is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU CC is distributed in the hope that it will be useful, 12: but WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14: GNU General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU CC; see the file COPYING. If not, write to 18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ 19: 20: 21: #include "config.h" 22: #include "tree.h" 23: #include <stdio.h> 24: 25: extern char **tree_code_name; 26: 27: extern char *mode_name[]; 28: 29: void print_node (); 30: void indent_to (); 31: 32: /* Define the hash table of nodes already seen. 33: Such nodes are not repeated; brief cross-references are used. */ 34: 35: #define HASH_SIZE 37 36: 37: struct bucket 38: { 39: tree node; 40: struct bucket *next; 41: }; 42: 43: static struct bucket **table; 44: 45: /* Print the node NODE on standard error, for debugging. 46: Most nodes referred to by this one are printed recursively 47: down to a depth of six. */ 48: 49: void 50: debug_tree (node) 51: tree node; 52: { 53: char *object = (char *) oballoc (0); 54: table = (struct bucket **) oballoc (HASH_SIZE * sizeof (struct bucket *)); 55: bzero (table, HASH_SIZE * sizeof (struct bucket *)); 56: print_node (stderr, "", node, 0); 57: table = 0; 58: obfree (object); 59: fprintf (stderr, "\n"); 60: } 61: 62: /* Print a node in brief fashion, with just the code, address and name. */ 63: 64: void 65: print_node_brief (file, prefix, node, indent) 66: FILE *file; 67: char *prefix; 68: tree node; 69: int indent; 70: { 71: char class; 72: 73: if (node == 0) 74: return; 75: 76: class = TREE_CODE_CLASS (TREE_CODE (node)); 77: 78: /* Always print the slot this node is in, and its code, address and 79: name if any. */ 80: if (indent > 0) 81: fprintf (file, " "); 1.1.1.3 root 82: fprintf (file, "%s <%s ", prefix, tree_code_name[(int) TREE_CODE (node)]); 1.1.1.4 ! root 83: fprintf (file, HOST_PTR_PRINTF, (HOST_WIDE_INT) node); 1.1 root 84: 85: if (class == 'd') 86: { 87: if (DECL_NAME (node)) 88: fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node))); 89: } 90: else if (class == 't') 91: { 92: if (TYPE_NAME (node)) 93: { 94: if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE) 95: fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node))); 96: else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL 97: && DECL_NAME (TYPE_NAME (node))) 98: fprintf (file, " %s", 99: IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)))); 100: } 101: } 102: if (TREE_CODE (node) == IDENTIFIER_NODE) 103: fprintf (file, " %s", IDENTIFIER_POINTER (node)); 104: /* We might as well always print the value of an integer. */ 105: if (TREE_CODE (node) == INTEGER_CST) 106: { 107: if (TREE_INT_CST_HIGH (node) == 0) 108: fprintf (file, " %1u", TREE_INT_CST_LOW (node)); 109: else if (TREE_INT_CST_HIGH (node) == -1 110: && TREE_INT_CST_LOW (node) != 0) 111: fprintf (file, " -%1u", -TREE_INT_CST_LOW (node)); 112: else 1.1.1.3 root 113: fprintf (file, 114: #if HOST_BITS_PER_WIDE_INT == 64 115: #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT 116: " 0x%lx%016lx", 117: #else 118: " 0x%x%016x", 119: #endif 120: #else 121: #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT 122: " 0x%lx%08lx", 123: #else 124: " 0x%x%08x", 125: #endif 126: #endif 127: TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node)); 1.1 root 128: } 129: if (TREE_CODE (node) == REAL_CST) 130: { 131: #ifndef REAL_IS_NOT_DOUBLE 132: fprintf (file, " %e", TREE_REAL_CST (node)); 133: #else 134: { 135: int i; 136: char *p = (char *) &TREE_REAL_CST (node); 137: fprintf (file, " 0x"); 138: for (i = 0; i < sizeof TREE_REAL_CST (node); i++) 139: fprintf (file, "%02x", *p++); 140: fprintf (file, ""); 141: } 142: #endif /* REAL_IS_NOT_DOUBLE */ 143: } 144: 145: fprintf (file, ">"); 146: } 147: 148: void 149: indent_to (file, column) 150: FILE *file; 151: int column; 152: { 153: int i; 154: 155: /* Since this is the long way, indent to desired column. */ 156: if (column > 0) 157: fprintf (file, "\n"); 158: for (i = 0; i < column; i++) 159: fprintf (file, " "); 160: } 161: 162: /* Print the node NODE in full on file FILE, preceded by PREFIX, 163: starting in column INDENT. */ 164: 165: void 166: print_node (file, prefix, node, indent) 167: FILE *file; 168: char *prefix; 169: tree node; 170: int indent; 171: { 172: int hash; 173: struct bucket *b; 174: enum machine_mode mode; 175: char class; 176: int len; 177: int first_rtl; 178: int i; 179: 180: if (node == 0) 181: return; 182: 183: class = TREE_CODE_CLASS (TREE_CODE (node)); 184: 185: /* Don't get too deep in nesting. If the user wants to see deeper, 186: it is easy to use the address of a lowest-level node 187: as an argument in another call to debug_tree. */ 188: 189: if (indent > 24) 190: { 191: print_node_brief (file, prefix, node, indent); 192: return; 193: } 194: 195: if (indent > 8 && (class == 't' || class == 'd')) 196: { 197: print_node_brief (file, prefix, node, indent); 198: return; 199: } 200: 201: /* It is unsafe to look at any other filds of an ERROR_MARK node. */ 202: if (TREE_CODE (node) == ERROR_MARK) 203: { 204: print_node_brief (file, prefix, node, indent); 205: return; 206: } 207: 1.1.1.3 root 208: hash = ((unsigned HOST_WIDE_INT) node) % HASH_SIZE; 1.1 root 209: 210: /* If node is in the table, just mention its address. */ 211: for (b = table[hash]; b; b = b->next) 212: if (b->node == node) 213: { 214: print_node_brief (file, prefix, node, indent); 215: return; 216: } 217: 218: /* Add this node to the table. */ 219: b = (struct bucket *) oballoc (sizeof (struct bucket)); 220: b->node = node; 221: b->next = table[hash]; 222: table[hash] = b; 223: 224: /* Indent to the specified column, since this is the long form. */ 225: indent_to (file, indent); 226: 227: /* Print the slot this node is in, and its code, and address. */ 1.1.1.3 root 228: fprintf (file, "%s <%s ", prefix, tree_code_name[(int) TREE_CODE (node)]); 1.1.1.4 ! root 229: fprintf (file, HOST_PTR_PRINTF, (HOST_WIDE_INT) node); 1.1 root 230: 231: /* Print the name, if any. */ 232: if (class == 'd') 233: { 234: if (DECL_NAME (node)) 235: fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node))); 236: } 237: else if (class == 't') 238: { 239: if (TYPE_NAME (node)) 240: { 241: if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE) 242: fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node))); 243: else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL 244: && DECL_NAME (TYPE_NAME (node))) 245: fprintf (file, " %s", 246: IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)))); 247: } 248: } 249: if (TREE_CODE (node) == IDENTIFIER_NODE) 250: fprintf (file, " %s", IDENTIFIER_POINTER (node)); 251: 252: if (TREE_CODE (node) == INTEGER_CST) 253: { 254: if (indent <= 4) 255: print_node_brief (file, "type", TREE_TYPE (node), indent + 4); 256: } 257: else 258: { 259: print_node (file, "type", TREE_TYPE (node), indent + 4); 260: if (TREE_TYPE (node)) 261: indent_to (file, indent + 3); 262: } 263: 264: /* If a permanent object is in the wrong obstack, or the reverse, warn. */ 265: if (object_permanent_p (node) != TREE_PERMANENT (node)) 266: { 267: if (TREE_PERMANENT (node)) 268: fputs (" !!permanent object in non-permanent obstack!!", file); 269: else 270: fputs (" !!non-permanent object in permanent obstack!!", file); 271: indent_to (file, indent + 3); 272: } 273: 274: if (TREE_SIDE_EFFECTS (node)) 275: fputs (" side-effects", file); 276: if (TREE_READONLY (node)) 277: fputs (" readonly", file); 278: if (TREE_CONSTANT (node)) 279: fputs (" constant", file); 280: if (TREE_ADDRESSABLE (node)) 281: fputs (" addressable", file); 282: if (TREE_THIS_VOLATILE (node)) 283: fputs (" volatile", file); 284: if (TREE_UNSIGNED (node)) 285: fputs (" unsigned", file); 286: if (TREE_ASM_WRITTEN (node)) 287: fputs (" asm_written", file); 288: if (TREE_USED (node)) 289: fputs (" used", file); 1.1.1.3 root 290: if (TREE_RAISES (node)) 291: fputs (" raises", file); 1.1 root 292: if (TREE_PERMANENT (node)) 293: fputs (" permanent", file); 294: if (TREE_PUBLIC (node)) 295: fputs (" public", file); 296: if (TREE_STATIC (node)) 297: fputs (" static", file); 298: if (TREE_LANG_FLAG_0 (node)) 299: fputs (" tree_0", file); 300: if (TREE_LANG_FLAG_1 (node)) 301: fputs (" tree_1", file); 302: if (TREE_LANG_FLAG_2 (node)) 303: fputs (" tree_2", file); 304: if (TREE_LANG_FLAG_3 (node)) 305: fputs (" tree_3", file); 306: if (TREE_LANG_FLAG_4 (node)) 307: fputs (" tree_4", file); 308: if (TREE_LANG_FLAG_5 (node)) 309: fputs (" tree_5", file); 310: if (TREE_LANG_FLAG_6 (node)) 311: fputs (" tree_6", file); 312: 313: /* DECL_ nodes have additional attributes. */ 314: 315: switch (TREE_CODE_CLASS (TREE_CODE (node))) 316: { 317: case 'd': 318: mode = DECL_MODE (node); 319: 1.1.1.3 root 320: if (DECL_EXTERNAL (node)) 1.1 root 321: fputs (" external", file); 1.1.1.3 root 322: if (DECL_NONLOCAL (node)) 1.1 root 323: fputs (" nonlocal", file); 1.1.1.3 root 324: if (DECL_REGISTER (node)) 1.1 root 325: fputs (" regdecl", file); 1.1.1.3 root 326: if (DECL_INLINE (node)) 1.1 root 327: fputs (" inline", file); 328: if (DECL_BIT_FIELD (node)) 329: fputs (" bit-field", file); 330: if (DECL_VIRTUAL_P (node)) 331: fputs (" virtual", file); 332: if (DECL_IGNORED_P (node)) 333: fputs (" ignored", file); 1.1.1.3 root 334: if (DECL_IN_SYSTEM_HEADER (node)) 335: fputs (" in_system_header", file); 1.1 root 336: if (DECL_LANG_FLAG_0 (node)) 337: fputs (" decl_0", file); 338: if (DECL_LANG_FLAG_1 (node)) 339: fputs (" decl_1", file); 340: if (DECL_LANG_FLAG_2 (node)) 341: fputs (" decl_2", file); 342: if (DECL_LANG_FLAG_3 (node)) 343: fputs (" decl_3", file); 344: if (DECL_LANG_FLAG_4 (node)) 345: fputs (" decl_4", file); 346: if (DECL_LANG_FLAG_5 (node)) 347: fputs (" decl_5", file); 348: if (DECL_LANG_FLAG_6 (node)) 349: fputs (" decl_6", file); 350: if (DECL_LANG_FLAG_7 (node)) 351: fputs (" decl_7", file); 352: 353: fprintf (file, " %s", mode_name[(int) mode]); 354: 355: fprintf (file, " file %s line %d", 356: DECL_SOURCE_FILE (node), DECL_SOURCE_LINE (node)); 357: 358: print_node (file, "size", DECL_SIZE (node), indent + 4); 359: indent_to (file, indent + 3); 1.1.1.2 root 360: if (TREE_CODE (node) != FUNCTION_DECL) 361: fprintf (file, " align %d", DECL_ALIGN (node)); 1.1.1.3 root 362: else if (DECL_INLINE (node)) 1.1.1.2 root 363: fprintf (file, " frame_size %d", DECL_FRAME_SIZE (node)); 364: else if (DECL_BUILT_IN (node)) 365: fprintf (file, " built-in code %d", DECL_FUNCTION_CODE (node)); 1.1 root 366: if (TREE_CODE (node) == FIELD_DECL) 367: print_node (file, "bitpos", DECL_FIELD_BITPOS (node), indent + 4); 368: print_node_brief (file, "context", DECL_CONTEXT (node), indent + 4); 1.1.1.3 root 369: print_node_brief (file, "abstract_origin", 370: DECL_ABSTRACT_ORIGIN (node), indent + 4); 1.1 root 371: 372: print_node (file, "arguments", DECL_ARGUMENTS (node), indent + 4); 373: print_node (file, "result", DECL_RESULT (node), indent + 4); 374: print_node_brief (file, "initial", DECL_INITIAL (node), indent + 4); 375: 376: print_lang_decl (file, node, indent); 377: 378: if (DECL_RTL (node) != 0) 379: { 380: indent_to (file, indent + 4); 381: print_rtl (file, DECL_RTL (node)); 382: } 383: 384: if (DECL_SAVED_INSNS (node) != 0) 385: { 386: indent_to (file, indent + 4); 387: if (TREE_CODE (node) == PARM_DECL) 388: { 389: fprintf (file, "incoming-rtl "); 390: print_rtl (file, DECL_INCOMING_RTL (node)); 391: } 392: else if (TREE_CODE (node) == FUNCTION_DECL) 1.1.1.3 root 393: { 394: fprintf (file, "saved-insns "); 1.1.1.4 ! root 395: fprintf (file, HOST_PTR_PRINTF, ! 396: (HOST_WIDE_INT) DECL_SAVED_INSNS (node)); 1.1.1.3 root 397: } 1.1 root 398: } 399: 400: /* Print the decl chain only if decl is at second level. */ 401: if (indent == 4) 402: print_node (file, "chain", TREE_CHAIN (node), indent + 4); 403: else 404: print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4); 405: break; 406: 407: case 't': 408: if (TYPE_NO_FORCE_BLK (node)) 409: fputs (" no_force_blk", file); 410: if (TYPE_LANG_FLAG_0 (node)) 411: fputs (" type_0", file); 412: if (TYPE_LANG_FLAG_1 (node)) 413: fputs (" type_1", file); 414: if (TYPE_LANG_FLAG_2 (node)) 415: fputs (" type_2", file); 416: if (TYPE_LANG_FLAG_3 (node)) 417: fputs (" type_3", file); 418: if (TYPE_LANG_FLAG_4 (node)) 419: fputs (" type_4", file); 420: if (TYPE_LANG_FLAG_5 (node)) 421: fputs (" type_5", file); 422: if (TYPE_LANG_FLAG_6 (node)) 423: fputs (" type_6", file); 424: 425: mode = TYPE_MODE (node); 426: fprintf (file, " %s", mode_name[(int) mode]); 427: 428: print_node (file, "size", TYPE_SIZE (node), indent + 4); 429: indent_to (file, indent + 3); 430: 431: fprintf (file, " align %d", TYPE_ALIGN (node)); 432: fprintf (file, " symtab %d", TYPE_SYMTAB_ADDRESS (node)); 433: 434: if (TREE_CODE (node) == ARRAY_TYPE || TREE_CODE (node) == SET_TYPE) 435: print_node (file, "domain", TYPE_DOMAIN (node), indent + 4); 1.1.1.3 root 436: else if (TREE_CODE (node) == INTEGER_TYPE 437: || TREE_CODE (node) == BOOLEAN_TYPE 438: || TREE_CODE (node) == CHAR_TYPE) 1.1 root 439: { 440: fprintf (file, " precision %d", TYPE_PRECISION (node)); 441: print_node (file, "min", TYPE_MIN_VALUE (node), indent + 4); 442: print_node (file, "max", TYPE_MAX_VALUE (node), indent + 4); 443: } 444: else if (TREE_CODE (node) == ENUMERAL_TYPE) 445: { 446: fprintf (file, " precision %d", TYPE_PRECISION (node)); 447: print_node (file, "min", TYPE_MIN_VALUE (node), indent + 4); 448: print_node (file, "max", TYPE_MAX_VALUE (node), indent + 4); 449: print_node (file, "values", TYPE_VALUES (node), indent + 4); 450: } 451: else if (TREE_CODE (node) == REAL_TYPE) 452: fprintf (file, " precision %d", TYPE_PRECISION (node)); 1.1.1.4 ! root 453: else if (TREE_CODE (node) == RECORD_TYPE ! 454: || TREE_CODE (node) == UNION_TYPE ! 455: || TREE_CODE (node) == QUAL_UNION_TYPE) 1.1 root 456: print_node (file, "fields", TYPE_FIELDS (node), indent + 4); 457: else if (TREE_CODE (node) == FUNCTION_TYPE || TREE_CODE (node) == METHOD_TYPE) 458: { 459: if (TYPE_METHOD_BASETYPE (node)) 460: print_node_brief (file, "method basetype", TYPE_METHOD_BASETYPE (node), indent + 4); 461: print_node (file, "arg-types", TYPE_ARG_TYPES (node), indent + 4); 462: } 463: if (TYPE_CONTEXT (node)) 464: print_node_brief (file, "context", TYPE_CONTEXT (node), indent + 4); 465: 466: print_lang_type (file, node, indent); 467: 468: if (TYPE_POINTER_TO (node) || TREE_CHAIN (node)) 469: indent_to (file, indent + 3); 470: print_node_brief (file, "pointer_to_this", TYPE_POINTER_TO (node), indent + 4); 471: print_node_brief (file, "reference_to_this", TYPE_REFERENCE_TO (node), indent + 4); 472: print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4); 473: break; 474: 1.1.1.3 root 475: case 'b': 476: print_node (file, "vars", BLOCK_VARS (node), indent + 4); 477: print_node (file, "tags", BLOCK_TYPE_TAGS (node), indent + 4); 478: print_node (file, "supercontext", BLOCK_SUPERCONTEXT (node), indent + 4); 479: print_node (file, "subblocks", BLOCK_SUBBLOCKS (node), indent + 4); 480: print_node (file, "chain", BLOCK_CHAIN (node), indent + 4); 481: print_node (file, "abstract_origin", 482: BLOCK_ABSTRACT_ORIGIN (node), indent + 4); 483: return; 484: 1.1 root 485: case 'e': 486: case '<': 487: case '1': 488: case '2': 489: case 'r': 490: case 's': 491: switch (TREE_CODE (node)) 492: { 493: case BIND_EXPR: 494: print_node (file, "vars", TREE_OPERAND (node, 0), indent + 4); 495: print_node (file, "body", TREE_OPERAND (node, 1), indent + 4); 1.1.1.2 root 496: print_node (file, "block", TREE_OPERAND (node, 2), indent + 4); 1.1 root 497: return; 498: } 499: 500: first_rtl = len = tree_code_length[(int) TREE_CODE (node)]; 501: /* These kinds of nodes contain rtx's, not trees, 502: after a certain point. Print the rtx's as rtx's. */ 503: switch (TREE_CODE (node)) 504: { 505: case SAVE_EXPR: 506: first_rtl = 2; 507: break; 508: case CALL_EXPR: 509: first_rtl = 2; 510: break; 511: case METHOD_CALL_EXPR: 512: first_rtl = 3; 513: break; 514: case WITH_CLEANUP_EXPR: 515: /* Should be defined to be 2. */ 516: first_rtl = 1; 517: break; 518: case RTL_EXPR: 519: first_rtl = 0; 520: } 521: for (i = 0; i < len; i++) 522: { 523: if (i >= first_rtl) 524: { 525: indent_to (file, indent + 4); 526: fprintf (file, "rtl %d ", i); 527: if (TREE_OPERAND (node, i)) 1.1.1.4 ! root 528: print_rtl (file, (struct rtx_def *) TREE_OPERAND (node, i)); 1.1 root 529: else 530: fprintf (file, "(nil)"); 531: fprintf (file, "\n"); 532: } 533: else 534: { 535: char temp[10]; 536: 537: sprintf (temp, "arg %d", i); 538: print_node (file, temp, TREE_OPERAND (node, i), indent + 4); 539: } 540: } 541: break; 542: 543: case 'c': 544: case 'x': 545: switch (TREE_CODE (node)) 546: { 547: case INTEGER_CST: 548: if (TREE_INT_CST_HIGH (node) == 0) 549: fprintf (file, " %1u", TREE_INT_CST_LOW (node)); 550: else if (TREE_INT_CST_HIGH (node) == -1 551: && TREE_INT_CST_LOW (node) != 0) 552: fprintf (file, " -%1u", -TREE_INT_CST_LOW (node)); 553: else 1.1.1.3 root 554: fprintf (file, 555: #if HOST_BITS_PER_WIDE_INT == 64 556: #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT 557: " 0x%lx%016lx", 558: #else 559: " 0x%x%016x", 560: #endif 561: #else 562: #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT 563: " 0x%lx%08lx", 564: #else 565: " 0x%x%08x", 566: #endif 567: #endif 568: TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node)); 1.1 root 569: break; 570: 571: case REAL_CST: 572: #ifndef REAL_IS_NOT_DOUBLE 573: fprintf (file, " %e", TREE_REAL_CST (node)); 574: #else 575: { 576: char *p = (char *) &TREE_REAL_CST (node); 577: fprintf (file, " 0x"); 578: for (i = 0; i < sizeof TREE_REAL_CST (node); i++) 579: fprintf (file, "%02x", *p++); 580: fprintf (file, ""); 581: } 582: #endif /* REAL_IS_NOT_DOUBLE */ 583: break; 584: 585: case COMPLEX_CST: 586: print_node (file, "real", TREE_REALPART (node), indent + 4); 587: print_node (file, "imag", TREE_IMAGPART (node), indent + 4); 588: break; 589: 590: case STRING_CST: 591: fprintf (file, " \"%s\"", TREE_STRING_POINTER (node)); 1.1.1.4 ! root 592: /* Print the chain at second level. */ ! 593: if (indent == 4) ! 594: print_node (file, "chain", TREE_CHAIN (node), indent + 4); ! 595: else ! 596: print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4); 1.1 root 597: break; 598: 599: case IDENTIFIER_NODE: 600: print_lang_identifier (file, node, indent); 601: break; 602: 603: case TREE_LIST: 604: print_node (file, "purpose", TREE_PURPOSE (node), indent + 4); 605: print_node (file, "value", TREE_VALUE (node), indent + 4); 606: print_node (file, "chain", TREE_CHAIN (node), indent + 4); 607: break; 608: 609: case TREE_VEC: 610: len = TREE_VEC_LENGTH (node); 611: for (i = 0; i < len; i++) 1.1.1.3 root 612: if (TREE_VEC_ELT (node, i)) 613: { 614: char temp[10]; 615: sprintf (temp, "elt %d", i); 616: indent_to (file, indent + 4); 617: print_node_brief (file, temp, TREE_VEC_ELT (node, i), 0); 618: } 1.1 root 619: break; 620: 621: case OP_IDENTIFIER: 622: print_node (file, "op1", TREE_PURPOSE (node), indent + 4); 623: print_node (file, "op2", TREE_VALUE (node), indent + 4); 624: } 625: 626: break; 627: } 1.1.1.3 root 628: 629: fprintf (file, ">"); 1.1 root 630: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.