dump.c

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