win/chain/wc_trace.c

   1 /* NetHack 3.6  wc_trace.c      $NHDT-Date: 1501464799 2017/07/31 01:33:19 $  $NHDT-Branch: NetHack-3.6.0 $:$NHDT-Revision: 1.8 $ */
   2 /* Copyright (c) Kenneth Lorber, 2012                             */
   3 /* NetHack may be freely redistributed.  See license for details. */
   4
   5 #include "hack.h"
   6 #include "wintty.h"
   7 #include "func_tab.h"
   8
   9 #include <ctype.h>
  10 #include <errno.h>
  11
  12 FILE *wc_tracelogf; /* Should be static, but it's just too useful to have
  13                      * access to this logfile from arbitrary other files. */
  14 static unsigned int indent_level; /* Some winfuncs call other winfuncs, so
  15                                    * we need to support nesting. */
  16
  17 static char indentdata[10] = "         ";
  18 #define ISCALE 1
  19 #if 1
  20 #define INDENT                                                             \
  21     &indentdata[((indent_level * ISCALE) < (sizeof(indentdata)))           \
  22                     ? ((sizeof(indentdata) - 1) - (indent_level * ISCALE)) \
  23                     : 0]
  24 #else
  25 /* for debugging this file */
  26 #define INDENT                                                          \
  27     ({                                                                  \
  28         static char buf[50];                                            \
  29         sprintf(buf, "[%s:%d %d]\t", __func__, __LINE__, indent_level); \
  30         buf;                                                            \
  31     })
  32 #endif
  33 #define PRE indent_level++
  34 #define POST indent_level--
  35
  36 struct trace_data {
  37     struct chain_procs *nprocs;
  38     void *ndata;
  39
  40     int linknum;
  41 };
  42
  43 void *
  44 trace_procs_chain(cmd, n, me, nextprocs, nextdata)
  45 int cmd;
  46 int n;
  47 void *me;
  48 void *nextprocs;
  49 void *nextdata;
  50 {
  51     struct trace_data *tdp = 0;
  52
  53     switch (cmd) {
  54     case WINCHAIN_ALLOC:
  55         tdp = (struct trace_data *) alloc(sizeof *tdp);
  56         tdp->nprocs = 0;
  57         tdp->ndata = 0;
  58         tdp->linknum = n;
  59         break;
  60     case WINCHAIN_INIT:
  61         tdp = me;
  62         tdp->nprocs = nextprocs;
  63         tdp->ndata = nextdata;
  64         break;
  65     default:
  66         panic("trace_procs_chain: bad cmd\n");
  67         /*NOTREACHED*/
  68     }
  69     return tdp;
  70 }
  71
  72 void
  73 trace_procs_init(dir)
  74 int dir;
  75 {
  76     char fname[200];
  77     long pid;
  78
  79     /* processors shouldn't need this test, but just in case */
  80     if (dir != WININIT)
  81         return;
  82
  83     pid = (long) getpid();
  84     Sprintf(fname, "%s/tlog.%ld", HACKDIR, pid);
  85     wc_tracelogf = fopen(fname, "w");
  86     if (!wc_tracelogf) {
  87         fprintf(stderr, "Can't open trace log file %s: %s\n", fname,
  88                 strerror(errno));
  89         nh_terminate(EXIT_FAILURE);
  90     }
  91     setvbuf(wc_tracelogf, (char *) 0, _IONBF, 0);
  92     fprintf(wc_tracelogf, "Trace log started for pid %ld\n", pid);
  93
  94     indent_level = 0;
  95 }
  96
  97 /***
  98  *** winprocs
  99  ***/
 100
 101 void
 102 trace_init_nhwindows(vp, argcp, argv)
 103 void *vp;
 104 int *argcp;
 105 char **argv;
 106 {
 107     struct trace_data *tdp = vp;
 108
 109     fprintf(wc_tracelogf, "%sinit_nhwindows(%d,*)\n", INDENT, *argcp);
 110
 111     PRE;
 112     (*tdp->nprocs->win_init_nhwindows)(tdp->ndata, argcp, argv);
 113     POST;
 114 }
 115
 116 void
 117 trace_player_selection(vp)
 118 void *vp;
 119 {
 120     struct trace_data *tdp = vp;
 121     fprintf(wc_tracelogf, "%splayer_selection()\n", INDENT);
 122
 123     PRE;
 124     (*tdp->nprocs->win_player_selection)(tdp->ndata);
 125     POST;
 126 }
 127
 128 void
 129 trace_askname(vp)
 130 void *vp;
 131 {
 132     struct trace_data *tdp = vp;
 133     fprintf(wc_tracelogf, "%saskname()\n", INDENT);
 134
 135     PRE;
 136     (*tdp->nprocs->win_askname)(tdp->ndata);
 137     POST;
 138 }
 139
 140 void
 141 trace_get_nh_event(vp)
 142 void *vp;
 143 {
 144     struct trace_data *tdp = vp;
 145     fprintf(wc_tracelogf, "%sget_nh_event()\n", INDENT);
 146
 147     PRE;
 148     (*tdp->nprocs->win_get_nh_event)(tdp->ndata);
 149     POST;
 150 }
 151
 152 void
 153 trace_exit_nhwindows(vp, str)
 154 void *vp;
 155 const char *str;
 156 {
 157     struct trace_data *tdp = vp;
 158     fprintf(wc_tracelogf, "%sexit_nhwindows(%s)\n", INDENT, str);
 159
 160     PRE;
 161     (*tdp->nprocs->win_exit_nhwindows)(tdp->ndata, str);
 162     POST;
 163 }
 164
 165 void
 166 trace_suspend_nhwindows(vp, str)
 167 void *vp;
 168 const char *str;
 169 {
 170     struct trace_data *tdp = vp;
 171     fprintf(wc_tracelogf, "%ssuspend_nhwindows(%s)\n", INDENT, str);
 172
 173     PRE;
 174     (*tdp->nprocs->win_suspend_nhwindows)(tdp->ndata, str);
 175     POST;
 176 }
 177
 178 void
 179 trace_resume_nhwindows(vp)
 180 void *vp;
 181 {
 182     struct trace_data *tdp = vp;
 183     fprintf(wc_tracelogf, "%sresume_nhwindows()\n", INDENT);
 184
 185     PRE;
 186     (*tdp->nprocs->win_resume_nhwindows)(tdp->ndata);
 187     POST;
 188 }
 189
 190 static const char *
 191 NHWname(type)
 192 int type;
 193 {
 194     switch (type) {
 195     case NHW_MESSAGE:
 196         return "MESSAGE";
 197     case NHW_STATUS:
 198         return "STATUS";
 199     case NHW_MAP:
 200         return "MAP";
 201     case NHW_MENU:
 202         return "MENU";
 203     case NHW_TEXT:
 204         return "TEXT";
 205     case NHW_BASE:
 206         return "BASE";
 207     default: {
 208         static char b[20];
 209         sprintf(b, "(%d)", type);
 210         return b;
 211     }
 212     }
 213 }
 214
 215 winid
 216 trace_create_nhwindow(vp, type)
 217 void *vp;
 218 int type;
 219 {
 220     struct trace_data *tdp = vp;
 221     const char *typestring = NHWname(type);
 222     winid rv;
 223
 224     fprintf(wc_tracelogf, "%screate_nhwindow(%s)\n", INDENT, typestring);
 225
 226     PRE;
 227     rv = (*tdp->nprocs->win_create_nhwindow)(tdp->ndata, type);
 228     POST;
 229
 230     fprintf(wc_tracelogf, "%s=> %d\n", INDENT, rv);
 231     return rv;
 232 }
 233
 234 void
 235 trace_clear_nhwindow(vp, window)
 236 void *vp;
 237 winid window;
 238 {
 239     struct trace_data *tdp = vp;
 240
 241     fprintf(wc_tracelogf, "%sclear_nhwindow(%d)\n", INDENT, window);
 242
 243     PRE;
 244     (*tdp->nprocs->win_clear_nhwindow)(tdp->ndata, window);
 245     POST;
 246 }
 247
 248 void
 249 trace_display_nhwindow(vp, window, blocking)
 250 void *vp;
 251 winid window;
 252 BOOLEAN_P blocking;
 253 {
 254     struct trace_data *tdp = vp;
 255
 256     fprintf(wc_tracelogf, "%sdisplay_nhwindow(%d, %d)\n", INDENT, window,
 257             blocking);
 258
 259     PRE;
 260     (*tdp->nprocs->win_display_nhwindow)(tdp->ndata, window, blocking);
 261     POST;
 262 }
 263
 264 void
 265 trace_destroy_nhwindow(vp, window)
 266 void *vp;
 267 winid window;
 268 {
 269     struct trace_data *tdp = vp;
 270
 271     fprintf(wc_tracelogf, "%sdestroy_nhwindow(%d)\n", INDENT, window);
 272
 273     PRE;
 274     (*tdp->nprocs->win_destroy_nhwindow)(tdp->ndata, window);
 275     POST;
 276 }
 277
 278 void
 279 trace_curs(vp, window, x, y)
 280 void *vp;
 281 winid window;
 282 int x;
 283 int y;
 284 {
 285     struct trace_data *tdp = vp;
 286
 287     fprintf(wc_tracelogf, "%scurs(%d, %d, %d)\n", INDENT, window, x, y);
 288
 289     PRE;
 290     (*tdp->nprocs->win_curs)(tdp->ndata, window, x, y);
 291     POST;
 292 }
 293
 294 void
 295 trace_putstr(vp, window, attr, str)
 296 void *vp;
 297 winid window;
 298 int attr;
 299 const char *str;
 300 {
 301     struct trace_data *tdp = vp;
 302
 303     if (str) {
 304         fprintf(wc_tracelogf, "%sputstr(%d, %d, '%s'(%d))\n", INDENT, window,
 305                 attr, str, (int) strlen(str));
 306     } else {
 307         fprintf(wc_tracelogf, "%sputstr(%d, %d, NULL)\n", INDENT, window,
 308                 attr);
 309     }
 310
 311     PRE;
 312     (*tdp->nprocs->win_putstr)(tdp->ndata, window, attr, str);
 313     POST;
 314 }
 315
 316 void
 317 trace_putmixed(vp, window, attr, str)
 318 void *vp;
 319 winid window;
 320 int attr;
 321 const char *str;
 322 {
 323     struct trace_data *tdp = vp;
 324
 325     if (str) {
 326         fprintf(wc_tracelogf, "%sputmixed(%d, %d, '%s'(%d))\n", INDENT,
 327                 window, attr, str, (int) strlen(str));
 328     } else {
 329         fprintf(wc_tracelogf, "%sputmixed(%d, %d, NULL)\n", INDENT, window,
 330                 attr);
 331     }
 332
 333     PRE;
 334     (*tdp->nprocs->win_putmixed)(tdp->ndata, window, attr, str);
 335     POST;
 336 }
 337
 338 void
 339 trace_display_file(vp, fname, complain)
 340 void *vp;
 341 const char *fname;
 342 boolean complain;
 343 {
 344     struct trace_data *tdp = vp;
 345
 346     if (fname) {
 347         fprintf(wc_tracelogf, "%sdisplay_file('%s'(%d), %d)\n", INDENT, fname,
 348                 (int) strlen(fname), complain);
 349     } else {
 350         fprintf(wc_tracelogf, "%sdisplay_file(NULL, %d)\n", INDENT, complain);
 351     }
 352
 353     PRE;
 354     (*tdp->nprocs->win_display_file)(tdp->ndata, fname, complain);
 355     POST;
 356 }
 357
 358 void
 359 trace_start_menu(vp, window)
 360 void *vp;
 361 winid window;
 362 {
 363     struct trace_data *tdp = vp;
 364
 365     fprintf(wc_tracelogf, "%sstart_menu(%d)\n", INDENT, window);
 366
 367     PRE;
 368     (*tdp->nprocs->win_start_menu)(tdp->ndata, window);
 369     POST;
 370 }
 371
 372 void
 373 trace_add_menu(vp, window, glyph, identifier, ch, gch, attr, str, preselected)
 374 void *vp;
 375 winid window;               /* window to use, must be of type NHW_MENU */
 376 int glyph;                  /* glyph to display with item (unused) */
 377 const anything *identifier; /* what to return if selected */
 378 char ch;                    /* keyboard accelerator (0 = pick our own) */
 379 char gch;                   /* group accelerator (0 = no group) */
 380 int attr;                   /* attribute for string (like tty_putstr()) */
 381 const char *str;            /* menu string */
 382 boolean preselected;        /* item is marked as selected */
 383 {
 384     struct trace_data *tdp = vp;
 385
 386     char buf_ch[10];
 387     char buf_gch[10];
 388
 389     if (isprint(ch)) {
 390         sprintf(buf_ch, "'%c'(%d)", ch, ch);
 391     } else {
 392         sprintf(buf_ch, "(%d)", ch);
 393     }
 394
 395     if (isprint(gch)) {
 396         sprintf(buf_gch, "'%c'(%d)", gch, gch);
 397     } else {
 398         sprintf(buf_gch, "(%d)", gch);
 399     }
 400
 401     if (str) {
 402         fprintf(wc_tracelogf,
 403                 "%sadd_menu(%d, %d, %p, %s, %s, %d, '%s'(%d), %d)\n", INDENT,
 404                 window, glyph, (void *) identifier, buf_ch, buf_gch, attr,
 405                 str, (int) strlen(str), preselected);
 406     } else {
 407         fprintf(wc_tracelogf,
 408                 "%sadd_menu(%d, %d, %p, %s, %s, %d, NULL, %d)\n", INDENT,
 409                 window, glyph, (void *) identifier, buf_ch, buf_gch, attr,
 410                 preselected);
 411     }
 412
 413     PRE;
 414     (*tdp->nprocs->win_add_menu)(tdp->ndata, window, glyph, identifier, ch,
 415                                  gch, attr, str, preselected);
 416     POST;
 417 }
 418
 419 void
 420 trace_end_menu(vp, window, prompt)
 421 void *vp;
 422 winid window;
 423 const char *prompt;
 424 {
 425     struct trace_data *tdp = vp;
 426
 427     if (prompt) {
 428         fprintf(wc_tracelogf, "%send_menu(%d, '%s'(%d))\n", INDENT, window,
 429                 prompt, (int) strlen(prompt));
 430     } else {
 431         fprintf(wc_tracelogf, "%send_menu(%d, NULL)\n", INDENT, window);
 432     }
 433
 434     PRE;
 435     (*tdp->nprocs->win_end_menu)(tdp->ndata, window, prompt);
 436     POST;
 437 }
 438
 439 int
 440 trace_select_menu(vp, window, how, menu_list)
 441 void *vp;
 442 winid window;
 443 int how;
 444 menu_item **menu_list;
 445 {
 446     struct trace_data *tdp = vp;
 447     int rv;
 448
 449     fprintf(wc_tracelogf, "%sselect_menu(%d, %d, %p)\n", INDENT, window, how,
 450             (void *) menu_list);
 451
 452     PRE;
 453     rv = (*tdp->nprocs->win_select_menu)(tdp->ndata, window, how,
 454                                          (void *) menu_list);
 455     POST;
 456
 457     fprintf(wc_tracelogf, "%s=> %d\n", INDENT, rv);
 458     return rv;
 459 }
 460
 461 char
 462 trace_message_menu(vp, let, how, mesg)
 463 void *vp;
 464 char let;
 465 int how;
 466 const char *mesg;
 467 {
 468     struct trace_data *tdp = vp;
 469     char buf_let[10];
 470     char rv;
 471
 472     if (isprint(let)) {
 473         sprintf(buf_let, "'%c'(%d)", let, let);
 474     } else {
 475         sprintf(buf_let, "(%d)", let);
 476     }
 477
 478     if (mesg) {
 479         fprintf(wc_tracelogf, "%smessage_menu(%s, %d, '%s'(%d))\n", INDENT,
 480                 buf_let, how, mesg, (int) strlen(mesg));
 481     } else {
 482         fprintf(wc_tracelogf, "%smessage_menu(%s, %d, NULL)\n", INDENT,
 483                 buf_let, how);
 484     }
 485
 486     PRE;
 487     rv = (*tdp->nprocs->win_message_menu)(tdp->ndata, let, how, mesg);
 488     POST;
 489
 490     if (isprint(rv)) {
 491         sprintf(buf_let, "'%c'(%d)", rv, rv);
 492     } else {
 493         sprintf(buf_let, "(%d)", rv);
 494     }
 495     fprintf(wc_tracelogf, "%s=> %s\n", INDENT, buf_let);
 496
 497     return rv;
 498 }
 499
 500 void
 501 trace_update_inventory(vp)
 502 void *vp;
 503 {
 504     struct trace_data *tdp = vp;
 505
 506     fprintf(wc_tracelogf, "%supdate_inventory()\n", INDENT);
 507
 508     PRE;
 509     (*tdp->nprocs->win_update_inventory)(tdp->ndata);
 510     POST;
 511 }
 512
 513 void
 514 trace_mark_synch(vp)
 515 void *vp;
 516 {
 517     struct trace_data *tdp = vp;
 518
 519     fprintf(wc_tracelogf, "%smark_synch()\n", INDENT);
 520
 521     PRE;
 522     (*tdp->nprocs->win_mark_synch)(tdp->ndata);
 523     POST;
 524 }
 525
 526 void
 527 trace_wait_synch(vp)
 528 void *vp;
 529 {
 530     struct trace_data *tdp = vp;
 531
 532     fprintf(wc_tracelogf, "%swait_synch()\n", INDENT);
 533
 534     PRE;
 535     (*tdp->nprocs->win_wait_synch)(tdp->ndata);
 536     POST;
 537 }
 538
 539 #ifdef CLIPPING
 540 void
 541 trace_cliparound(vp, x, y)
 542 void *vp;
 543 int x;
 544 int y;
 545 {
 546     struct trace_data *tdp = vp;
 547
 548     fprintf(wc_tracelogf, "%scliparound(%d, %d)\n", INDENT, x, y);
 549
 550     PRE;
 551     (*tdp->nprocs->win_cliparound)(tdp->ndata, x, y);
 552     POST;
 553 }
 554 #endif
 555
 556 #ifdef POSITIONBAR
 557 void
 558 trace_update_positionbar(vp, posbar)
 559 void *vp;
 560 char *posbar;
 561 {
 562     struct trace_data *tdp = vp;
 563
 564     if (posbar) {
 565         fprintf(wc_tracelogf, "%supdate_positionbar('%s'(%d))\n", INDENT,
 566                 posbar, (int) strlen(posbar));
 567     } else {
 568         fprintf(wc_tracelogf, "%supdate_positionbar(NULL)\n", INDENT);
 569     }
 570     PRE;
 571     (*tdp->nprocs->win_update_positionbar)(tdp->ndata, posbar);
 572     POST;
 573 }
 574 #endif
 575
 576 /* XXX can we decode the glyph in a meaningful way? see mapglyph()?
 577  genl_putmixed?  */
 578 void
 579 trace_print_glyph(vp, window, x, y, glyph, bkglyph)
 580 void *vp;
 581 winid window;
 582 xchar x, y;
 583 int glyph, bkglyph;
 584 {
 585     struct trace_data *tdp = vp;
 586
 587     fprintf(wc_tracelogf, "%sprint_glyph(%d, %d, %d, %d, %d)\n", INDENT, window,
 588             x, y, glyph, bkglyph);
 589
 590     PRE;
 591     (*tdp->nprocs->win_print_glyph)(tdp->ndata, window, x, y, glyph, bkglyph);
 592     POST;
 593 }
 594
 595 void
 596 trace_raw_print(vp, str)
 597 void *vp;
 598 const char *str;
 599 {
 600     struct trace_data *tdp = vp;
 601
 602     if (str) {
 603         fprintf(wc_tracelogf, "%sraw_print('%s'(%d))\n", INDENT, str,
 604                 (int) strlen(str));
 605     } else {
 606         fprintf(wc_tracelogf, "%sraw_print(NULL)\n", INDENT);
 607     }
 608
 609     PRE;
 610     (*tdp->nprocs->win_raw_print)(tdp->ndata, str);
 611     POST;
 612 }
 613
 614 void
 615 trace_raw_print_bold(vp, str)
 616 void *vp;
 617 const char *str;
 618 {
 619     struct trace_data *tdp = vp;
 620
 621     if (str) {
 622         fprintf(wc_tracelogf, "%sraw_print_bold('%s'(%d))\n", INDENT, str,
 623                 (int) strlen(str));
 624     } else {
 625         fprintf(wc_tracelogf, "%sraw_print_bold(NULL)\n", INDENT);
 626     }
 627
 628     PRE;
 629     (*tdp->nprocs->win_raw_print_bold)(tdp->ndata, str);
 630     POST;
 631 }
 632
 633 int
 634 trace_nhgetch(vp)
 635 void *vp;
 636 {
 637     struct trace_data *tdp = vp;
 638     int rv;
 639     char buf[10];
 640
 641     fprintf(wc_tracelogf, "%snhgetch()\n", INDENT);
 642
 643     PRE;
 644     rv = (*tdp->nprocs->win_nhgetch)(tdp->ndata);
 645     POST;
 646
 647     if (rv > 0 && rv < 256 && isprint(rv)) {
 648         sprintf(buf, "'%c'(%d)", rv, rv);
 649     } else {
 650         sprintf(buf, "(%d)", rv);
 651     }
 652     fprintf(wc_tracelogf, "%s=> %s\n", INDENT, buf);
 653
 654     return rv;
 655 }
 656
 657 int
 658 trace_nh_poskey(vp, x, y, mod)
 659 void *vp;
 660 int *x;
 661 int *y;
 662 int *mod;
 663 {
 664     struct trace_data *tdp = vp;
 665     int rv;
 666     char buf[10];
 667
 668     fprintf(wc_tracelogf, "%snh_poskey(%d, %d, %d)\n", INDENT, *x, *y, *mod);
 669
 670     PRE;
 671     rv = (*tdp->nprocs->win_nh_poskey)(tdp->ndata, x, y, mod);
 672     POST;
 673     if (rv > 0 && rv < 256 && isprint(rv)) {
 674         sprintf(buf, "'%c'(%d)", rv, rv);
 675     } else {
 676         sprintf(buf, "(%d)", rv);
 677     }
 678     fprintf(wc_tracelogf, "%s=> %s (%d, %d, %d)\n", INDENT, buf, *x, *y,
 679             *mod);
 680
 681     return rv;
 682 }
 683
 684 void
 685 trace_nhbell(vp)
 686 void *vp;
 687 {
 688     struct trace_data *tdp = vp;
 689
 690     fprintf(wc_tracelogf, "%snhbell()\n", INDENT);
 691
 692     PRE;
 693     (*tdp->nprocs->win_nhbell)(tdp->ndata);
 694     POST;
 695 }
 696
 697 int
 698 trace_doprev_message(vp)
 699 void *vp;
 700 {
 701     struct trace_data *tdp = vp;
 702     int rv;
 703
 704     fprintf(wc_tracelogf, "%sdoprev_message()\n", INDENT);
 705
 706     PRE;
 707     rv = (*tdp->nprocs->win_doprev_message)(tdp->ndata);
 708     POST;
 709
 710     fprintf(wc_tracelogf, "%s=> %d\n", INDENT, rv);
 711
 712     return rv;
 713 }
 714
 715 char
 716 trace_yn_function(vp, query, resp, def)
 717 void *vp;
 718 const char *query, *resp;
 719 char def;
 720 {
 721     struct trace_data *tdp = vp;
 722     char rv;
 723     char buf[10];
 724
 725     if (query) {
 726         fprintf(wc_tracelogf, "%syn_function('%s'(%d), ", INDENT, query,
 727                 (int) strlen(query));
 728     } else {
 729         fprintf(wc_tracelogf, "%syn_function(NULL, ", INDENT);
 730     }
 731
 732     if (resp) {
 733         fprintf(wc_tracelogf, "'%s'(%d), ", resp, (int) strlen(resp));
 734     } else {
 735         fprintf(wc_tracelogf, "NULL, ");
 736     }
 737
 738     if (isprint(def)) {
 739         sprintf(buf, "'%c'(%d)", def, def);
 740     } else {
 741         sprintf(buf, "(%d)", def);
 742     }
 743
 744     fprintf(wc_tracelogf, "%s)\n", buf);
 745
 746     PRE;
 747     rv = (*tdp->nprocs->win_yn_function)(tdp->ndata, query, resp, def);
 748     POST;
 749
 750     if (isprint(rv)) {
 751         sprintf(buf, "'%c'(%d)", rv, rv);
 752     } else {
 753         sprintf(buf, "(%d)", rv);
 754     }
 755
 756     fprintf(wc_tracelogf, "%s=> %s\n", INDENT, buf);
 757
 758     return rv;
 759 }
 760
 761 void
 762 trace_getlin(vp, query, bufp)
 763 void *vp;
 764 const char *query;
 765 char *bufp;
 766 {
 767     struct trace_data *tdp = vp;
 768
 769     if (query) {
 770         fprintf(wc_tracelogf, "%sgetlin('%s'(%d), ", INDENT, query,
 771                 (int) strlen(query));
 772     } else {
 773         fprintf(wc_tracelogf, "%sgetlin(NULL, ", INDENT);
 774     }
 775
 776     if (bufp) {
 777         fprintf(wc_tracelogf, "%s)\n", fmt_ptr((genericptr_t) bufp));
 778     } else {
 779         fprintf(wc_tracelogf, "NULL)\n");
 780     }
 781
 782     PRE;
 783     (*tdp->nprocs->win_getlin)(tdp->ndata, query, bufp);
 784     POST;
 785 }
 786
 787 int
 788 trace_get_ext_cmd(vp)
 789 void *vp;
 790 {
 791     struct trace_data *tdp = vp;
 792     int rv;
 793     int ecl_size = 0;
 794
 795     /* this is ugly, but the size isn't exposed */
 796     const struct ext_func_tab *efp;
 797     for (efp = extcmdlist; efp->ef_txt; efp++)
 798         ecl_size++;
 799
 800     fprintf(wc_tracelogf, "%sget_ext_cmd()\n", INDENT);
 801
 802     PRE;
 803     rv = (*tdp->nprocs->win_get_ext_cmd)(tdp->ndata);
 804     POST;
 805
 806     if (rv < 0 || rv >= ecl_size) {
 807         fprintf(wc_tracelogf, "%s=> (%d)\n", INDENT, rv);
 808     } else {
 809         fprintf(wc_tracelogf, "%s=> %d/%s\n", INDENT, rv,
 810                 extcmdlist[rv].ef_txt);
 811     }
 812
 813     return rv;
 814 }
 815
 816 void
 817 trace_number_pad(vp, state)
 818 void *vp;
 819 int state;
 820 {
 821     struct trace_data *tdp = vp;
 822
 823     fprintf(wc_tracelogf, "%snumber_pad(%d)\n", INDENT, state);
 824
 825     PRE;
 826     (*tdp->nprocs->win_number_pad)(tdp->ndata, state);
 827     POST;
 828 }
 829
 830 void
 831 trace_delay_output(vp)
 832 void *vp;
 833 {
 834     struct trace_data *tdp = vp;
 835
 836     fprintf(wc_tracelogf, "%sdelay_output()\n", INDENT);
 837
 838     PRE;
 839     (*tdp->nprocs->win_delay_output)(tdp->ndata);
 840     POST;
 841 }
 842
 843 #ifdef CHANGE_COLOR
 844 void
 845 trace_change_color(vp, color, value, reverse)
 846 void *vp;
 847 int color;
 848 long value;
 849 int reverse;
 850 {
 851     struct trace_data *tdp = vp;
 852
 853     fprintf(wc_tracelogf, "%schange_color(%d, $%lx, %d)\n", INDENT, color,
 854             value, reverse);
 855
 856     PRE;
 857     (*tdp->nprocs->win_change_color)(tdp->ndata, color, value, reverse);
 858     POST;
 859 }
 860
 861 #ifdef MAC
 862 void
 863 trace_change_background(vp, bw)
 864 void *vp;
 865 int bw;
 866 {
 867     struct trace_data *tdp = vp;
 868
 869     fprintf(wc_tracelogf, "%schange_background(%d)\n", INDENT, bw);
 870
 871     PRE;
 872     (*tdp->nprocs->win_change_background)(tdp->ndata, bw);
 873     POST;
 874 }
 875
 876 short
 877 trace_set_font_name(vp, window, font)
 878 void *vp;
 879 winid window;
 880 char *font;
 881 {
 882     struct trace_data *tdp = vp;
 883     short rv;
 884
 885     if (font) {
 886         fprintf(wc_tracelogf, "%sset_font_name(%d, '%s'(%d))\n", INDENT,
 887                 window, font, (int) (strlen(font)));
 888     } else {
 889         fprintf(wc_tracelogf, "%sset_font_name(%d, NULL)\n", INDENT, window);
 890     }
 891
 892     PRE;
 893     rv = (*tdp->nprocs->win_set_font_name)(tdp->ndata, window, font);
 894     POST;
 895
 896     fprintf(wc_tracelogf, "%s=> %d\n", INDENT, rv);
 897
 898     return rv;
 899 }
 900 #endif
 901
 902 char *
 903 trace_get_color_string(vp)
 904 void *vp;
 905 {
 906     struct trace_data *tdp = vp;
 907     char *rv;
 908
 909     fprintf(wc_tracelogf, "%sget_color_string()\n", INDENT);
 910
 911     PRE;
 912     rv = (*tdp->nprocs->win_get_color_string)(tdp->ndata);
 913     POST;
 914
 915     if (rv) {
 916         fprintf(wc_tracelogf, "%s=> '%s'(%d)\n", INDENT, rv,
 917                 (int) strlen(rv));
 918     } else {
 919         fprintf(wc_tracelogf, "%s=> NULL\n", INDENT);
 920     }
 921
 922     return rv;
 923 }
 924
 925 #endif
 926
 927 /* other defs that really should go away (they're tty specific) */
 928 void
 929 trace_start_screen(vp)
 930 void *vp;
 931 {
 932     struct trace_data *tdp = vp;
 933
 934     fprintf(wc_tracelogf, "%sstart_screen()\n", INDENT);
 935
 936     PRE;
 937     (*tdp->nprocs->win_start_screen)(tdp->ndata);
 938     POST;
 939 }
 940
 941 void
 942 trace_end_screen(vp)
 943 void *vp;
 944 {
 945     struct trace_data *tdp = vp;
 946
 947     fprintf(wc_tracelogf, "%send_screen()\n", INDENT);
 948
 949     PRE;
 950     (*tdp->nprocs->win_end_screen)(tdp->ndata);
 951     POST;
 952 }
 953
 954 void
 955 trace_outrip(vp, tmpwin, how, when)
 956 void *vp;
 957 winid tmpwin;
 958 int how;
 959 time_t when;
 960 {
 961     struct trace_data *tdp = vp;
 962
 963     fprintf(wc_tracelogf, "%soutrip(%d, %d, %ld)\n", INDENT, (int) tmpwin,
 964             how, (long) when);
 965
 966     PRE;
 967     (*tdp->nprocs->win_outrip)(tdp->ndata, tmpwin, how, when);
 968     POST;
 969 }
 970
 971 void
 972 trace_preference_update(vp, pref)
 973 void *vp;
 974 const char *pref;
 975 {
 976     struct trace_data *tdp = vp;
 977
 978     if (pref) {
 979         fprintf(wc_tracelogf, "%spreference_update('%s'(%d))\n", INDENT, pref,
 980                 (int) strlen(pref));
 981     } else {
 982         fprintf(wc_tracelogf, "%spreference_update(NULL)\n", INDENT);
 983     }
 984
 985     PRE;
 986     (*tdp->nprocs->win_preference_update)(tdp->ndata, pref);
 987     POST;
 988 }
 989
 990 char *
 991 trace_getmsghistory(vp, init)
 992 void *vp;
 993 boolean init;
 994 {
 995     struct trace_data *tdp = vp;
 996     char *rv;
 997
 998     fprintf(wc_tracelogf, "%sgetmsghistory(%d)\n", INDENT, init);
 999
1000     PRE;
1001     rv = (*tdp->nprocs->win_getmsghistory)(tdp->ndata, init);
1002     POST;
1003
1004     if (rv) {
1005         fprintf(wc_tracelogf, "%s=> '%s'(%d)\n", INDENT, rv,
1006                 (int) strlen(rv));
1007     } else {
1008         fprintf(wc_tracelogf, "%s=> NULL\n", INDENT);
1009     }
1010
1011     return rv;
1012 }
1013
1014 void
1015 trace_putmsghistory(vp, msg, is_restoring)
1016 void *vp;
1017 const char *msg;
1018 boolean is_restoring;
1019 {
1020     struct trace_data *tdp = vp;
1021
1022     if (msg) {
1023         fprintf(wc_tracelogf, "%sputmsghistory('%s'(%d), %d)\n", INDENT, msg,
1024                 (int) strlen(msg), is_restoring);
1025     } else {
1026         fprintf(wc_tracelogf, "%sputmghistory(NULL, %d)\n", INDENT,
1027                 is_restoring);
1028     }
1029
1030     PRE;
1031     (*tdp->nprocs->win_putmsghistory)(tdp->ndata, msg, is_restoring);
1032     POST;
1033 }
1034
1035 void
1036 trace_status_init(vp)
1037 void *vp;
1038 {
1039     struct trace_data *tdp = vp;
1040
1041     fprintf(wc_tracelogf, "%sstatus_init()\n", INDENT);
1042
1043     PRE;
1044     (*tdp->nprocs->win_status_init)(tdp->ndata);
1045     POST;
1046 }
1047
1048 void
1049 trace_status_finish(vp)
1050 void *vp;
1051 {
1052     struct trace_data *tdp = vp;
1053
1054     fprintf(wc_tracelogf, "%sstatus_finish()\n", INDENT);
1055
1056     PRE;
1057     (*tdp->nprocs->win_status_finish)(tdp->ndata);
1058     POST;
1059 }
1060
1061 void
1062 trace_status_enablefield(vp, fieldidx, nm, fmt, enable)
1063 void *vp;
1064 int fieldidx;
1065 const char *nm;
1066 const char *fmt;
1067 boolean enable;
1068 {
1069     struct trace_data *tdp = vp;
1070
1071     fprintf(wc_tracelogf, "%sstatus_enablefield(%d, ", INDENT, fieldidx);
1072     if (nm) {
1073         fprintf(wc_tracelogf, "'%s'(%d), ", nm, (int) strlen(nm));
1074     } else {
1075         fprintf(wc_tracelogf, "NULL, ");
1076     }
1077     if (fmt) {
1078         fprintf(wc_tracelogf, "'%s'(%d), ", fmt, (int) strlen(fmt));
1079     } else {
1080         fprintf(wc_tracelogf, "NULL, ");
1081     }
1082     fprintf(wc_tracelogf, "%d)\n", enable);
1083
1084     PRE;
1085     (*tdp->nprocs->win_status_enablefield)(tdp->ndata, fieldidx, nm, fmt,
1086                                            enable);
1087     POST;
1088 }
1089
1090 void
1091 trace_status_update(vp, idx, ptr, chg, percent, color, colormasks)
1092 void *vp;
1093 int idx, chg, percent, color;
1094 genericptr_t ptr;
1095 unsigned long *colormasks;
1096 {
1097     struct trace_data *tdp = vp;
1098
1099     fprintf(wc_tracelogf, "%sstatus_update(%d, %p, %d, %d)\n", INDENT, idx,
1100             ptr, chg, percent);
1101
1102     PRE;
1103     (*tdp->nprocs->win_status_update)(tdp->ndata, idx, ptr, chg, percent,
1104                                       color, colormasks);
1105     POST;
1106 }
1107
1108 boolean
1109 trace_can_suspend(vp)
1110 void *vp;
1111 {
1112     struct trace_data *tdp = vp;
1113     boolean rv;
1114
1115     fprintf(wc_tracelogf, "%scan_suspend()\n", INDENT);
1116
1117     PRE;
1118     rv = (*tdp->nprocs->win_can_suspend)(tdp->ndata);
1119     POST;
1120
1121     fprintf(wc_tracelogf, "%s=> %d\n", INDENT, rv);
1122
1123     return rv;
1124 }
1125
1126 struct chain_procs trace_procs = {
1127     "+trace", 0, /* wincap */
1128     0,           /* wincap2 */
1129     /*
1130     XXX problem - the above need to come from the real window port, possibly
1131     modified.  May need to do something to call an additional init fn later
1132     or if this is the only place like this the choose_windows fn can do the
1133     fixup
1134     (but not if the value can be modified by the stack?)  TBD
1135     */
1136     trace_init_nhwindows,
1137     trace_player_selection, trace_askname, trace_get_nh_event,
1138     trace_exit_nhwindows, trace_suspend_nhwindows, trace_resume_nhwindows,
1139     trace_create_nhwindow, trace_clear_nhwindow, trace_display_nhwindow,
1140     trace_destroy_nhwindow, trace_curs, trace_putstr, trace_putmixed,
1141     trace_display_file, trace_start_menu, trace_add_menu, trace_end_menu,
1142     trace_select_menu, trace_message_menu, trace_update_inventory,
1143     trace_mark_synch, trace_wait_synch,
1144 #ifdef CLIPPING
1145     trace_cliparound,
1146 #endif
1147 #ifdef POSITIONBAR
1148     trace_update_positionbar,
1149 #endif
1150     trace_print_glyph, trace_raw_print, trace_raw_print_bold, trace_nhgetch,
1151     trace_nh_poskey, trace_nhbell, trace_doprev_message, trace_yn_function,
1152     trace_getlin, trace_get_ext_cmd, trace_number_pad, trace_delay_output,
1153 #ifdef CHANGE_COLOR
1154     trace_change_color,
1155 #ifdef MAC
1156     trace_change_background, trace_set_font_name,
1157 #endif
1158     trace_get_color_string,
1159 #endif
1160
1161     trace_start_screen, trace_end_screen,
1162
1163     trace_outrip, trace_preference_update, trace_getmsghistory,
1164     trace_putmsghistory,
1165     trace_status_init, trace_status_finish, trace_status_enablefield,
1166     trace_status_update,
1167     trace_can_suspend,
1168 };