home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / AWK / AWK320SR.ZIP / AWKDEBUG.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-04-28  |  8.6 KB  |  361 lines
  1. /*
  2.  * Awk debug printing routines
  3.  *
  4.  * Copyright (C) 1988, 1989, 1990, 1991 by Rob Duff
  5.  * All rights reserved
  6.  */
  7.  
  8. #include <stdio.h>
  9.  
  10. #include "awk.h"
  11.  
  12. #define DEBUG 1
  13.  
  14. #if DEBUG
  15.  
  16. char *optab[] ={
  17.     "END", 
  18.     "EQ", "NE", "LT", "GT", "LE", "GE",
  19.     "MUL", "DIV", "MOD", "ADD", "SUB",
  20.     "NEG", "NOT", "NUM", "_PRE ","PRE ", "_POST", "POST",
  21.     "IS", "IN", "MAT", "CAT",
  22.     "RAND", "SYS", "LEN", 
  23.     "COS", "EXP", "INT", "LOG", "SIN", "SQRT", 
  24.     "ATAN2", "POW",
  25.     "DOLAR", "FIELD", "PLUCK", 
  26.     "VAR", "FETCH", "AUTO", "BUILT", 
  27.     "SELECT", "LOAD",
  28.     "_STORE", "STORE", "_COPY", "COPY",
  29.     "DUP", "SWAP", "UNDER", "DROP",
  30.     "CALL", "USER", "RETURN",
  31.     "JUMP", "FJMP", "TJMP", "AJMP", "OJMP", "IJMP",
  32.     "CCON", "ICON", "LCON", "DCON",
  33.     "SCON", "RCON", "FCON", "LINE"
  34. };
  35.  
  36. char *calltab[] ={
  37.     "none", "next", "exit", "print", "printf", "getline", 
  38.     "srand", "gsub", "lsub", "join", "split", "delete", 
  39.     "index", "match", "substr", "sprintf", "open", 
  40.     "create", "append", "close", "system"
  41. };
  42.  
  43. char *class[] ={"ACTUAL" , "FORMAL" };
  44. char *types[] ={"SHORT", "LONG", "DOUBLE", "NUMBER", "STRING",
  45.                 "REGEXP", "ARRAY" , "STACK" , "FILES" , "FIELD ",
  46.                 "SIMPLE", "BUILTIN" };
  47.  
  48. char *jumps[] = { 
  49.     "NORMAL","CONTINUE","BREAK","DONE","MARK","FOR","ELSE","WHILE" };
  50.  
  51. char *print_ccl(char *ccl)
  52. {
  53.     int     i;
  54.  
  55.     for (i = 1; i < 256; i++) {
  56.         if (ccl[(i>>3)&037] & (1<<(i&7))) {
  57.             if (i < ' ') {
  58.                 switch (i) {
  59.                 case '\b':
  60.                     printf("\\b");
  61.                     break;
  62.                 case '\f':
  63.                     printf("\\f");
  64.                     break;
  65.                 case '\n':
  66.                     printf("\\n");
  67.                     break;
  68.                 case '\r':
  69.                     printf("\\r");
  70.                     break;
  71.                 case '\t':
  72.                     printf("\\t");
  73.                     break;
  74.                 default:
  75.                     printf("\\%03o", i);
  76.                 }
  77.             }
  78.             else
  79.                 printf("%c", i);
  80.         }
  81.     }
  82.     return ccl+32;
  83. }
  84.  
  85. char *print_re(char *pp)
  86. {
  87.     register int c;
  88.  
  89.     while ((c = *pp++) != R_END) {
  90.         switch (c) {
  91.         case R_BOL:       fprintf(stderr, "^"); break;
  92.         case R_EOL:       fprintf(stderr, "$"); break;
  93.         case R_ANY:       fprintf(stderr, "."); break;
  94.         case R_CLASS:
  95.             fprintf(stderr, "[");
  96.             pp = print_ccl(pp);
  97.             fprintf(stderr, "]");
  98.             break;
  99.         case R_NCLAS:
  100.             fprintf(stderr, "[^");
  101.             pp = print_ccl(pp);
  102.             fprintf(stderr, "]");
  103.             break;
  104.         case R_BAR:
  105.             pp = print_re(pp + 5);
  106.             fprintf(stderr, "|");
  107.             pp = print_re(pp);
  108.             break;
  109.         case R_STAR:
  110.             fprintf(stderr, "(");
  111.             pp = print_re(pp + 2);
  112.             fprintf(stderr, ")*");
  113.             break;
  114.         case R_PLUS:
  115.             fprintf(stderr, "(");
  116.             pp = print_re(pp + 2);
  117.             fprintf(stderr, ")+");
  118.             break;
  119.         case R_QUEST:
  120.             fprintf(stderr, "(");
  121.             pp = print_re(pp + 2);
  122.             fprintf(stderr, ")?");
  123.             break;
  124.         case R_RANGE:
  125.             c = *pp++;
  126.             fprintf(stderr, "%c-%c", c, *pp++);
  127.             break;
  128.         case R_CHAR:
  129.             c = *pp++;
  130.             fprintf(stderr, "\\%03o", c);
  131.             break;
  132.         case '$':
  133.         case '^':
  134.         case '.':
  135.         case '/':
  136.         case '\\':
  137.         case '*':
  138.         case '+':
  139.         case '?':
  140.         case '(':
  141.         case ')':
  142.         case '[':
  143.         case ']':
  144.             fprintf(stderr, "\\");
  145.         default:
  146.             fprintf(stderr, "%c", c);
  147.             break;
  148.         }
  149.     }
  150.     return pp;
  151. }
  152.  
  153. void print_code(char *st)
  154. {
  155.     char    *cp;
  156.  
  157.     cp = st;
  158.     while (*cp != C_END)
  159.         cp = print_op(st, cp);
  160.     print_op(st, cp);
  161.     fprintf(stderr, "\n");
  162. }
  163.  
  164. char *print_op(char *st, char *cp)
  165. {
  166.     int     op, i;
  167.     long    l;
  168.     char    *c;
  169.     double  d;
  170.     FYLE    *f;
  171.     IDENT   *v;
  172.  
  173.     i = (int)(cp - st);
  174.     op = *cp++;
  175.     fprintf(stderr, "%04X:%04d %04d %-8s", (int)st, i, 
  176.         (int)(stacktop - stackptr), optab[op]);
  177.     switch(op) {
  178.     case C_CALL:
  179.         i = *cp++;
  180.         fprintf(stderr, "%s,%3d", calltab[i], *((char*)cp)++);
  181.         break;
  182.     case C_USER:
  183.         v = *((IDENT**)cp)++;
  184.         i = *cp++;
  185.         fprintf(stderr, "%s,%3d", v->vname, i);
  186.         break;
  187.     case C_JUMP:
  188.     case C_FJMP:
  189.     case C_TJMP:
  190.     case C_IJMP:
  191.     case C_AJMP:
  192.     case C_OJMP:
  193.         i = *((short*)cp)++;
  194.         fprintf(stderr, "%04d", i + (int)(cp - st));
  195.         break;
  196.     case C_LINE:
  197.         c = *((char**)cp)++;
  198.         i = *((short*)cp)++;
  199.         fprintf(stderr, "%d  %s", i, c);
  200.         break;
  201.     case C_CCON:
  202.         i = *((char*)cp)++;
  203.         fprintf(stderr, "%d", i);
  204.         break;
  205.     case C_AUTO:
  206.     case C_ICON:
  207.         i = *((short*)cp)++;
  208.         fprintf(stderr, "%d", i);
  209.         break;
  210.     case C_LCON:
  211.         l = *((long*)cp)++;
  212.         fprintf(stderr, "%ld", l);
  213.         break;
  214.     case C_DCON:
  215.         d = *((double*)cp)++;
  216.         fprintf(stderr, "%.10g", d);
  217.         break;
  218.     case C_FCON:
  219.         f = *((FYLE**)cp)++;
  220.         fprintf(stderr, "%s", f->fname+1);
  221.         break;
  222.     case C_RCON:
  223.         c = *((char**)cp)++;
  224.         fprintf(stderr, "/");
  225.         print_re(c);
  226.         fprintf(stderr, "/");
  227.         break;
  228.     case C_SCON:
  229.         c = (*((char**)cp)++)+1;
  230.         fprintf(stderr, "\"%s\"", c);
  231.         break;
  232.     case C_FIELD:
  233.     case C_PLUCK:
  234.         i = (int)((*((ITEM**)cp)++) - fieldtab);
  235.         fprintf(stderr, "$%d", i);
  236.         break;
  237.     case C_ADDR:
  238.     case C_BUILT:
  239.     case C_FETCH:
  240.         v = lookfor((*((ITEM**)cp)++));
  241.         fprintf(stderr, "%s", v->vname);
  242.         break;
  243.     case C_PRE:
  244.     case C_POST:
  245.     case C_STORE:
  246.     case C_COPY:
  247.     case C__PRE:
  248.     case C__POST:
  249.     case C__STORE:
  250.     case C__COPY:
  251.         i = *((char*)cp)++;
  252.         if (i != 0) {
  253.             fprintf(stderr, "%s", optab[i]);
  254.             break;
  255.         }
  256.     }
  257.     fprintf(stderr, "\n");
  258.     return cp;
  259. }
  260.  
  261. void print_one(char *sp, ITEM *ip)
  262. {
  263.     fprintf(stderr, "%s: ", sp);
  264.     print_item(ip);
  265.     fprintf(stderr, "\n");
  266. }
  267.  
  268. void print_two(char *sp, ITEM *ip1, ITEM *ip2)
  269. {
  270.     fprintf(stderr, "%s: ", sp);
  271.     print_item(ip1);
  272.     print_item(ip2);
  273.     fprintf(stderr, "\n");
  274. }
  275.  
  276. void print_element(char *sp, ELEMENT *ep)
  277. {
  278.     fprintf(stderr, "%s ", sp);
  279.     if (ep == NULL)
  280.         fprintf(stderr, "<NULL>");
  281.     else {
  282.         printf("[%Fs] ", ep->aindex+1);
  283.         print_item((ITEM*)ep);
  284.     }
  285.     fprintf(stderr, "\n");
  286. }
  287.  
  288. void print_item(ITEM *ip)
  289. {
  290.     fprintf(stderr, "%s %s ", class[ip->sclass], types[ip->stype]);
  291.     print_value(ip);
  292. }
  293.  
  294. void print_value(ITEM *ip)
  295. {
  296.     int     i;
  297.     FYLE    *fp;
  298.     ELEMENT *ep;
  299.  
  300.     switch (ip->stype) {
  301.     case S_SHORT:
  302.         fprintf(stderr, "%d ", ip->svalue.ival);
  303.         break;
  304.     case S_LONG:
  305.         fprintf(stderr, "%ld ", ip->svalue.lval);
  306.         break;
  307.     case S_DOUBLE:
  308.         fprintf(stderr, "%.6g", ip->svalue.dval);
  309.         fprintf(stderr, " ");
  310.         break;
  311.     case S_NUMBER:
  312.         if (ip->sstr == nullstr) {
  313.             fprintf(stderr, "<DEFAULT>");
  314.             break;
  315.         }
  316.     case S_STRING:
  317.         fprintf(stderr, "\"%Fs\" ", ip->sstr+1);
  318.         break;
  319.     case S_FILES:
  320.         fp = ip->svalue.fptr;
  321.         fprintf(stderr, "%Fs(%d)x %4X", fp->fname+1, (int)(fp-files), fp->ffyle);
  322.         break;
  323.     case S_FIELD:
  324.         i = (int)(ip->svalue.sptr - fieldtab);
  325.         fprintf(stderr, "$%d ", i);
  326.         print_item(ip->svalue.sptr);
  327.         break;
  328.     case S_SIMPLE:
  329.     case S_BUILT:
  330.         i = (int)(ip->svalue.sptr - vartab);
  331.         fprintf(stderr, "%d", i);
  332.         print_item(ip->svalue.sptr);
  333.         break;
  334.     case S_STACK:
  335.         i = (int)(ip->svalue.sptr - stacktop);
  336.         fprintf(stderr, "%d ", i);
  337.         print_item(ip->svalue.sptr);
  338.         break;
  339.     case S_ARRAY:
  340.         ep = ip->svalue.aptr;
  341.         fprintf(stderr, "\n");
  342.         while (ep != NULL) {
  343.             print_element("       ", ep);
  344.             ep = ep->anext;
  345.         }
  346.         break;
  347.     default:
  348.         fprintf(stderr, "%04X ", ip->svalue.ival);
  349.         break;
  350.     }
  351. }
  352.  
  353. void print_label(char *str, int label)
  354. {
  355.     printf("%s %d(%d)\n", str, labels[label].label, labels[label].where);
  356. }
  357.  
  358. #endif
  359.  
  360.  
  361.