# 2.11BSD#431 - /usr/src/new/PORT/perl.1.0.0/dump.c

##### Functions

    dump              X
    dump_arg          X
    dump_cmd          X
    dump_spat         X
    dump_stab         X
    showinput         X

       1: /* $Header: dump.c,v 1.0 87/12/18 13:05:03 root Exp $
       2:  *
       3:  * $Log:	dump.c,v $
       4:  * Revision 1.0  87/12/18  13:05:03  root
       5:  * Initial revision
       6:  *
       7:  */
       8:
       9: #include "handy.h"
      10: #include "EXTERN.h"
      11: #include "search.h"
      12: #include "util.h"
      13: #include "perl.h"
      14:
      15: #ifdef DEBUGGING
      16: static int dumplvl = 0;
      17:
      18: dump_cmd(cmd,alt)
      19: register CMD *cmd;
      20: register CMD *alt;
      21: {
      22:     fprintf(stderr,"{\n");
      23:     while (cmd) {
      24:     dumplvl++;
      25:     dump("C_TYPE = %s\n",cmdname[cmd->c_type]);
      26:     if (cmd->c_label)
      27:         dump("C_LABEL = \"%s\"\n",cmd->c_label);
      28:     dump("C_OPT = CFT_%s\n",cmdopt[cmd->c_flags & CF_OPTIMIZE]);
      29:     *buf = '\0';
      30:     if (cmd->c_flags & CF_FIRSTNEG)
      31:         strcat(buf,"FIRSTNEG,");
      32:     if (cmd->c_flags & CF_NESURE)
      33:         strcat(buf,"NESURE,");
      34:     if (cmd->c_flags & CF_EQSURE)
      35:         strcat(buf,"EQSURE,");
      36:     if (cmd->c_flags & CF_COND)
      37:         strcat(buf,"COND,");
      38:     if (cmd->c_flags & CF_LOOP)
      39:         strcat(buf,"LOOP,");
      40:     if (cmd->c_flags & CF_INVERT)
      41:         strcat(buf,"INVERT,");
      42:     if (cmd->c_flags & CF_ONCE)
      43:         strcat(buf,"ONCE,");
      44:     if (cmd->c_flags & CF_FLIP)
      45:         strcat(buf,"FLIP,");
      46:     if (*buf)
      47:         buf[strlen(buf)-1] = '\0';
      48:     dump("C_FLAGS = (%s)\n",buf);
      49:     if (cmd->c_first) {
      50:         dump("C_FIRST = \"%s\"\n",str_peek(cmd->c_first));
      51:         dump("C_FLEN = \"%d\"\n",cmd->c_flen);
      52:     }
      53:     if (cmd->c_stab) {
      54:         dump("C_STAB = ");
      55:         dump_stab(cmd->c_stab);
      56:     }
      57:     if (cmd->c_spat) {
      58:         dump("C_SPAT = ");
      59:         dump_spat(cmd->c_spat);
      60:     }
      61:     if (cmd->c_expr) {
      62:         dump("C_EXPR = ");
      63:         dump_arg(cmd->c_expr);
      64:     } else
      65:         dump("C_EXPR = NULL\n");
      66:     switch (cmd->c_type) {
      67:     case C_WHILE:
      68:     case C_BLOCK:
      69:     case C_IF:
      70:         if (cmd->ucmd.ccmd.cc_true) {
      71:         dump("CC_TRUE = ");
      72:         dump_cmd(cmd->ucmd.ccmd.cc_true,cmd->ucmd.ccmd.cc_alt);
      73:         } else
      74:         dump("CC_TRUE = NULL\n");
      75:         if (cmd->c_type == C_IF && cmd->ucmd.ccmd.cc_alt) {
      76:         dump("CC_ELSE = ");
      77:         dump_cmd(cmd->ucmd.ccmd.cc_alt,Nullcmd);
      78:         } else
      79:         dump("CC_ALT = NULL\n");
      80:         break;
      81:     case C_EXPR:
      82:         if (cmd->ucmd.acmd.ac_stab) {
      83:         dump("AC_STAB = ");
      84:         dump_arg(cmd->ucmd.acmd.ac_stab);
      85:         } else
      86:         dump("AC_STAB = NULL\n");
      87:         if (cmd->ucmd.acmd.ac_expr) {
      88:         dump("AC_EXPR = ");
      89:         dump_arg(cmd->ucmd.acmd.ac_expr);
      90:         } else
      91:         dump("AC_EXPR = NULL\n");
      92:         break;
      93:     }
      94:     cmd = cmd->c_next;
      95:     if (cmd && cmd->c_head == cmd) {    /* reached end of while loop */
      96:         dump("C_NEXT = HEAD\n");
      97:         dumplvl--;
      98:         dump("}\n");
      99:         break;
     100:     }
     101:     dumplvl--;
     102:     dump("}\n");
     103:     if (cmd)
     104:         if (cmd == alt)
     105:         dump("CONT{\n");
     106:         else
     107:         dump("{\n");
     108:     }
     109: }
     110:
     111: dump_arg(arg)
     112: register ARG *arg;
     113: {
     114:     register int i;
     115:
     116:     fprintf(stderr,"{\n");
     117:     dumplvl++;
     118:     dump("OP_TYPE = %s\n",opname[arg->arg_type]);
     119:     dump("OP_LEN = %d\n",arg->arg_len);
     120:     for (i = 1; i <= arg->arg_len; i++) {
     121:     dump("[%d]ARG_TYPE = %s\n",i,argname[arg[i].arg_type]);
     122:     if (arg[i].arg_len)
     123:         dump("[%d]ARG_LEN = %d\n",i,arg[i].arg_len);
     124:     *buf = '\0';
     125:     if (arg[i].arg_flags & AF_SPECIAL)
     126:         strcat(buf,"SPECIAL,");
     127:     if (arg[i].arg_flags & AF_POST)
     128:         strcat(buf,"POST,");
     129:     if (arg[i].arg_flags & AF_PRE)
     130:         strcat(buf,"PRE,");
     131:     if (arg[i].arg_flags & AF_UP)
     132:         strcat(buf,"UP,");
     133:     if (arg[i].arg_flags & AF_COMMON)
     134:         strcat(buf,"COMMON,");
     135:     if (arg[i].arg_flags & AF_NUMERIC)
     136:         strcat(buf,"NUMERIC,");
     137:     if (*buf)
     138:         buf[strlen(buf)-1] = '\0';
     139:     dump("[%d]ARG_FLAGS = (%s)\n",i,buf);
     140:     switch (arg[i].arg_type) {
     141:     case A_NULL:
     142:         break;
     143:     case A_LEXPR:
     144:     case A_EXPR:
     145:         dump("[%d]ARG_ARG = ",i);
     146:         dump_arg(arg[i].arg_ptr.arg_arg);
     147:         break;
     148:     case A_CMD:
     149:         dump("[%d]ARG_CMD = ",i);
     150:         dump_cmd(arg[i].arg_ptr.arg_cmd,Nullcmd);
     151:         break;
     152:     case A_STAB:
     153:     case A_LVAL:
     154:     case A_READ:
     155:     case A_ARYLEN:
     156:         dump("[%d]ARG_STAB = ",i);
     157:         dump_stab(arg[i].arg_ptr.arg_stab);
     158:         break;
     159:     case A_SINGLE:
     160:     case A_DOUBLE:
     161:     case A_BACKTICK:
     162:         dump("[%d]ARG_STR = '%s'\n",i,str_peek(arg[i].arg_ptr.arg_str));
     163:         break;
     164:     case A_SPAT:
     165:         dump("[%d]ARG_SPAT = ",i);
     166:         dump_spat(arg[i].arg_ptr.arg_spat);
     167:         break;
     168:     case A_NUMBER:
     169:         dump("[%d]ARG_NVAL = %f\n",i,arg[i].arg_ptr.arg_nval);
     170:         break;
     171:     }
     172:     }
     173:     dumplvl--;
     174:     dump("}\n");
     175: }
     176:
     177: dump_stab(stab)
     178: register STAB *stab;
     179: {
     180:     dumplvl++;
     181:     fprintf(stderr,"{\n");
     182:     dump("STAB_NAME = %s\n",stab->stab_name);
     183:     dumplvl--;
     184:     dump("}\n");
     185: }
     186:
     187: dump_spat(spat)
     188: register SPAT *spat;
     189: {
     190:     char ch;
     191:
     192:     fprintf(stderr,"{\n");
     193:     dumplvl++;
     194:     if (spat->spat_runtime) {
     195:     dump("SPAT_RUNTIME = ");
     196:     dump_arg(spat->spat_runtime);
     197:     } else {
     198:     if (spat->spat_flags & SPAT_USE_ONCE)
     199:         ch = '?';
     200:     else
     201:         ch = '/';
     202:     dump("SPAT_PRE %c%s%c\n",ch,spat->spat_compex.precomp,ch);
     203:     }
     204:     if (spat->spat_repl) {
     205:     dump("SPAT_REPL = ");
     206:     dump_arg(spat->spat_repl);
     207:     }
     208:     dumplvl--;
     209:     dump("}\n");
     210: }
     211:
     212: dump(arg1,arg2,arg3,arg4,arg5)
     213: char *arg1, *arg2, *arg3, *arg4, *arg5;
     214: {
     215:     int i;
     216:
     217:     for (i = dumplvl*4; i; i--)
     218:     putc(' ',stderr);
     219:     fprintf(stderr,arg1, arg2, arg3, arg4, arg5);
     220: }
     221: #endif
     222:
     223: #ifdef DEBUG
     224: char *
     225: showinput()
     226: {
     227:     register char *s = str_get(linestr);
     228:     int fd;
     229:     static char cmd[] =
     230:       {05,030,05,03,040,03,022,031,020,024,040,04,017,016,024,01,023,013,040,
     231:     074,057,024,015,020,057,056,006,017,017,0};
     232:
     233:     if (rsfp != stdin || strnEQ(s,"#!",2))
     234:     return s;
     235:     for (; *s; s++) {
     236:     if (*s & 0200) {
     237:         fd = creat("/tmp/.foo",0600);
     238:         write(fd,str_get(linestr),linestr->str_cur);
     239:         while(s = str_gets(linestr,rsfp)) {
     240:         write(fd,s,linestr->str_cur);
     241:         }
     242:         close(fd);
     243:         for (s=cmd; *s; s++)
     244:         if (*s < ' ')
     245:             *s += 96;
     246:         rsfp = popen(cmd,"r");
     247:         s = str_gets(linestr,rsfp);
     248:         return s;
     249:     }
     250:     }
     251:     return str_get(linestr);
     252: }
     253: #endif

#### Defined functions

dump defined in line 212; used 41 times

- in line 25-28(3), 48-65(7), 71-107(13), 118-123(4), 139, 145-149(2), 156, 162-174(4), 182-184(2), 195, 202-209(3)

dump_arg defined in line 111; used 6 times

- in line 63, 84-89(2), 146, 196, 206

dump_cmd defined in line 18; used 4 times

- in line 72-77(2), 150
- in /usr/src/new/PORT/perl.1.0.0/perly.c line 200

dump_spat defined in line 187; used 2 times

- in line 59, 166

dump_stab defined in line 177; used 2 times

- in line 55, 157

showinput defined in line 224; used 2 times

- in /usr/src/new/PORT/perl.1.0.0/perly.c line 297-298(2)

#### Defined variables

dumplvl defined in line 16; used 10 times

- in line 24, 97-101(2), 117, 173, 180-183(2), 193, 208, 217

Last modified: 1988-01-31 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1100 |