nl-debug.c

   1 /* nl-debug.c --- debugging functions for newLISP
   2
   3     Copyright (C) 2008 Lutz Mueller
   4
   5     This program is free software: you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation, either version 3 of the License, or
   8     (at your option) any later version.
   9
  10     This program 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
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 */
  19
  20
  21 #include "newlisp.h"
  22 #include "protos.h"
  23
  24 #ifdef WIN_32
  25 #define fgets win32_fgets
  26 #endif
  27
  28 extern FILE * IOchannel;
  29 extern int evalSilent;
  30
  31 int matchString(char * buffer,  char * string, int * length);
  32 int stringComp(char * buffer, char * string);
  33 int printFunction(CELL * cell);
  34 void getDebuggerInput(char * msg);
  35 void allocateDebugStack(void);
  36
  37 extern SYMBOL * currentFunc;
  38 extern SYMBOL * timerEvent;
  39 extern SYMBOL * symHandler[];
  40 extern int currentSignal;
  41
  42 int currentLevel = 0;
  43 int debugStackIdx = 0;
  44 UINT * debugStack;
  45
  46 char preStr[8] = "#";
  47 char postStr[8] = "#";
  48 char headerStr[16] = "\n-----\n\n";
  49 char footerStr[32] = " s|tep n|ext c|ont q|uit > ";
  50
  51 #define pushDebugStack(A) (*(debugStack + debugStackIdx++) = (UINT)(A))
  52 #define popDebugStack() (*(debugStack + --debugStackIdx))
  53
  54 #define DEBUG_ENTRY "->"
  55 #define DEBUG_EXIT "<-"
  56
  57
  58 void openTrace(void)
  59         {
  60         if(traceFlag) return;
  61         traceFlag = TRUE;
  62         currentFunc = nilSymbol;
  63         debugStackIdx = 0;
  64         allocateDebugStack();
  65         }
  66
  67 void closeTrace(void)
  68         {
  69 /*      printf("closing trace\n"); */
  70         traceFlag = 0;
  71         if(debugStack) free(debugStack);
  72         debugStack = NULL;
  73         }
  74
  75
  76
  77 CELL * p_debug(CELL * params)
  78 {
  79 CELL * result;
  80
  81 openTrace();
  82 result = copyCell(evaluateExpression(params));
  83 closeTrace();
  84
  85 return(result);
  86 }
  87
  88
  89 CELL * p_trace(CELL * params)
  90 {
  91 if(params != nilCell)
  92         {
  93         if(getFlag(params))
  94                 openTrace();
  95         else
  96                 closeTrace();
  97         }
  98
  99 return((traceFlag == 0 ? nilCell : trueCell));
 100 }
 101
 102 CELL * p_traceHighlight(CELL * params)
 103 {
 104 char * pre, * post, * header, * footer;
 105
 106 params = getString(params, &pre);
 107 params = getString(params, &post);
 108
 109 strncpy(preStr, pre, 7);
 110 strncpy(postStr, post, 7);
 111
 112 if(params != nilCell)
 113         {
 114         params = getString(params, &header);
 115         strncpy(headerStr, header, 15);
 116         }
 117
 118 if(params != nilCell)
 119         {
 120         getString(params, &footer);
 121         strncpy(footerStr, footer, 31);
 122         }
 123
 124
 125 return(trueCell);
 126 }
 127
 128
 129 void traceEntry(CELL * cell, CELL * pCell, CELL * args)
 130 {
 131 int defaultFuncFlag = FALSE;
 132
 133 if(traceFlag & (TRACE_IN_ENTRY | TRACE_IN_EXIT | TRACE_DEBUG_NEXT)) return;
 134 traceFlag |= TRACE_IN_ENTRY;
 135
 136 if(traceFlag & TRACE_SIGNAL)
 137         {
 138         traceFlag &= ~TRACE_SIGNAL;
 139         executeSymbol(symHandler[currentSignal - 1], stuffInteger(currentSignal));
 140         traceFlag &= ~TRACE_IN_ENTRY;
 141         return;
 142         }
 143
 144 if(traceFlag & TRACE_SIGINT)
 145         {
 146         traceFlag &= ~TRACE_SIGINT;
 147         longjmp(errorJump, ERR_USER_RESET);
 148         }
 149
 150 if(traceFlag & TRACE_TIMER)
 151         {
 152         traceFlag &= ~TRACE_TIMER;
 153         executeSymbol(timerEvent, NULL);
 154         traceFlag &= ~TRACE_IN_ENTRY;
 155         return;
 156         }
 157
 158 if(debugStackIdx > 1)
 159         {
 160         if(printFunction(cell))
 161                 getDebuggerInput(DEBUG_ENTRY);
 162         if(!traceFlag) return;
 163         }
 164
 165 if(traceFlag & TRACE_DEBUG_NEXT)
 166         {
 167         traceFlag &= ~TRACE_IN_ENTRY;
 168         return;
 169         }
 170
 171 if(pCell->type == CELL_CONTEXT)
 172         {
 173         defaultFuncFlag = TRUE;
 174         currentFunc = translateCreateSymbol(
 175                         ((SYMBOL*)pCell->contents)->name,
 176                         CELL_NIL,
 177                         (SYMBOL*)pCell->contents,
 178                         TRUE);
 179
 180         pCell = (CELL *)currentFunc->contents;
 181         }
 182
 183 if((pCell->type == CELL_LAMBDA || pCell->type == CELL_MACRO)
 184         && args->type == CELL_SYMBOL)
 185         {
 186         if(debugStackIdx == 0) /* startup */
 187                 traceFlag &= ~TRACE_DEBUG_NEXT;
 188
 189         if(!defaultFuncFlag)
 190                 currentFunc = (SYMBOL *)args->contents;
 191         pushDebugStack(recursionCount);
 192         pushDebugStack(currentFunc);
 193         }
 194
 195 traceFlag &= ~TRACE_IN_ENTRY;
 196 }
 197
 198
 199 void traceExit(CELL * result, CELL * cell, CELL * pCell, CELL * args)
 200 {
 201 if(traceFlag & (TRACE_IN_ENTRY | TRACE_IN_EXIT | TRACE_SIGNAL | TRACE_SIGINT | TRACE_TIMER)) return;
 202 traceFlag |= TRACE_IN_EXIT;
 203
 204 if(traceFlag & TRACE_DEBUG_NEXT)
 205         {
 206         if(currentLevel >= recursionCount)
 207                 traceFlag &= ~TRACE_DEBUG_NEXT;
 208         else
 209                 {
 210                 traceFlag &= ~TRACE_IN_EXIT;
 211                 return;
 212                 }
 213         }
 214
 215 if( (pCell->type == CELL_LAMBDA || pCell->type == CELL_MACRO)
 216                 && args->type == CELL_SYMBOL)
 217         {
 218         if((UINT)recursionCount == *(debugStack + debugStackIdx - 2) )
 219                 {
 220                 debugStackIdx -= 2;
 221                 if(debugStackIdx > 0)
 222                         currentFunc = (SYMBOL *)*(debugStack + debugStackIdx - 1);
 223                 if(debugStackIdx == 0)
 224                         traceFlag &= ~TRACE_DEBUG_NEXT;
 225                 }
 226         }
 227
 228 if(printFunction(cell))
 229         {
 230         varPrintf(OUT_CONSOLE, "\nRESULT: ");
 231         printCell(result, TRUE, OUT_CONSOLE);
 232         varPrintf(OUT_CONSOLE, "\n");
 233
 234         if(debugStackIdx > 0)
 235                 {
 236                 getDebuggerInput(DEBUG_EXIT);
 237                 if(!traceFlag) return;
 238                 }
 239         }
 240
 241 if(traceFlag & TRACE_DEBUG_NEXT)
 242         currentLevel = recursionCount;
 243
 244 traceFlag &= ~TRACE_IN_EXIT;
 245 }
 246
 247
 248 void getDebuggerInput(char * msg)
 249 {
 250 char command[MAX_LINE];
 251 char * context;
 252 jmp_buf errorJumpSave;
 253 int resultStackIdxSave;
 254 SYMBOL * contextSave;
 255
 256 while(TRUE)
 257         {
 258
 259         if(currentContext != mainContext)
 260                 context = currentContext->name;
 261         else context = "";
 262
 263
 264         if(!evalSilent)
 265                 varPrintf(OUT_CONSOLE, "\n[%s %d %s]%s", msg, recursionCount, context, footerStr);
 266         else evalSilent = FALSE;
 267
 268         fgets(command, MAX_LINE - 1, IOchannel);
 269
 270         if( (strcmp(command, "n\n") == 0) || (strcmp(command, "n\r\n") == 0))
 271                 {
 272                 traceFlag |= TRACE_DEBUG_NEXT;
 273                 currentLevel = recursionCount;
 274                 break;
 275                 }
 276         else if( (strcmp(command, "s\n") == 0) || (strcmp(command, "s\r\n") == 0))
 277                 {
 278                 traceFlag &= ~TRACE_DEBUG_NEXT;
 279                 break;
 280                 }
 281         else if( (strcmp(command, "q\n") == 0) || (strcmp(command, "q\r\n") == 0))
 282                 {
 283                 closeTrace();
 284                 longjmp(errorJump, ERR_USER_RESET);
 285                 }
 286         else if( (strcmp(command, "c\n") == 0) || (strcmp(command, "c\r\n") == 0))
 287                 {
 288                 closeTrace();
 289                 break;
 290                 }
 291
 292         resultStackIdxSave = resultStackIdx;
 293         memcpy(errorJumpSave, errorJump, sizeof(jmp_buf));
 294         contextSave = currentContext;
 295         currentContext = currentFunc->context;
 296         if(setjmp(errorJump))
 297                 {
 298                 cleanupResults(resultStackIdxSave);
 299                 goto DEBUG_EVAL_END;
 300                 }
 301
 302         executeCommandLine(command, OUT_CONSOLE, NULL);
 303
 304         DEBUG_EVAL_END:
 305         currentContext = contextSave;
 306         memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
 307         }
 308 }
 309
 310
 311 int printFunction(CELL * cell)
 312 {
 313 char * funcStr;
 314 char * expStr;
 315 int start, length;
 316 STREAM strStream;
 317
 318 if(currentFunc == nilSymbol) return FALSE;
 319
 320 openStrStream(&strStream, MAX_STRING, 0);
 321 printSymbol(currentFunc, (UINT)&strStream);
 322 length = strlen(strStream.buffer);
 323 funcStr = allocMemory(length + 1);
 324 memcpy(funcStr, strStream.buffer, length + 1);
 325 *(funcStr + length) = 0;
 326
 327 openStrStream(&strStream, MAX_STRING, 0);
 328 printCell((CELL *)cell, TRUE, (UINT)&strStream);
 329 expStr = strStream.buffer;
 330 start = matchString(funcStr, expStr, &length);
 331 closeStrStream(&strStream);
 332
 333 if(start == -1 || length == 0)
 334         {
 335         free(funcStr);
 336         return FALSE;
 337         }
 338
 339 varPrintf(OUT_CONSOLE, headerStr);
 340
 341 expStr = allocMemory(length + 1);
 342 strncpy(expStr, funcStr + start, length);
 343 *(expStr + length) = 0;
 344 *(funcStr + start) = 0;
 345
 346 varPrintf(OUT_CONSOLE, "%s%s%s%s%s",
 347         funcStr, preStr, expStr, postStr, funcStr + start + length);
 348
 349 free(funcStr);
 350
 351 return TRUE;
 352 }
 353
 354
 355 void allocateDebugStack(void)
 356 {
 357 debugStack = (UINT *)allocMemory(MAX_CPU_STACK * 2 * sizeof(UINT));
 358 }
 359
 360 /* search for a string skipping white space
 361 */
 362 int matchString(char * buffer,  char * string, int * length)
 363 {
 364 int position, flag;
 365
 366 /* strip leading white space */
 367 while(*string <= ' ' && *string > 0) string++;
 368
 369 position = flag = 0;
 370
 371 while(*buffer)
 372         {
 373         if(*buffer > ' ')
 374                 if((*length = stringComp(buffer, string)) > 0)
 375                         {
 376                         flag = TRUE;
 377                         break;
 378                         }
 379         position++;
 380         buffer++;
 381         }
 382
 383 if(!flag) return(-1);
 384 return(position);
 385 }
 386
 387
 388 /* compare strings skipping white space
 389 */
 390 int stringComp(char * buffer, char * string)
 391 {
 392 char * start;
 393
 394 start = buffer;
 395 while(*string && *buffer)
 396         {
 397         if(*string > ' ')
 398                 {
 399                 if(*buffer > ' ')
 400                         {
 401                         if(*string != *buffer) return(0);
 402                         string++;
 403                         buffer++;
 404                         }
 405                 else buffer++;
 406                 }
 407         else string++;
 408         }
 409
 410 if(*string == 0)
 411         return(buffer - start);
 412
 413 return(0);
 414 }
 415
 416
 417 /* eof */
 418
 419