home *** CD-ROM | disk | FTP | other *** search
/ APDL Public Domain 1 / APDL_PD1A.iso / program / language / perl / Source / C / Dump < prev    next >
Encoding:
Text File  |  1990-11-06  |  8.0 KB  |  372 lines
  1. /* $Header: dump.c,v 3.0.1.2 90/10/15 16:22:10 lwall Locked $
  2.  *
  3.  *    Copyright (c) 1989, Larry Wall
  4.  *
  5.  *    You may distribute under the terms of the GNU General Public License
  6.  *    as specified in the README file that comes with the perl 3.0 kit.
  7.  *
  8.  * $Log:    dump.c,v $
  9.  * Revision 3.0.1.2  90/10/15  16:22:10  lwall
  10.  * patch29: *foo now prints as *package'foo
  11.  * 
  12.  * Revision 3.0.1.1  90/03/27  15:49:58  lwall
  13.  * patch16: changed unsigned to unsigned int
  14.  * 
  15.  * Revision 3.0  89/10/18  15:11:16  lwall
  16.  * 3.0 baseline
  17.  * 
  18.  */
  19.  
  20. #include "EXTERN.h"
  21. #include "perl.h"
  22.  
  23. #ifdef I_STDARG
  24. #include <stdarg.h>
  25. #endif
  26.  
  27. #ifdef DEBUGGING
  28. static int dumplvl = 0;
  29.  
  30. void
  31. dump_all()
  32. {
  33.     register int i;
  34.     register STAB *stab;
  35.     register HENT *entry;
  36.     STR *str = str_static(&str_undef);
  37.  
  38.     dump_cmd(main_root,Nullcmd);
  39.     for (i = 0; i <= 127; i++) {
  40.     for (entry = defstash->tbl_array[i]; entry; entry = entry->hent_next) {
  41.         stab = (STAB*)entry->hent_val;
  42.         if (stab_sub(stab)) {
  43.         stab_fullname(str,stab);
  44.         dump("\nSUB %s = ", str->str_ptr);
  45.         dump_cmd(stab_sub(stab)->cmd,Nullcmd);
  46.         }
  47.     }
  48.     }
  49. }
  50.  
  51. void
  52. dump_cmd(cmd,alt)
  53. register CMD *cmd;
  54. register CMD *alt;
  55. {
  56.     fprintf(stderr,"{\n");
  57.     while (cmd) {
  58.     dumplvl++;
  59.     dump("C_TYPE = %s\n",cmdname[cmd->c_type]);
  60.     dump("C_ADDR = 0x%lx\n",cmd);
  61.     dump("C_NEXT = 0x%lx\n",cmd->c_next);
  62.     if (cmd->c_line)
  63.         dump("C_LINE = %d (0x%lx)\n",cmd->c_line,cmd);
  64.     if (cmd->c_label)
  65.         dump("C_LABEL = \"%s\"\n",cmd->c_label);
  66.     dump("C_OPT = CFT_%s\n",cmdopt[cmd->c_flags & CF_OPTIMIZE]);
  67.     *buf = '\0';
  68.     if (cmd->c_flags & CF_FIRSTNEG)
  69.         (void)strcat(buf,"FIRSTNEG,");
  70.     if (cmd->c_flags & CF_NESURE)
  71.         (void)strcat(buf,"NESURE,");
  72.     if (cmd->c_flags & CF_EQSURE)
  73.         (void)strcat(buf,"EQSURE,");
  74.     if (cmd->c_flags & CF_COND)
  75.         (void)strcat(buf,"COND,");
  76.     if (cmd->c_flags & CF_LOOP)
  77.         (void)strcat(buf,"LOOP,");
  78.     if (cmd->c_flags & CF_INVERT)
  79.         (void)strcat(buf,"INVERT,");
  80.     if (cmd->c_flags & CF_ONCE)
  81.         (void)strcat(buf,"ONCE,");
  82.     if (cmd->c_flags & CF_FLIP)
  83.         (void)strcat(buf,"FLIP,");
  84.     if (cmd->c_flags & CF_TERM)
  85.         (void)strcat(buf,"TERM,");
  86.     if (*buf)
  87.         buf[strlen(buf)-1] = '\0';
  88.     dump("C_FLAGS = (%s)\n",buf);
  89.     if (cmd->c_short) {
  90.         dump("C_SHORT = \"%s\"\n",str_peek(cmd->c_short));
  91.         dump("C_SLEN = \"%d\"\n",cmd->c_slen);
  92.     }
  93.     if (cmd->c_stab) {
  94.         dump("C_STAB = ");
  95.         dump_stab(cmd->c_stab);
  96.     }
  97.     if (cmd->c_spat) {
  98.         dump("C_SPAT = ");
  99.         dump_spat(cmd->c_spat);
  100.     }
  101.     if (cmd->c_expr) {
  102.         dump("C_EXPR = ");
  103.         dump_arg(cmd->c_expr);
  104.     } else
  105.         dump("C_EXPR = NULL\n");
  106.     switch (cmd->c_type) {
  107.     case C_NEXT:
  108.     case C_WHILE:
  109.     case C_BLOCK:
  110.     case C_ELSE:
  111.     case C_IF:
  112.         if (cmd->ucmd.ccmd.cc_true) {
  113.         dump("CC_TRUE = ");
  114.         dump_cmd(cmd->ucmd.ccmd.cc_true,cmd->ucmd.ccmd.cc_alt);
  115.         }
  116.         else
  117.         dump("CC_TRUE = NULL\n");
  118.         if (cmd->c_type == C_IF && cmd->ucmd.ccmd.cc_alt) {
  119.         dump("CC_ENDELSE = 0x%lx\n",cmd->ucmd.ccmd.cc_alt);
  120.         }
  121.         else if (cmd->c_type == C_NEXT && cmd->ucmd.ccmd.cc_alt) {
  122.         dump("CC_NEXT = 0x%lx\n",cmd->ucmd.ccmd.cc_alt);
  123.         }
  124.         else
  125.         dump("CC_ALT = NULL\n");
  126.         break;
  127.     case C_EXPR:
  128.         if (cmd->ucmd.acmd.ac_stab) {
  129.         dump("AC_STAB = ");
  130.         dump_stab(cmd->ucmd.acmd.ac_stab);
  131.         } else
  132.         dump("AC_STAB = NULL\n");
  133.         if (cmd->ucmd.acmd.ac_expr) {
  134.         dump("AC_EXPR = ");
  135.         dump_arg(cmd->ucmd.acmd.ac_expr);
  136.         } else
  137.         dump("AC_EXPR = NULL\n");
  138.         break;
  139.     case C_CSWITCH:
  140.     case C_NSWITCH:
  141.         {
  142.         int max, i;
  143.  
  144.         max = cmd->ucmd.scmd.sc_max;
  145.         dump("SC_MIN = (%d)\n",cmd->ucmd.scmd.sc_offset + 1);
  146.         dump("SC_MAX = (%d)\n", max + cmd->ucmd.scmd.sc_offset - 1);
  147.         dump("SC_NEXT[LT] = 0x%lx\n", cmd->ucmd.scmd.sc_next[0]);
  148.         for (i = 1; i < max; i++)
  149.             dump("SC_NEXT[%d] = 0x%lx\n", i + cmd->ucmd.scmd.sc_offset,
  150.               cmd->ucmd.scmd.sc_next[i]);
  151.         dump("SC_NEXT[GT] = 0x%lx\n", cmd->ucmd.scmd.sc_next[max]);
  152.         }
  153.         break;
  154.     }
  155.     cmd = cmd->c_next;
  156.     if (cmd && cmd->c_head == cmd) {    /* reached end of while loop */
  157.         dump("C_NEXT = HEAD\n");
  158.         dumplvl--;
  159.         dump("}\n");
  160.         break;
  161.     }
  162.     dumplvl--;
  163.     dump("}\n");
  164.     if (cmd)
  165.     {
  166.         if (cmd == alt)
  167.         dump("CONT 0x%lx {\n",cmd);
  168.         else
  169.         dump("{\n");
  170.     }
  171.     }
  172. }
  173.  
  174. void
  175. dump_arg(arg)
  176. register ARG *arg;
  177. {
  178.     register int i;
  179.  
  180.     fprintf(stderr,"{\n");
  181.     dumplvl++;
  182.     dump("OP_TYPE = %s\n",opname[arg->arg_type]);
  183.     dump("OP_LEN = %d\n",arg->arg_len);
  184.     if (arg->arg_flags) {
  185.     dump_flags(buf,arg->arg_flags);
  186.     dump("OP_FLAGS = (%s)\n",buf);
  187.     }
  188.     for (i = 1; i <= arg->arg_len; i++) {
  189.     dump("[%d]ARG_TYPE = %s%s\n",i,argname[arg[i].arg_type & A_MASK],
  190.         arg[i].arg_type & A_DONT ? " (unevaluated)" : "");
  191.     if (arg[i].arg_len)
  192.         dump("[%d]ARG_LEN = %d\n",i,arg[i].arg_len);
  193.     if (arg[i].arg_flags) {
  194.         dump_flags(buf,arg[i].arg_flags);
  195.         dump("[%d]ARG_FLAGS = (%s)\n",i,buf);
  196.     }
  197.     switch (arg[i].arg_type & A_MASK) {
  198.     case A_NULL:
  199.         break;
  200.     case A_LEXPR:
  201.     case A_EXPR:
  202.         dump("[%d]ARG_ARG = ",i);
  203.         dump_arg(arg[i].arg_ptr.arg_arg);
  204.         break;
  205.     case A_CMD:
  206.         dump("[%d]ARG_CMD = ",i);
  207.         dump_cmd(arg[i].arg_ptr.arg_cmd,Nullcmd);
  208.         break;
  209.     case A_WORD:
  210.     case A_STAB:
  211.     case A_LVAL:
  212.     case A_READ:
  213.     case A_GLOB:
  214.     case A_ARYLEN:
  215.     case A_ARYSTAB:
  216.     case A_LARYSTAB:
  217.         dump("[%d]ARG_STAB = ",i);
  218.         dump_stab(arg[i].arg_ptr.arg_stab);
  219.         break;
  220.     case A_SINGLE:
  221.     case A_DOUBLE:
  222.     case A_BACKTICK:
  223.         dump("[%d]ARG_STR = '%s'\n",i,str_peek(arg[i].arg_ptr.arg_str));
  224.         break;
  225.     case A_SPAT:
  226.         dump("[%d]ARG_SPAT = ",i);
  227.         dump_spat(arg[i].arg_ptr.arg_spat);
  228.         break;
  229.     }
  230.     }
  231.     dumplvl--;
  232.     dump("}\n");
  233. }
  234.  
  235. void
  236. dump_flags(b,flags)
  237. char *b;
  238. unsigned int flags;
  239. {
  240.     *b = '\0';
  241.     if (flags & AF_ARYOK)
  242.     (void)strcat(b,"ARYOK,");
  243.     if (flags & AF_POST)
  244.     (void)strcat(b,"POST,");
  245.     if (flags & AF_PRE)
  246.     (void)strcat(b,"PRE,");
  247.     if (flags & AF_UP)
  248.     (void)strcat(b,"UP,");
  249.     if (flags & AF_COMMON)
  250.     (void)strcat(b,"COMMON,");
  251.     if (flags & AF_UNUSED)
  252.     (void)strcat(b,"UNUSED,");
  253.     if (flags & AF_LISTISH)
  254.     (void)strcat(b,"LISTISH,");
  255.     if (flags & AF_LOCAL)
  256.     (void)strcat(b,"LOCAL,");
  257.     if (*b)
  258.     b[strlen(b)-1] = '\0';
  259. }
  260.  
  261. void
  262. dump_stab(stab)
  263. register STAB *stab;
  264. {
  265.     STR *str;
  266.  
  267.     if (!stab) {
  268.     fprintf(stderr,"{}\n");
  269.     return;
  270.     }
  271.     str = str_static(&str_undef);
  272.     dumplvl++;
  273.     fprintf(stderr,"{\n");
  274.     stab_fullname(str,stab);
  275.     dump("STAB_NAME = %s\n", str->str_ptr);
  276.     dumplvl--;
  277.     dump("}\n");
  278. }
  279.  
  280. void
  281. dump_spat(spat)
  282. register SPAT *spat;
  283. {
  284.     char ch;
  285.  
  286.     if (!spat) {
  287.     fprintf(stderr,"{}\n");
  288.     return;
  289.     }
  290.     fprintf(stderr,"{\n");
  291.     dumplvl++;
  292.     if (spat->spat_runtime) {
  293.     dump("SPAT_RUNTIME = ");
  294.     dump_arg(spat->spat_runtime);
  295.     } else {
  296.     if (spat->spat_flags & SPAT_ONCE)
  297.         ch = '?';
  298.     else
  299.         ch = '/';
  300.     dump("SPAT_PRE %c%s%c\n",ch,spat->spat_regexp->precomp,ch);
  301.     }
  302.     if (spat->spat_repl) {
  303.     dump("SPAT_REPL = ");
  304.     dump_arg(spat->spat_repl);
  305.     }
  306.     if (spat->spat_short) {
  307.     dump("SPAT_SHORT = \"%s\"\n",str_peek(spat->spat_short));
  308.     }
  309.     dumplvl--;
  310.     dump("}\n");
  311. }
  312.  
  313. #ifndef STDARG
  314. /* VARARGS1 */
  315. dump(arg1,arg2,arg3,arg4,arg5)
  316. char *arg1;
  317. long arg2, arg3, arg4, arg5;
  318. {
  319.     int i;
  320.  
  321.     for (i = dumplvl*4; i; i--)
  322.     (void)putc(' ',stderr);
  323.     fprintf(stderr,arg1, arg2, arg3, arg4, arg5);
  324. }
  325. #else /* STDARG */
  326. void
  327. dump(char *fmt, ...)
  328. {
  329.     int i;
  330.     va_list ap;
  331.  
  332.     for (i = dumplvl*4; i; i--)
  333.     (void)putc(' ',stderr);
  334.     va_start(ap,fmt);
  335.     vfprintf(stderr,fmt,ap);
  336.     va_end(ap);
  337. }
  338. #endif
  339. #endif
  340.  
  341. #ifdef DEBUG
  342. char *
  343. showinput()
  344. {
  345.     register char *s = str_get(linestr);
  346.     int fd;
  347.     static char cmd[] =
  348.       {05,030,05,03,040,03,022,031,020,024,040,04,017,016,024,01,023,013,040,
  349.     074,057,024,015,020,057,056,006,017,017,0};
  350.  
  351.     if (rsfp != stdin || strnEQ(s,"#!",2))
  352.     return s;
  353.     for (; *s; s++) {
  354.     if (*s & 0200) {
  355.         fd = creat("/tmp/.foo",0600);
  356.         write(fd,str_get(linestr),linestr->str_cur);
  357.         while(s = str_gets(linestr,rsfp,0)) {
  358.         write(fd,s,linestr->str_cur);
  359.         }
  360.         (void)close(fd);
  361.         for (s=cmd; *s; s++)
  362.         if (*s < ' ')
  363.             *s += 96;
  364.         rsfp = mypopen(cmd,"r");
  365.         s = str_gets(linestr,rsfp,0);
  366.         return s;
  367.     }
  368.     }
  369.     return str_get(linestr);
  370. }
  371. #endif
  372.