Commit | Line | Data |
---|---|---|
634191e1 AF |
1 | |
2 | /* Copyright (c) 1982 Regents of the University of California */ | |
3 | ||
e1f4dbca | 4 | static char sccsid[] = "@(#)debug.c 1.4\t%G%"; |
634191e1 AF |
5 | |
6 | /* | |
7 | * Debug routines | |
8 | */ | |
9 | ||
10 | #include "defs.h" | |
11 | #include "tree.h" | |
12 | #include "operators.h" | |
13 | #include "eval.h" | |
14 | #include "events.h" | |
15 | #include "symbols.h" | |
16 | #include "scanner.h" | |
17 | #include "source.h" | |
18 | #include "object.h" | |
19 | #include "mappings.h" | |
20 | #include "process.h" | |
21 | #include "machine.h" | |
22 | #include <signal.h> | |
23 | ||
24 | ||
25 | public int debug_flag[20]; | |
26 | ||
27 | public debug(p) | |
28 | Node p; | |
29 | { | |
30 | int code; | |
31 | code = p->value.lcon; | |
32 | ||
33 | if ( (code >= 0) and (code < 10) ) { | |
34 | switch(code) { | |
35 | case 2: if(debug_flag[2]) debug_flag[2]=0; | |
36 | else debug_flag[2] =1; | |
37 | printf(" flag 2 is %d \n",debug_flag[2]); | |
38 | break; | |
39 | ||
40 | case 3: if(debug_flag[3]) debug_flag[3]=0; | |
41 | else debug_flag[3] =1; | |
42 | printf(" flag 3 is %d \n",debug_flag[3]); | |
43 | break; | |
44 | ||
45 | case 4: if(debug_flag[4]) debug_flag[4]=0; | |
46 | else debug_flag[4] =1; | |
47 | printf(" flag 4 is %d \n",debug_flag[4]); | |
48 | break; | |
49 | ||
50 | case 5: if(debug_flag[5]) debug_flag[5]=0; | |
51 | else debug_flag[5] =1; | |
52 | printf(" flag 5 is %d \n",debug_flag[5]); | |
53 | break; | |
54 | ||
55 | case 6: dumpfunctab(); | |
56 | break; | |
57 | ||
58 | default: printf(" unknown debug code %ld \n",p->value.lcon); | |
59 | break; | |
60 | } | |
61 | } | |
62 | else if (debug_flag[3]) symbol_dump(code); | |
63 | else if (debug_flag[4]) psym(code); | |
64 | } | |
65 | ||
66 | public char *showoperator(op) | |
67 | Operator op; | |
68 | { | |
69 | static char *operator_str[] = { | |
70 | "O_NOP", "O_NAME", "O_SYM", "O_LCON", "O_FCON", "O_SCON", "O_RVAL", "O_INDEX", | |
71 | "O_INDIR", "O_DOT", "O_COMMA", "O_ITOF", "O_ADD", "O_ADDF", "O_SUB", "O_SUBF", | |
72 | "O_NEG", "O_NEGF", "O_MUL", "O_MULF", "O_DIVF", "O_DIV", "O_MOD", "O_AND", | |
73 | "O_OR", "O_LT", "O_LTF", "O_LE", "O_LEF", "O_GT", "O_GTF", "O_GE", "O_GEF", | |
74 | "O_EQ", "O_EQF", "O_NE", "O_NEF", "O_ALIAS", "O_ASSIGN", "O_CALL", "O_CATCH", | |
75 | "O_CHFILE", "O_CONT", "O_DEBUG", "O_DELETE", "O_DUMP", "O_EDIT", "O_FUNC", | |
76 | "O_GRIPE", "O_HELP", "O_IGNORE", "O_LIST", "O_PRINT", "O_PSYM", "O_RUN", | |
77 | "O_SKIP", "O_SOURCE", "O_STATUS", "O_STEP", "O_STOP", "O_STOPI", "O_TRACE", | |
78 | "O_TRACEI", "O_WHATIS", "O_WHERE", "O_WHEREIS", "O_WHICH", "O_EXAMINE", | |
79 | "O_ADDEVENT", "O_ENDX", "O_IF", "O_ONCE", "O_PRINTCALL", "O_PRINTIFCHANGED", | |
80 | "O_PRINTRTN", "O_PRINTSRCPOS", "O_PROCRTN", "O_QLINE", "O_STOPIFCHANGED", | |
81 | "O_STOPX", "O_TRACEON", "O_TRACEOFF", "O_TYPERENAME", "O_LASTOP" }; | |
82 | return( operator_str[ord(op)] ); | |
83 | } | |
84 | ||
85 | /* | |
86 | * Dump a tree recursively | |
87 | */ | |
88 | ||
89 | public dumptree(f, p) | |
90 | File f; | |
91 | register Node p; | |
92 | { | |
93 | register Node q; | |
94 | Operator op; | |
95 | static recurse =0; | |
96 | ++recurse; | |
97 | ||
98 | if (p != nil) { | |
99 | op = p->op; | |
100 | if (ord(op) > ord(O_LASTOP)) { | |
101 | panic("bad op %d in dumptree", p->op); | |
102 | } | |
103 | { int n_args; | |
104 | fprintf(f, "\n level %d op %s node %ld ",recurse,showoperator(op), p); | |
105 | for(n_args=0;n_args < nargs(op); n_args++) | |
106 | fprintf(f," arg%d %ld ",n_args,p->value.arg[n_args]); | |
107 | fprintf(f,"\n"); | |
108 | } | |
109 | if(p->nodetype) {fprintf(f,"nodetype: "); psym(p->nodetype);} | |
110 | switch (op) { | |
111 | case O_NAME: | |
112 | fprintf(f, "%s", ident(p->value.name)); | |
113 | break; | |
114 | ||
115 | case O_SYM: | |
116 | printname(f, p->value.sym); | |
117 | break; | |
118 | ||
119 | case O_QLINE: | |
120 | if (nlhdr.nfiles > 1) { | |
121 | dumptree(f, p->value.arg[0]); | |
122 | fprintf(f, ":"); | |
123 | } | |
124 | dumptree(f, p->value.arg[1]); | |
125 | break; | |
126 | ||
127 | case O_LCON: | |
128 | if (compatible(p->nodetype, t_char)) { | |
129 | fprintf(f, "'%c'", p->value.lcon); | |
130 | } else { | |
131 | fprintf(f, "%d", p->value.lcon); | |
132 | } | |
133 | break; | |
134 | ||
135 | case O_FCON: | |
136 | fprintf(f, "%g", p->value.fcon); | |
137 | break; | |
138 | ||
139 | case O_SCON: | |
140 | fprintf(f, "\"%s\"", p->value.scon); | |
141 | break; | |
142 | ||
143 | case O_INDEX: | |
144 | dumptree(f, p->value.arg[0]); | |
145 | fprintf(f, "["); | |
146 | dumptree(f, p->value.arg[1]); | |
147 | fprintf(f, "]"); | |
148 | break; | |
149 | ||
150 | case O_COMMA: | |
151 | dumptree(f, p->value.arg[0]); | |
152 | if (p->value.arg[1] != nil) { | |
153 | fprintf(f, ", "); | |
154 | dumptree(f, p->value.arg[1]); | |
155 | } | |
156 | break; | |
157 | ||
158 | case O_RVAL: | |
159 | if (p->value.arg[0]->op == O_SYM) { | |
160 | printname(f, p->value.arg[0]->value.sym); | |
161 | } else { | |
162 | dumptree(f, p->value.arg[0]); | |
163 | } | |
164 | break; | |
165 | ||
166 | case O_ITOF: | |
167 | dumptree(f, p->value.arg[0]); | |
168 | break; | |
169 | ||
170 | case O_CALL: | |
171 | dumptree(f, p->value.arg[0]); | |
172 | if (p->value.arg[1]!= nil) { | |
173 | fprintf(f, "("); | |
174 | dumptree(f, p->value.arg[1]); | |
175 | fprintf(f, ")"); | |
176 | } | |
177 | break; | |
178 | ||
179 | case O_INDIR: | |
180 | q = p->value.arg[0]; | |
181 | if (isvarparam(q->nodetype)) { | |
182 | dumptree(f, q); | |
183 | } else { | |
184 | if (q->op == O_SYM or q->op == O_LCON or q->op == O_DOT) { | |
185 | dumptree(f, q); | |
186 | fprintf(f, "^"); | |
187 | } else { | |
188 | fprintf(f, "*("); | |
189 | dumptree(f, q); | |
190 | fprintf(f, ")"); | |
191 | } | |
192 | } | |
193 | break; | |
194 | ||
195 | case O_DOT: | |
196 | q = p->value.arg[0]; | |
197 | if (q->op == O_INDIR) { | |
198 | dumptree(f, q->value.arg[0]); | |
199 | } else { | |
200 | dumptree(f, q); | |
201 | } | |
202 | fprintf(f, ".%s", symname(p->value.arg[1]->value.sym)); | |
203 | break; | |
204 | ||
205 | default: | |
206 | switch (degree(op)) { | |
207 | case BINARY: | |
208 | dumptree(f, p->value.arg[0]); | |
209 | fprintf(f, "%s", opinfo[ord(op)].opstring); | |
210 | dumptree(f, p->value.arg[1]); | |
211 | break; | |
212 | ||
213 | case UNARY: | |
214 | fprintf(f, "%s", opinfo[ord(op)].opstring); | |
215 | dumptree(f, p->value.arg[0]); | |
216 | break; | |
217 | ||
218 | default: | |
219 | if(degree(op) < ord(O_LASTOP) ) | |
220 | { int i; | |
221 | if( nargs(op) != 0) | |
222 | for(i=0;i<nargs(op);i++) | |
223 | dumptree(f, p->value.arg[i]); | |
224 | } | |
225 | else | |
226 | error("internal error: bad op %d in dumptree", op); | |
227 | } | |
228 | break; | |
229 | } | |
230 | } | |
231 | recurse--; | |
232 | fflush(f); | |
233 | } |