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