regina/tracing.c

   1 /*
   2  *  The Regina Rexx Interpreter
   3  *  Copyright (C) 1992-1994  Anders Christensen <anders@pvv.unit.no>
   4  *
   5  *  This library is free software; you can redistribute it and/or
   6  *  modify it under the terms of the GNU Library General Public
   7  *  License as published by the Free Software Foundation; either
   8  *  version 2 of the License, or (at your option) any later version.
   9  *
  10  *  This library is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  *  Library General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU Library General Public
  16  *  License along with this library; if not, write to the Free
  17  *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19
  20 #include "rexx.h"
  21 #include <stdio.h>
  22 #ifdef HAVE_UNISTD_H
  23 # include <unistd.h>
  24 #endif
  25 #ifdef HAVE_ASSERT_H
  26 # include <assert.h>
  27 #endif
  28 #include <string.h>
  29
  30
  31 typedef struct { /* tra_tsd: static variables of this module (thread-safe) */
  32    int  traceflag;   /* boolean: 1 indicates that trace output is NOT displayed */
  33    int  lasttracedline;
  34    int  intercount;  /* number of times to execute trace without interaction */
  35    int  quiet;       /* boolean: run quietly in interaction trace */
  36    int  notnow;
  37    char tracestr[LINELENGTH+1];
  38    char buf0[32];
  39    int  bufptr0;
  40    char tracefmt[20];
  41 } tra_tsd_t; /* thread-specific but only needed by this module. see
  42               * init_tracing
  43               */
  44
  45
  46 /* init_tracing initializes the module.
  47  * Currently, we set up the thread specific data.
  48  * The function returns 1 on success, 0 if memory is short.
  49  */
  50 int init_tracing( tsd_t *TSD )
  51 {
  52    tra_tsd_t *tt;
  53
  54    if ( TSD->tra_tsd != NULL )
  55       return 1;
  56
  57    if ( ( TSD->tra_tsd = MallocTSD( sizeof( tra_tsd_t ) ) ) == NULL )
  58       return 0;
  59    tt = (tra_tsd_t *)TSD->tra_tsd;
  60    memset( tt, 0, sizeof( tra_tsd_t ) );
  61    tt->lasttracedline = -1;
  62    return 1;
  63 }
  64
  65 int pushcallstack( const tsd_t *TSD, treenode *thisptr )
  66 {
  67    nodeptr *tmpptr;
  68
  69    if ( TSD->systeminfo->cstackcnt >= TSD->systeminfo->cstackmax )
  70    {
  71       assert( TSD->systeminfo->cstackcnt == TSD->systeminfo->cstackmax );
  72       tmpptr = (nodeptr *)MallocTSD( ( TSD->systeminfo->cstackmax * 2 + 10 ) *
  73                                                            sizeof( nodeptr ) );
  74       if ( TSD->systeminfo->callstack )
  75       {
  76          memcpy( tmpptr, TSD->systeminfo->callstack,
  77                               TSD->systeminfo->cstackcnt * sizeof( nodeptr ) );
  78          FreeTSD( TSD->systeminfo->callstack );
  79       }
  80       TSD->systeminfo->callstack = tmpptr;
  81       TSD->systeminfo->cstackmax *= 2;
  82       TSD->systeminfo->cstackmax += 10;
  83    }
  84
  85    TSD->systeminfo->callstack[TSD->systeminfo->cstackcnt++] = thisptr;
  86    return TSD->systeminfo->cstackcnt;
  87 }
  88
  89 void popcallstack( const tsd_t *TSD, int value )
  90 {
  91    if ( value >= 0 )
  92    {
  93       assert( TSD->systeminfo->cstackcnt >= value );
  94       TSD->systeminfo->cstackcnt = value;
  95    }
  96
  97    --TSD->systeminfo->cstackcnt;
  98
  99    assert( TSD->systeminfo->cstackcnt >= 0 );
 100 }
 101
 102 static void printout( tsd_t *TSD, const streng *message )
 103 {
 104    int rc;
 105    FILE *fp=stderr;
 106
 107    rc = HOOK_GO_ON;
 108    if ( TSD->systeminfo->hooks & HOOK_MASK( HOOK_STDERR ) )
 109       rc = hookup_output( TSD, HOOK_STDERR, message );
 110
 111    if ( rc == HOOK_GO_ON )
 112    {
 113       if ( get_options_flag( TSD->currlevel, EXT_STDOUT_FOR_STDERR ) )
 114          fp = stdout;
 115       if ( get_options_flag( TSD->currlevel, EXT_TRACE_HTML ) )
 116          fwrite( "<FONT COLOR=#669933><PRE>", 25, 1, fp );
 117       fwrite( message->value, message->len, 1, fp ) ;
 118       if ( get_options_flag( TSD->currlevel, EXT_TRACE_HTML ) )
 119          fwrite( "</PRE></FONT>", 13, 1, fp );
 120 #if defined(DOS) || defined(OS2) || defined(WIN32)
 121       /*
 122        * stdout is open in binary mode, so we need to add the
 123        * extra CR to the end of the line.
 124        */
 125       fputc( REGINA_CR, fp );
 126 #endif
 127       fputc( REGINA_EOL, fp );
 128       fflush( fp );
 129    }
 130 }
 131
 132 void traceerror( tsd_t *TSD, const treenode *thisptr, int RC )
 133 {
 134    streng *message;
 135
 136    if ( ( TSD->trace_stat == 'N' ) || ( TSD->trace_stat == 'F' ) )
 137       traceline( TSD, thisptr, 'C', 0 );
 138
 139    if ( TSD->trace_stat != 'O' )
 140    {
 141       message = Str_makeTSD( 20 + sizeof( int ) * 3 ) ;
 142       message->len = sprintf( message->value, "       +++ RC=%d +++", RC );
 143
 144       printout( TSD, message );
 145       Free_stringTSD( message );
 146    }
 147 }
 148
 149 void tracecompound( tsd_t *TSD, const streng *stem, int length,
 150                     const streng *index, char trch )
 151 {
 152    streng *message;
 153    tra_tsd_t *tt;
 154    int indent;
 155
 156    tt = (tra_tsd_t *)TSD->tra_tsd;
 157    if ( tt->traceflag || ( TSD->trace_stat != 'I' ) || tt->quiet )
 158       return;
 159
 160    indent = TSD->systeminfo->cstackcnt + TSD->systeminfo->ctrlcounter;
 161    message = Str_makeTSD( stem->len + index->len + 30 + indent );
 162
 163    sprintf( tt->tracestr, "       >%c> %%%ds  \"%%.%ds.%%.%ds\"",
 164                           trch, indent, length, index->len );
 165    message->len = sprintf( message->value, tt->tracestr,
 166                                            "", stem->value, index->value );
 167
 168    printout( TSD, message );
 169
 170    Free_stringTSD( message );
 171 }
 172
 173 void starttrace( const tsd_t *TSD )
 174 {
 175    tra_tsd_t *tt;
 176
 177    tt = (tra_tsd_t *)TSD->tra_tsd;
 178    tt->traceflag = 0;
 179    tt->notnow = 1;
 180 }
 181
 182 static void tracemsg( tsd_t *TSD )
 183 {
 184    streng *message;
 185    const streng *msg;
 186
 187    msg = errortext( TSD, 0, 3, 0, 0 );
 188    message = Str_makeTSD( 12 + Str_len( msg ) );
 189    Str_catstrTSD( message, "       +++ " );
 190    Str_catTSD( message, msg );
 191    printout( TSD, message );
 192    Free_stringTSD( message );
 193 }
 194
 195 int intertrace( tsd_t *TSD )
 196 {
 197    streng *str=NULL;
 198    int retvalue1,rc;
 199    tra_tsd_t *tt;
 200
 201    tt = (tra_tsd_t *)TSD->tra_tsd;
 202
 203    if ( tt->intercount )
 204    {
 205       tt->intercount -= 1;
 206       if ( tt->intercount == 0 )
 207       {
 208          tt->quiet = 0;
 209          tt->traceflag = 0;
 210       }
 211       else
 212          return 0;
 213    }
 214
 215    if ( tt->traceflag )
 216       return 0;
 217
 218    if ( tt->notnow == 1 )
 219    {
 220       tt->notnow = 2;
 221       return 0;
 222    }
 223    else if ( tt->notnow == 2 )
 224    {
 225       tt->notnow = 0;
 226       tracemsg( TSD );
 227    }
 228    tt->traceflag = 1;
 229    retvalue1 = -1;
 230
 231    for ( ; retvalue1 < 0; )
 232    {
 233       rc = HOOK_GO_ON;
 234       if ( TSD->systeminfo->hooks & HOOK_MASK( HOOK_TRCIN ) )
 235          rc = hookup_input( TSD, HOOK_TRCIN, &str );
 236
 237       if ( rc == HOOK_GO_ON )
 238          str = readkbdline( TSD );
 239
 240       if ( str->len == 0 )
 241       {
 242          tt->traceflag = 0;
 243          retvalue1 = 0;
 244       }
 245
 246       if ( ( Str_len( str ) == 1 ) && (str->value[0] == '=' ) )
 247       {
 248          tt->traceflag = 0;
 249          retvalue1 = 1;
 250       }
 251       else if ( str->len )
 252       {
 253          dointerpret( TSD, str );
 254          if ( !TSD->systeminfo->interactive )
 255          {
 256             tt->intercount = tt->quiet = 0;
 257             return 0;
 258          }
 259          if ( tt->intercount )
 260          {
 261             if ( tt->quiet )
 262                tt->traceflag = 1;
 263             else
 264                tt->traceflag = 0;
 265             return 0;
 266          }
 267       }
 268    }
 269
 270    return retvalue1;
 271 }
 272
 273 void tracenumber( tsd_t *TSD, const num_descr *num, char type )
 274 {
 275    char tmpch;
 276    streng *message,*tmpstr;
 277    tra_tsd_t *tt;
 278    num_descr nd;
 279    int indent;
 280
 281    tmpch = TSD->currlevel->tracestat;
 282    if ( ( tmpch != 'I' ) && ( tmpch != 'R' ) )
 283       return;
 284
 285    tt = (tra_tsd_t *)TSD->tra_tsd;
 286    if ( tt->traceflag || tt->quiet )
 287       return;
 288
 289    memset( &nd, 0, sizeof( num_descr ) );
 290    descr_copy( TSD, num, &nd );
 291    tmpstr = str_norm( TSD, &nd, NULL );
 292    indent = TSD->systeminfo->cstackcnt + TSD->systeminfo->ctrlcounter;
 293    message = Str_makeTSD( 30 + indent + tmpstr->len );
 294    sprintf( tt->tracestr, "       >%%c> %%%ds  \"%%.%ds\"",
 295                           indent, tmpstr->len );
 296    message->len = sprintf( message->value, tt->tracestr,
 297                                            type, "", tmpstr->value );
 298    printout( TSD, message );
 299    if ( nd.num != NULL )
 300       FreeTSD( nd.num );
 301    Free_stringTSD( message );
 302    Free_stringTSD( tmpstr );
 303 }
 304
 305 void tracebool( tsd_t *TSD, int value, char type )
 306 {
 307    char tmpch;
 308    streng *message;
 309    tra_tsd_t *tt;
 310    int indent;
 311
 312    tmpch = TSD->currlevel->tracestat;
 313    if ( ( tmpch != 'I' ) && ( tmpch != 'R' ) )
 314       return;
 315
 316    tt = (tra_tsd_t *)TSD->tra_tsd;
 317    if ( tt->traceflag || tt->quiet )
 318       return;
 319
 320    indent = TSD->systeminfo->cstackcnt + TSD->systeminfo->ctrlcounter;
 321    message = Str_makeTSD( 35 + indent );
 322    sprintf( tt->tracestr, "       >%%c> %%%ds  \"%%d\"",
 323                           indent );
 324    message->len = sprintf( message->value, tt->tracestr,
 325                                            type, "", value );
 326    printout( TSD, message );
 327    Free_stringTSD( message );
 328 }
 329
 330 void tracevalue( tsd_t *TSD, const streng *str, char type )
 331 {
 332    char tmpch;
 333    streng *message;
 334    tra_tsd_t *tt;
 335    int indent;
 336
 337    /*
 338     * ANSI 8.3.17 requires placeholders in PARSE to be traced with TRACE R
 339     */
 340    tmpch = TSD->currlevel->tracestat;
 341    if ( ( tmpch != 'I' ) && ( tmpch != 'R' ) )
 342       return;
 343
 344    tt = (tra_tsd_t *)TSD->tra_tsd;
 345    if ( tt->traceflag || tt->quiet )
 346       return;
 347
 348    indent = TSD->systeminfo->cstackcnt + TSD->systeminfo->ctrlcounter;
 349    message = Str_makeTSD( str->len + 30 + indent );
 350    sprintf( tt->tracestr, "       >%%c> %%%ds  \"%%.%ds\"",
 351                           indent, str->len );
 352    message->len = sprintf( message->value, tt->tracestr,
 353                                            type, "", str->value );
 354    printout( TSD, message );
 355    Free_stringTSD( message );
 356 }
 357
 358 void traceline( tsd_t *TSD, const treenode *thisptr, char tch, int offset )
 359 {
 360    streng *srcstr;
 361    streng *message;
 362    tra_tsd_t *tt;
 363    int indent;
 364
 365    tt = (tra_tsd_t *)TSD->tra_tsd;
 366    if ( tt->traceflag || tt->quiet )
 367       return;
 368
 369    if ( ( thisptr->charnr < 0 ) || ( thisptr->lineno < 0 ) )
 370       return;
 371
 372    switch ( tch )
 373    {
 374       case 'I':
 375       case 'R':
 376       case 'A':
 377          break; /* Oh yes, break the IRA ;-) */
 378
 379       case 'L':
 380          if ( thisptr->type == X_LABEL )
 381             break;
 382          return;
 383
 384       case 'C':
 385          if ( ( thisptr->type == X_COMMAND )
 386            || ( ( thisptr->type == X_ADDR_N ) && thisptr->p[0] ) )
 387             break;
 388          return;
 389
 390       default:
 391          return;
 392    }
 393
 394    srcstr = getsourceline( TSD, thisptr->lineno, thisptr->charnr,
 395                                                      &TSD->systeminfo->tree );
 396
 397    indent = TSD->systeminfo->cstackcnt + TSD->systeminfo->ctrlcounter;
 398    message = Str_makeTSD( indent + 20 + srcstr->len + offset );
 399    if ( thisptr->lineno == tt->lasttracedline )
 400    {
 401       sprintf( tt->tracestr, "       *-* %%%ds%%.%ds",
 402                              indent + offset, srcstr->len );
 403       message->len = sprintf( message->value, tt->tracestr,
 404                                               "", srcstr->value );
 405    }
 406    else
 407    {
 408       sprintf( tt->tracestr, "%%6d *-* %%%ds%%.%ds",
 409                              indent + offset, srcstr->len );
 410       message->len = sprintf( message->value, tt->tracestr,
 411                                               thisptr->lineno, "", srcstr->value );
 412    }
 413
 414    printout( TSD, message );
 415    tt->lasttracedline = thisptr->lineno;
 416    Free_stringTSD( message );
 417    Free_stringTSD( srcstr );
 418 }
 419
 420 void traceback( tsd_t *TSD )
 421 {
 422    sysinfo ss;
 423    streng *message;
 424    streng *srcline;
 425    nodeptr ptr;
 426    int i,j,linesize=128,indent;
 427    tra_tsd_t *tt;
 428
 429    tt = (tra_tsd_t *)TSD->tra_tsd;
 430    /*
 431     * Allocate enough space for one line and control stuff. Count below
 432     * characters for the needed size. Beware of the computed format
 433     * entry.
 434     */
 435    indent = TSD->systeminfo->cstackcnt + TSD->systeminfo->ctrlcounter;
 436    message = Str_makeTSD( linesize + indent * 3 + 20 );
 437    if ( TSD->currentnode )
 438    {
 439       srcline = getsourceline( TSD,
 440                                TSD->currentnode->lineno,
 441                                TSD->currentnode->charnr,
 442                                &TSD->systeminfo->tree );
 443       if ( srcline->len > linesize )
 444       {
 445          Free_stringTSD( message );
 446          linesize = srcline->len;
 447          message = Str_makeTSD( linesize + indent * 3 + 20 );
 448       }
 449       sprintf( tt->tracefmt, "%%6d +++ %%%ds%%.%ds",
 450                              indent * 3, srcline->len );
 451       message->len = sprintf( message->value, tt->tracefmt,
 452                                               TSD->currentnode->lineno, "",
 453                                                              srcline->value );
 454       printout( TSD, message );
 455       Free_stringTSD( srcline );
 456    }
 457
 458    j = indent;
 459    for ( ss = TSD->systeminfo; ss; ss = ss->previous )
 460    {
 461       for ( i = ss->cstackcnt - 1; i >= 0; i-- )
 462       {
 463          ptr = ss->callstack[i];
 464          if ( !ptr )
 465             continue;
 466
 467          srcline = getsourceline( TSD,
 468                                   ptr->lineno,
 469                                   ptr->charnr,
 470                                   &ss->tree );
 471          if ( srcline->len > linesize )
 472          {
 473             Free_stringTSD( message );
 474             linesize = srcline->len;
 475             message = Str_makeTSD( linesize + indent * 3 + 20 );
 476          }
 477
 478          j--;
 479          if ( ( j > 12 ) && get_options_flag( TSD->currlevel, EXT_PRUNE_TRACE ) )
 480             sprintf( tt->tracefmt, "%%6d +++ [...] %%%ds%%.%ds",
 481                                    30, srcline->len );
 482          else
 483             sprintf( tt->tracefmt, "%%6d +++ %%%ds%%.%ds",
 484                                    j * 3, srcline->len );
 485          message->len = sprintf( message->value, tt->tracefmt,
 486                                                  ptr->lineno, "",
 487                                                              srcline->value );
 488          printout( TSD, message );
 489          Free_stringTSD( srcline );
 490       }
 491    }
 492    Free_stringTSD( message );
 493 }
 494
 495 void queue_trace_char( const tsd_t *TSD, char ch2 )
 496 {
 497    tra_tsd_t *tt;
 498
 499    tt = (tra_tsd_t *)TSD->tra_tsd;
 500    if ( tt->bufptr0 < 32 )
 501       tt->buf0[tt->bufptr0++] = ch2;
 502    else
 503       exiterror( ERR_INTERPRETER_FAILURE, 1, __FILE__, __LINE__,
 504                                                "too many tracechars queued" );
 505 }
 506
 507 void flush_trace_chars( tsd_t *TSD )
 508 {
 509    int cnt;
 510    tra_tsd_t *tt;
 511
 512    tt = (tra_tsd_t *)TSD->tra_tsd;
 513    for ( cnt = 0; cnt < tt->bufptr0; cnt++ )
 514       set_trace_char( TSD, tt->buf0[cnt] );
 515
 516    tt->bufptr0 = 0;
 517 }
 518
 519 void set_trace_char( tsd_t *TSD, char ch2 )
 520 {
 521    ch2 = (char) rx_toupper( ch2 );
 522    switch ( ch2 )
 523    {
 524       case '?':
 525          TSD->systeminfo->interactive = !TSD->systeminfo->interactive;
 526          TSD->currlevel->traceint = (char) TSD->systeminfo->interactive;
 527          if ( TSD->systeminfo->interactive )
 528             starttrace( TSD );
 529          break ;
 530
 531       case 'F':
 532       case 'A':
 533       case 'C':
 534       case 'E':
 535       case 'I':
 536       case 'L':
 537       case 'N':
 538       case 'O':
 539       case 'R':
 540          TSD->currlevel->tracestat = ch2;
 541          break;
 542
 543       default:
 544          exiterror( ERR_INVALID_TRACE, 1, "ACEFILNOR", ch2 );
 545    }
 546
 547    if ( ch2 == 'O' )
 548       TSD->systeminfo->interactive = TSD->currlevel->traceint = 0;
 549    TSD->trace_stat = TSD->currlevel->tracestat;
 550 }
 551
 552 void set_trace( tsd_t *TSD, const streng *setting )
 553 {
 554    int cptr,error;
 555    tra_tsd_t *tt;
 556
 557    if ( myisnumber( TSD, setting ) )
 558    {
 559       cptr = streng_to_int( TSD, setting, &error );
 560       if ( error )
 561          exiterror( ERR_INVALID_INTEGER, 7, tmpstr_of( TSD, setting ) );
 562
 563       /*
 564        * If the number is positive, interactive tracing continues
 565        * for the supplied number of clauses, but no pausing is done.
 566        * If the number is negative, no trace output is inhibited
 567        * (as is the pauses) for the supplied number of clauses.
 568        * If the number is zero, this is the same as TRACE OFF
 569        */
 570       tt = (tra_tsd_t *)TSD->tra_tsd;
 571       if ( cptr == 0 )
 572       {
 573          TSD->currlevel->tracestat = 'O';
 574          TSD->systeminfo->interactive = 0;
 575          TSD->currlevel->traceint = 0;
 576          TSD->trace_stat = TSD->currlevel->tracestat;
 577       }
 578       else if ( cptr > 0 )
 579       {
 580          tt->quiet = 0;
 581          tt->intercount = cptr + 1;
 582       }
 583       else
 584       {
 585          tt->quiet = 1;
 586          tt->intercount = -cptr + 1;
 587       }
 588    }
 589    else
 590    {
 591       for ( cptr = 0; cptr < Str_len( setting ); cptr++ )
 592       {
 593          set_trace_char( TSD, setting->value[cptr] );
 594          if ( rx_isalpha( setting->value[cptr] ) )
 595             return;
 596       }
 597    }
 598 }