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