dump.c

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