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