src/runtime/print.c

   1 /* code for low-level debugging/diagnostic output */
   2
   3 /*
   4  * This software is part of the SBCL system. See the README file for
   5  * more information.
   6  *
   7  * This software is derived from the CMU CL system, which was
   8  * written at Carnegie Mellon University and released into the
   9  * public domain. The software is in the public domain and is
  10  * provided with absolutely no warranty. See the COPYING and CREDITS
  11  * files for more information.
  12  */
  13
  14 /*
  15  * FIXME:
  16  *   Some of the code in here (the various
  17  *   foo_slots[], at least) is deeply broken, depending on guessing
  18  *   already out-of-date values instead of getting them from sbcl.h.
  19  */
  20
  21 #include <stdio.h>
  22
  23 #include "sbcl.h"
  24 #include "print.h"
  25 #include "runtime.h"
  26
  27 /* This file can be skipped if we're not supporting LDB. */
  28 #if defined(LISP_FEATURE_SB_LDB)
  29
  30 #include "monitor.h"
  31 #include "vars.h"
  32 #include "os.h"
  33 #include "gencgc-alloc-region.h" /* genesis/thread.h needs this */
  34 #include "genesis/static-symbols.h"
  35 #include "genesis/primitive-objects.h"
  36
  37 #include "genesis/static-symbols.h"
  38
  39
  40
  41 static int max_lines = 20, cur_lines = 0;
  42 static int max_depth = 5, brief_depth = 2, cur_depth = 0;
  43 static int max_length = 5;
  44 static boolean dont_descend = 0, skip_newline = 0;
  45 static int cur_clock = 0;
  46
  47 static void print_obj(char *prefix, lispobj obj);
  48
  49 #define NEWLINE_OR_RETURN if (continue_p(1)) newline(NULL); else return;
  50
  51 char *lowtag_Names[] = {
  52     "even fixnum",
  53     "instance pointer",
  54     "other immediate [0]",
  55     "list pointer",
  56     "odd fixnum",
  57     "function pointer",
  58     "other immediate [1]",
  59     "other pointer"
  60 };
  61
  62 /* FIXME: Yikes! This table implicitly depends on the values in sbcl.h,
  63  * but doesn't actually depend on them, so if they change, it gets
  64  * all broken. We should either get rid of it or
  65  * rewrite the code so that it's cleanly initialized by gc_init_tables[]
  66  * in a way which varies correctly with the values in sbcl.h. */
  67 char *subtype_Names[] = {
  68     "unused 0",
  69     "unused 1",
  70     "bignum",
  71     "ratio",
  72     "single float",
  73     "double float",
  74 #ifdef LONG_FLOAT_WIDETAG
  75     "long float",
  76 #endif
  77     "complex",
  78 #ifdef COMPLEX_SINGLE_FLOAT_WIDETAG
  79     "complex single float",
  80 #endif
  81 #ifdef COMPLEX_DOUBLE_FLOAT_WIDETAG
  82     "complex double float",
  83 #endif
  84 #ifdef COMPLEX_LONG_FLOAT_WIDETAG
  85     "complex long float",
  86 #endif
  87     "simple-array",
  88     "simple-string",
  89     "simple-bit-vector",
  90     "simple-vector",
  91     "(simple-array (unsigned-byte 2) (*))",
  92     "(simple-array (unsigned-byte 4) (*))",
  93     "(simple-array (unsigned-byte 8) (*))",
  94     "(simple-array (unsigned-byte 16) (*))",
  95     "(simple-array (unsigned-byte 32) (*))",
  96 #ifdef SIMPLE_ARRAY_SIGNED_BYTE_8_WIDETAG
  97     "(simple-array (signed-byte 8) (*))",
  98 #endif
  99 #ifdef SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG
 100     "(simple-array (signed-byte 16) (*))",
 101 #endif
 102 #ifdef SIMPLE_ARRAY_SIGNED_BYTE_30_WIDETAG
 103     "(simple-array fixnum (*))",
 104 #endif
 105 #ifdef SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG
 106     "(simple-array (signed-byte 32) (*))",
 107 #endif
 108     "(simple-array single-float (*))",
 109     "(simple-array double-float (*))",
 110 #ifdef SIMPLE_ARRAY_LONG_FLOAT_WIDETAG
 111     "(simple-array long-float (*))",
 112 #endif
 113 #ifdef SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG
 114     "(simple-array (complex single-float) (*))",
 115 #endif
 116 #ifdef SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG
 117     "(simple-array (complex double-float) (*))",
 118 #endif
 119 #ifdef SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG
 120     "(simple-array (complex long-float) (*))",
 121 #endif
 122     "complex-string",
 123     "complex-bit-vector",
 124     "(array * (*))",
 125     "array",
 126     "code header",
 127     "function header",
 128     "closure header",
 129     "funcallable-instance header",
 130     "unused function header 1",
 131     "unused function header 2",
 132     "unused function header 3",
 133     "closure function header",
 134     "return PC header",
 135     "value cell header",
 136     "symbol header",
 137     "character",
 138     "SAP",
 139     "unbound marker",
 140     "weak pointer",
 141     "instance header",
 142     "fdefn"
 143 };
 144
 145 static void indent(int in)
 146 {
 147     static char *spaces = "                                                                ";
 148
 149     while (in > 64) {
 150         fputs(spaces, stdout);
 151         in -= 64;
 152     }
 153     if (in != 0)
 154         fputs(spaces + 64 - in, stdout);
 155 }
 156
 157 static boolean continue_p(boolean newline)
 158 {
 159     char buffer[256];
 160
 161     if (cur_depth >= max_depth || dont_descend)
 162         return 0;
 163
 164     if (newline) {
 165         if (skip_newline)
 166             skip_newline = 0;
 167         else
 168             putchar('\n');
 169
 170         if (cur_lines >= max_lines) {
 171             printf("More? [y] ");
 172             fflush(stdout);
 173
 174             fgets(buffer, sizeof(buffer), stdin);
 175
 176             if (buffer[0] == 'n' || buffer[0] == 'N')
 177                 throw_to_monitor();
 178             else
 179                 cur_lines = 0;
 180         }
 181     }
 182
 183     return 1;
 184 }
 185
 186 static void newline(char *label)
 187 {
 188     cur_lines++;
 189     if (label != NULL)
 190         fputs(label, stdout);
 191     putchar('\t');
 192     indent(cur_depth * 2);
 193 }
 194
 195
 196 static void brief_fixnum(lispobj obj)
 197 {
 198 #ifndef alpha
 199     printf("%ld", ((long)obj)>>2);
 200 #else
 201     printf("%d", ((s32)obj)>>2);
 202 #endif
 203 }
 204
 205 static void print_fixnum(lispobj obj)
 206 {
 207 #ifndef alpha
 208     printf(": %ld", ((long)obj)>>2);
 209 #else
 210     printf(": %d", ((s32)obj)>>2);
 211 #endif
 212 }
 213
 214 static void brief_otherimm(lispobj obj)
 215 {
 216     int type, c, idx;
 217     char buffer[10];
 218
 219     type = widetag_of(obj);
 220     switch (type) {
 221         case CHARACTER_WIDETAG:
 222             c = (obj>>8)&0xff;
 223             switch (c) {
 224                 case '\0':
 225                     printf("#\\Null");
 226                     break;
 227                 case '\n':
 228                     printf("#\\Newline");
 229                     break;
 230                 case '\b':
 231                     printf("#\\Backspace");
 232                     break;
 233                 case '\177':
 234                     printf("#\\Delete");
 235                     break;
 236                 default:
 237                     strcpy(buffer, "#\\");
 238                     if (c >= 128) {
 239                         strcat(buffer, "m-");
 240                         c -= 128;
 241                     }
 242                     if (c < 32) {
 243                         strcat(buffer, "c-");
 244                         c += '@';
 245                     }
 246                     printf("%s%c", buffer, c);
 247                     break;
 248             }
 249             break;
 250
 251         case UNBOUND_MARKER_WIDETAG:
 252             printf("<unbound marker>");
 253             break;
 254
 255         default:
 256             idx = type >> 2;
 257             if (idx < (sizeof(lowtag_Names) / sizeof(char *)))
 258                     printf("%s", lowtag_Names[idx]);
 259             else
 260                     printf("unknown type (0x%0x)", type);
 261             break;
 262     }
 263 }
 264
 265 static void print_otherimm(lispobj obj)
 266 {
 267     int type, idx;
 268
 269     type = widetag_of(obj);
 270     idx = type >> 2;
 271
 272     if (idx < (sizeof(lowtag_Names) / sizeof(char *)))
 273             printf(", %s", lowtag_Names[idx]);
 274     else
 275             printf(", unknown type (0x%0x)", type);
 276
 277     switch (widetag_of(obj)) {
 278         case CHARACTER_WIDETAG:
 279             printf(": ");
 280             brief_otherimm(obj);
 281             break;
 282
 283         case SAP_WIDETAG:
 284         case UNBOUND_MARKER_WIDETAG:
 285             break;
 286
 287         default:
 288             printf(": data=%ld", (long) (obj>>8)&0xffffff);
 289             break;
 290     }
 291 }
 292
 293 static void brief_list(lispobj obj)
 294 {
 295     int space = 0;
 296     int length = 0;
 297
 298     if (!is_valid_lisp_addr((os_vm_address_t)native_pointer(obj)))
 299         printf("(invalid Lisp-level address)");
 300     else if (obj == NIL)
 301         printf("NIL");
 302     else {
 303         putchar('(');
 304         while (lowtag_of(obj) == LIST_POINTER_LOWTAG) {
 305             struct cons *cons = (struct cons *)native_pointer(obj);
 306
 307             if (space)
 308                 putchar(' ');
 309             if (++length >= max_length) {
 310                 printf("...");
 311                 obj = NIL;
 312                 break;
 313             }
 314             print_obj(NULL, cons->car);
 315             obj = cons->cdr;
 316             space = 1;
 317             if (obj == NIL)
 318                 break;
 319         }
 320         if (obj != NIL) {
 321             printf(" . ");
 322             print_obj(NULL, obj);
 323         }
 324         putchar(')');
 325     }
 326 }
 327
 328 static void print_list(lispobj obj)
 329 {
 330     if (!is_valid_lisp_addr((os_vm_address_t)native_pointer(obj))) {
 331         printf("(invalid address)");
 332     } else if (obj == NIL) {
 333         printf(" (NIL)");
 334     } else {
 335         struct cons *cons = (struct cons *)native_pointer(obj);
 336
 337         print_obj("car: ", cons->car);
 338         print_obj("cdr: ", cons->cdr);
 339     }
 340 }
 341
 342 static void brief_struct(lispobj obj)
 343 {
 344     printf("#<ptr to 0x%08lx instance>",
 345            (unsigned long) ((struct instance *)native_pointer(obj))->slots[0]);
 346 }
 347
 348 static void print_struct(lispobj obj)
 349 {
 350     struct instance *instance = (struct instance *)native_pointer(obj);
 351     int i;
 352     char buffer[16];
 353     print_obj("type: ", ((struct instance *)native_pointer(obj))->slots[0]);
 354     for (i = 1; i < HeaderValue(instance->header); i++) {
 355         sprintf(buffer, "slot %d: ", i);
 356         print_obj(buffer, instance->slots[i]);
 357     }
 358 }
 359
 360 static void brief_otherptr(lispobj obj)
 361 {
 362     lispobj *ptr, header;
 363     int type;
 364     struct symbol *symbol;
 365     struct vector *vector;
 366     char *charptr;
 367
 368     ptr = (lispobj *) native_pointer(obj);
 369
 370     if (!is_valid_lisp_addr((os_vm_address_t)obj)) {
 371             printf("(invalid address)");
 372             return;
 373     }
 374
 375     header = *ptr;
 376     type = widetag_of(header);
 377     switch (type) {
 378         case SYMBOL_HEADER_WIDETAG:
 379             symbol = (struct symbol *)ptr;
 380             vector = (struct vector *)native_pointer(symbol->name);
 381             for (charptr = (char *)vector->data; *charptr != '\0'; charptr++) {
 382                 if (*charptr == '"')
 383                     putchar('\\');
 384                 putchar(*charptr);
 385             }
 386             break;
 387
 388         case SIMPLE_BASE_STRING_WIDETAG:
 389             vector = (struct vector *)ptr;
 390             putchar('"');
 391             for (charptr = (char *)vector->data; *charptr != '\0'; charptr++) {
 392                 if (*charptr == '"')
 393                     putchar('\\');
 394                 putchar(*charptr);
 395             }
 396             putchar('"');
 397             break;
 398
 399         default:
 400             printf("#<ptr to ");
 401             brief_otherimm(header);
 402             putchar('>');
 403     }
 404 }
 405
 406 static void print_slots(char **slots, int count, lispobj *ptr)
 407 {
 408     while (count-- > 0) {
 409         if (*slots) {
 410             print_obj(*slots++, *ptr++);
 411         } else {
 412             print_obj("???: ", *ptr++);
 413         }
 414     }
 415 }
 416
 417 /* FIXME: Yikes again! This, like subtype_Names[], needs to depend
 418  * on the values in sbcl.h (or perhaps be generated automatically
 419  * by GENESIS as part of sbcl.h). */
 420 static char *symbol_slots[] = {"value: ", "unused: ",
 421     "plist: ", "name: ", "package: ",
 422 #ifdef LISP_FEATURE_SB_THREAD
 423     "tls-index: " ,
 424 #endif
 425     NULL};
 426 static char *ratio_slots[] = {"numer: ", "denom: ", NULL};
 427 static char *complex_slots[] = {"real: ", "imag: ", NULL};
 428 static char *code_slots[] = {"words: ", "entry: ", "debug: ", NULL};
 429 static char *fn_slots[] = {
 430     "self: ", "next: ", "name: ", "arglist: ", "type: ", NULL};
 431 static char *closure_slots[] = {"fn: ", NULL};
 432 static char *funcallable_instance_slots[] = {"fn: ", "lexenv: ", "layout: ", NULL};
 433 static char *weak_pointer_slots[] = {"value: ", NULL};
 434 static char *fdefn_slots[] = {"name: ", "function: ", "raw_addr: ", NULL};
 435 static char *value_cell_slots[] = {"value: ", NULL};
 436
 437 static void print_otherptr(lispobj obj)
 438 {
 439     if (!is_valid_lisp_addr((os_vm_address_t)obj)) {
 440         printf("(invalid address)");
 441     } else {
 442 #ifndef alpha
 443         lispobj *ptr;
 444         unsigned long header;
 445         unsigned long length;
 446 #else
 447         u32 *ptr;
 448         u32 header;
 449         u32 length;
 450 #endif
 451         int count, type, index;
 452         char *cptr, buffer[16];
 453
 454         ptr = (lispobj*) native_pointer(obj);
 455         if (ptr == NULL) {
 456                 printf(" (NULL Pointer)");
 457                 return;
 458         }
 459
 460         header = *ptr++;
 461         length = (*ptr) >> 2;
 462         count = header>>8;
 463         type = widetag_of(header);
 464
 465         print_obj("header: ", header);
 466         if (lowtag_of(header) != OTHER_IMMEDIATE_0_LOWTAG &&
 467             lowtag_of(header) != OTHER_IMMEDIATE_1_LOWTAG) {
 468             NEWLINE_OR_RETURN;
 469             printf("(invalid header object)");
 470             return;
 471         }
 472
 473         switch (type) {
 474             case BIGNUM_WIDETAG:
 475                 ptr += count;
 476                 NEWLINE_OR_RETURN;
 477                 printf("0x");
 478                 while (count-- > 0)
 479                     printf("%08lx", (unsigned long) *--ptr);
 480                 break;
 481
 482             case RATIO_WIDETAG:
 483                 print_slots(ratio_slots, count, ptr);
 484                 break;
 485
 486             case COMPLEX_WIDETAG:
 487                 print_slots(complex_slots, count, ptr);
 488                 break;
 489
 490             case SYMBOL_HEADER_WIDETAG:
 491                 print_slots(symbol_slots, count, ptr);
 492                 break;
 493
 494             case SINGLE_FLOAT_WIDETAG:
 495                 NEWLINE_OR_RETURN;
 496                 printf("%g", ((struct single_float *)native_pointer(obj))->value);
 497                 break;
 498
 499             case DOUBLE_FLOAT_WIDETAG:
 500                 NEWLINE_OR_RETURN;
 501                 printf("%g", ((struct double_float *)native_pointer(obj))->value);
 502                 break;
 503
 504 #ifdef LONG_FLOAT_WIDETAG
 505             case LONG_FLOAT_WIDETAG:
 506                 NEWLINE_OR_RETURN;
 507                 printf("%Lg", ((struct long_float *)native_pointer(obj))->value);
 508                 break;
 509 #endif
 510
 511 #ifdef COMPLEX_SINGLE_FLOAT_WIDETAG
 512             case COMPLEX_SINGLE_FLOAT_WIDETAG:
 513                 NEWLINE_OR_RETURN;
 514                 printf("%g", ((struct complex_single_float *)native_pointer(obj))->real);
 515                 NEWLINE_OR_RETURN;
 516                 printf("%g", ((struct complex_single_float *)native_pointer(obj))->imag);
 517                 break;
 518 #endif
 519
 520 #ifdef COMPLEX_DOUBLE_FLOAT_WIDETAG
 521             case COMPLEX_DOUBLE_FLOAT_WIDETAG:
 522                 NEWLINE_OR_RETURN;
 523                 printf("%g", ((struct complex_double_float *)native_pointer(obj))->real);
 524                 NEWLINE_OR_RETURN;
 525                 printf("%g", ((struct complex_double_float *)native_pointer(obj))->imag);
 526                 break;
 527 #endif
 528
 529 #ifdef COMPLEX_LONG_FLOAT_WIDETAG
 530             case COMPLEX_LONG_FLOAT_WIDETAG:
 531                 NEWLINE_OR_RETURN;
 532                 printf("%Lg", ((struct complex_long_float *)native_pointer(obj))->real);
 533                 NEWLINE_OR_RETURN;
 534                 printf("%Lg", ((struct complex_long_float *)native_pointer(obj))->imag);
 535                 break;
 536 #endif
 537
 538             case SIMPLE_BASE_STRING_WIDETAG:
 539 #ifdef SIMPLE_CHARACTER_STRING_WIDETAG
 540         case SIMPLE_CHARACTER_STRING_WIDETAG: /* FIXME */
 541 #endif
 542                 NEWLINE_OR_RETURN;
 543                 cptr = (char *)(ptr+1);
 544                 putchar('"');
 545                 while (length-- > 0)
 546                     putchar(*cptr++);
 547                 putchar('"');
 548                 break;
 549
 550             case SIMPLE_VECTOR_WIDETAG:
 551                 NEWLINE_OR_RETURN;
 552                 printf("length = %ld", length);
 553                 ptr++;
 554                 index = 0;
 555                 while (length-- > 0) {
 556                     sprintf(buffer, "%d: ", index++);
 557                     print_obj(buffer, *ptr++);
 558                 }
 559                 break;
 560
 561             case INSTANCE_HEADER_WIDETAG:
 562                 NEWLINE_OR_RETURN;
 563                 printf("length = %ld", (long) count);
 564                 index = 0;
 565                 while (count-- > 0) {
 566                     sprintf(buffer, "%d: ", index++);
 567                     print_obj(buffer, *ptr++);
 568                 }
 569                 break;
 570
 571             case SIMPLE_ARRAY_WIDETAG:
 572             case SIMPLE_BIT_VECTOR_WIDETAG:
 573             case SIMPLE_ARRAY_UNSIGNED_BYTE_2_WIDETAG:
 574             case SIMPLE_ARRAY_UNSIGNED_BYTE_4_WIDETAG:
 575             case SIMPLE_ARRAY_UNSIGNED_BYTE_8_WIDETAG:
 576             case SIMPLE_ARRAY_UNSIGNED_BYTE_16_WIDETAG:
 577             case SIMPLE_ARRAY_UNSIGNED_BYTE_32_WIDETAG:
 578 #ifdef SIMPLE_ARRAY_SIGNED_BYTE_8_WIDETAG
 579             case SIMPLE_ARRAY_SIGNED_BYTE_8_WIDETAG:
 580 #endif
 581 #ifdef SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG
 582             case SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG:
 583 #endif
 584 #ifdef SIMPLE_ARRAY_SIGNED_BYTE_30_WIDETAG
 585             case SIMPLE_ARRAY_SIGNED_BYTE_30_WIDETAG:
 586 #endif
 587 #ifdef SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG
 588             case SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG:
 589 #endif
 590             case SIMPLE_ARRAY_SINGLE_FLOAT_WIDETAG:
 591             case SIMPLE_ARRAY_DOUBLE_FLOAT_WIDETAG:
 592 #ifdef SIMPLE_ARRAY_LONG_FLOAT_WIDETAG
 593             case SIMPLE_ARRAY_LONG_FLOAT_WIDETAG:
 594 #endif
 595 #ifdef SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG
 596             case SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG:
 597 #endif
 598 #ifdef SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG
 599             case SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG:
 600 #endif
 601 #ifdef SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG
 602             case SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG:
 603 #endif
 604             case COMPLEX_BASE_STRING_WIDETAG:
 605 #ifdef COMPLEX_CHARACTER_STRING_WIDETAG
 606         case COMPLEX_CHARACTER_STRING_WIDETAG:
 607 #endif
 608             case COMPLEX_VECTOR_NIL_WIDETAG:
 609             case COMPLEX_BIT_VECTOR_WIDETAG:
 610             case COMPLEX_VECTOR_WIDETAG:
 611             case COMPLEX_ARRAY_WIDETAG:
 612                 break;
 613
 614             case CODE_HEADER_WIDETAG:
 615                 print_slots(code_slots, count-1, ptr);
 616                 break;
 617
 618             case SIMPLE_FUN_HEADER_WIDETAG:
 619                 print_slots(fn_slots, 5, ptr);
 620                 break;
 621
 622             case RETURN_PC_HEADER_WIDETAG:
 623                 print_obj("code: ", obj - (count * 4));
 624                 break;
 625
 626             case CLOSURE_HEADER_WIDETAG:
 627                 print_slots(closure_slots, count, ptr);
 628                 break;
 629
 630             case FUNCALLABLE_INSTANCE_HEADER_WIDETAG:
 631                 print_slots(funcallable_instance_slots, count, ptr);
 632                 break;
 633
 634             case VALUE_CELL_HEADER_WIDETAG:
 635                 print_slots(value_cell_slots, 1, ptr);
 636                 break;
 637
 638             case SAP_WIDETAG:
 639                 NEWLINE_OR_RETURN;
 640 #ifndef alpha
 641                 printf("0x%08lx", (unsigned long) *ptr);
 642 #else
 643                 printf("0x%016lx", *(lispobj*)(ptr+1));
 644 #endif
 645                 break;
 646
 647             case WEAK_POINTER_WIDETAG:
 648                 print_slots(weak_pointer_slots, 1, ptr);
 649                 break;
 650
 651             case CHARACTER_WIDETAG:
 652             case UNBOUND_MARKER_WIDETAG:
 653                 NEWLINE_OR_RETURN;
 654                 printf("pointer to an immediate?");
 655                 break;
 656
 657             case FDEFN_WIDETAG:
 658                 print_slots(fdefn_slots, count, ptr);
 659                 break;
 660
 661             default:
 662                 NEWLINE_OR_RETURN;
 663                 printf("Unknown header object?");
 664                 break;
 665         }
 666     }
 667 }
 668
 669 static void print_obj(char *prefix, lispobj obj)
 670 {
 671     static void (*verbose_fns[])(lispobj obj)
 672         = {print_fixnum, print_struct, print_otherimm, print_list,
 673            print_fixnum, print_otherptr, print_otherimm, print_otherptr};
 674     static void (*brief_fns[])(lispobj obj)
 675         = {brief_fixnum, brief_struct, brief_otherimm, brief_list,
 676            brief_fixnum, brief_otherptr, brief_otherimm, brief_otherptr};
 677     int type = lowtag_of(obj);
 678     struct var *var = lookup_by_obj(obj);
 679     char buffer[256];
 680     boolean verbose = cur_depth < brief_depth;
 681
 682     if (!continue_p(verbose))
 683         return;
 684
 685     if (var != NULL && var_clock(var) == cur_clock)
 686         dont_descend = 1;
 687
 688     if (var == NULL &&
 689         /* FIXME: What does this "x & y & z & .." expression mean? */
 690         (obj & FUN_POINTER_LOWTAG & LIST_POINTER_LOWTAG & INSTANCE_POINTER_LOWTAG & OTHER_POINTER_LOWTAG) != 0)
 691         var = define_var(NULL, obj, 0);
 692
 693     if (var != NULL)
 694         var_setclock(var, cur_clock);
 695
 696     cur_depth++;
 697     if (verbose) {
 698         if (var != NULL) {
 699             sprintf(buffer, "$%s=", var_name(var));
 700             newline(buffer);
 701         }
 702         else
 703             newline(NULL);
 704         printf("%s0x%08lx: ", prefix, (unsigned long) obj);
 705         if (cur_depth < brief_depth) {
 706             fputs(lowtag_Names[type], stdout);
 707             (*verbose_fns[type])(obj);
 708         }
 709         else
 710             (*brief_fns[type])(obj);
 711     }
 712     else {
 713         if (dont_descend)
 714             printf("$%s", var_name(var));
 715         else {
 716             if (var != NULL)
 717                 printf("$%s=", var_name(var));
 718             (*brief_fns[type])(obj);
 719         }
 720     }
 721     cur_depth--;
 722     dont_descend = 0;
 723 }
 724
 725 void reset_printer()
 726 {
 727     cur_clock++;
 728     cur_lines = 0;
 729     dont_descend = 0;
 730 }
 731
 732 void print(lispobj obj)
 733 {
 734     skip_newline = 1;
 735     cur_depth = 0;
 736     max_depth = 5;
 737     max_lines = 20;
 738
 739     print_obj("", obj);
 740
 741     putchar('\n');
 742 }
 743
 744 void brief_print(lispobj obj)
 745 {
 746     skip_newline = 1;
 747     cur_depth = 0;
 748     max_depth = 1;
 749     max_lines = 5000;
 750
 751     print_obj("", obj);
 752     putchar('\n');
 753 }
 754
 755 #else
 756
 757 void
 758 brief_print(lispobj obj)
 759 {
 760     printf("lispobj 0x%lx\n", (unsigned long)obj);
 761 }
 762
 763 #endif /* defined(LISP_FEATURE_SB_LDB) */