![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to outimage.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / icon / rt|
Return to outimage.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / icon / rt |
1.1 root 1: #include "../h/rt.h"
2: #include "../h/record.h"
3:
4: #define STRINGLIMIT 16 /* limit on length of imaged string */
5: #define LISTLIMIT 6 /* limit on list items in image */
6:
7: /*
8: * outimage - print image of d on file f. If restrict is non-zero,
9: * fields of records will not be imaged.
10: */
11:
12: outimage(f, d, restrict)
13: FILE *f;
14: struct descrip *d;
15: int restrict;
16: {
17: register int i, j;
18: register char *s;
19: register union block *bp;
20: char *type;
21: FILE *fd;
22: struct descrip q;
23: extern char *blkname[];
24:
25: outimg:
26: if (NULLDESC(*d)) {
27: if (restrict == 0)
28: fprintf(f, "&null");
29: return;
30: }
31:
32: if (QUAL(*d)) {
33: /*
34: * *d is a string qualifier. Print STRINGLIMIT characters of it
35: * using printimage and denote the presence of additional characters
36: * by terminating the string with "...".
37: */
38: i = STRLEN(*d);
39: s = STRLOC(*d);
40: j = MIN(i, STRINGLIMIT);
41: putc('"', f);
42: while (j-- > 0)
43: printimage(f, *s++, '"');
44: if (i > STRINGLIMIT)
45: fprintf(f, "...");
46: putc('"', f);
47: return;
48: }
49:
50: if (VAR(*d) && !TVAR(*d)) {
51: /*
52: * *d is a variable. Print "variable =", dereference it and loop
53: * back to the top to cause the value of the variable to be imaged.
54: */
55: fprintf(f, "variable = ");
56: d = VARLOC(*d);
57: goto outimg;
58: }
59:
60: switch (TYPE(*d)) {
61:
62: case T_INTEGER:
63: fprintf(f, "%d", INTVAL(*d));
64: return;
65:
66: #ifdef LONGS
67: case T_LONGINT:
68: fprintf(f, "%ld", BLKLOC(*d)->longint.intval);
69: return;
70: #endif LONGS
71: case T_REAL:
72: {
73: char s[30];
74: struct descrip junk;
75: rtos(BLKLOC(*d)->realblk.realval, &junk, s);
76: fprintf(f, "%s", s);
77: return;
78: }
79:
80: case T_CSET:
81: /*
82: * Check for distinguished csets by looking at the address of
83: * of the object to image. If one is found, print its name.
84: */
85: if (BLKLOC(*d) == (union block *) &k_ascii) {
86: fprintf(f, "&ascii");
87: return;
88: }
89: else if (BLKLOC(*d) == (union block *) &k_cset) {
90: fprintf(f, "&cset");
91: return;
92: }
93: else if (BLKLOC(*d) == (union block *) &k_lcase) {
94: fprintf(f, "&lcase");
95: return;
96: }
97: else if (BLKLOC(*d) == (union block *) &k_ucase) {
98: fprintf(f, "&ucase");
99: return;
100: }
101: /*
102: * Use printimage to print each character in the cset. Follow
103: * with "..." if the cset contains more than STRINGLIMIT
104: * characters.
105: */
106: putc('\'', f);
107: j = STRINGLIMIT;
108: for (i = 0; i < 256; i++) {
109: if (tstb(i, BLKLOC(*d)->cset.bits)) {
110: if (j-- <= 0) {
111: fprintf(f, "...");
112: break;
113: }
114: printimage(f, i, '\'');
115: }
116: }
117: putc('\'', f);
118: return;
119:
120: case T_FILE:
121: /*
122: * Check for distinguished files by looking at the address of
123: * of the object to image. If one is found, print its name.
124: */
125: if ((fd = BLKLOC(*d)->file.fd) == stdin)
126: fprintf(f, "&input");
127: else if (fd == stdout)
128: fprintf(f, "&output");
129: else if (fd == stderr)
130: fprintf(f, "&output");
131: else {
132: /*
133: * The file isn't a special one, just print "file(name)".
134: */
135: i = STRLEN(BLKLOC(*d)->file.fname);
136: s = STRLOC(BLKLOC(*d)->file.fname);
137: fprintf(f, "file(");
138: while (i-- > 0)
139: printimage(f, *s++, '\0');
140: putc(')', f);
141: }
142: return;
143:
144: case T_PROC:
145: /*
146: * Produce one of:
147: * "procedure name"
148: * "function name"
149: * "record constructor name"
150: *
151: * Note that the number of dynamic locals is used to determine
152: * what type of "procedure" is at hand.
153: */
154: i = STRLEN(BLKLOC(*d)->proc.pname);
155: s = STRLOC(BLKLOC(*d)->proc.pname);
156: switch (BLKLOC(*d)->proc.ndynam) {
157: default: type = "procedure"; break;
158: case -1: type = "function"; break;
159: case -2: type = "record constructor"; break;
160: }
161: fprintf(f, "%s ", type);
162: while (i-- > 0)
163: printimage(f, *s++, '\0');
164: return;
165:
166: case T_LIST:
167: /*
168: * listimage does the work for lists.
169: */
170: listimage(f, BLKLOC(*d), restrict);
171: return;
172:
173: case T_TABLE:
174: /*
175: * Print "table(n)" where n is the size of the table.
176: */
177: fprintf(f, "table(%d)", BLKLOC(*d)->table.cursize);
178: return;
179: #ifdef SETS
180: case T_SET:
181: /*
182: * print "set(n)" where n is the cardinality of the set
183: */
184: fprintf(f,"set(%d)",BLKLOC(*d)->set.setsize);
185: return;
186: #endif SETS
187:
188: case T_RECORD:
189: /*
190: * If restrict is non-zero, print "record(n)" where n is the
191: * number of fields in the record. If restrict is zero, print
192: * the image of each field instead of the number of fields.
193: */
194: bp = BLKLOC(*d);
195: i = STRLEN(bp->record.recptr->recname);
196: s = STRLOC(bp->record.recptr->recname);
197: fprintf(f, "record ");
198: while (i-- > 0)
199: printimage(f, *s++, '\0');
200: j = bp->record.recptr->nfields;
201: if (j <= 0)
202: fprintf(f, "()");
203: else if (restrict > 0)
204: fprintf(f, "(%d)", j);
205: else {
206: putc('(', f);
207: i = 0;
208: for (;;) {
209: outimage(f, &bp->record.fields[i], restrict+1);
210: if (++i >= j)
211: break;
212: putc(',', f);
213: }
214: putc(')', f);
215: }
216: return;
217:
218: case T_TVSUBS:
219: /*
220: * Produce "v[i+:j] = value" where v is the image of the variable
221: * containing the substring, i is starting position of the substring
222: * j is the length, and value is the string v[i+:j]. If the length
223: * (j) is one, just produce "v[i] = value".
224: */
225: bp = BLKLOC(*d);
226: outimage(f, VARLOC(bp->tvsubs.ssvar), restrict);
227: if (bp->tvsubs.sslen == 1)
228: fprintf(f, "[%d]", bp->tvsubs.sspos);
229: else
230: fprintf(f, "[%d+:%d]", bp->tvsubs.sspos, bp->tvsubs.sslen);
231: if (QUAL(*VARLOC(bp->tvsubs.ssvar))) {
232: STRLEN(q) = bp->tvsubs.sslen;
233: STRLOC(q) = STRLOC(*VARLOC(bp->tvsubs.ssvar)) + bp->tvsubs.sspos-1;
234: fprintf(f, " = ");
235: d = &q;
236: goto outimg;
237: }
238: return;
239:
240: case T_TVTBL:
241: bp = BLKLOC(*d);
242: /*
243: * It is possible that descriptor d which thinks it is pointing
244: * at a TVTBL may actually be pointing at a TELEM which had
245: * been converted from a trapped variable. Check for this first
246: * and if it is a TELEM produce the outimage of its value.
247: */
248: if (bp->tvtbl.type == T_TELEM) {
249: outimage(f,&bp->tvtbl.tvtval,restrict);
250: return;
251: }
252: /*
253: * It really was a TVTBL - Produce "t[s]" where t is the image of
254: * the table containing the element and s is the image of the
255: * subscript.
256: */
257: else {
258: outimage(f, &bp->tvtbl.tvtable, restrict);
259: putc('[', f);
260: outimage(f, &bp->tvtbl.tvtref, restrict);
261: putc(']', f);
262: return;
263: }
264:
265: case T_TVPOS:
266: fprintf(f, "&pos = %d", k_pos);
267: return;
268:
269: case T_TVRAND:
270: fprintf(f, "&random = %ld", k_random);
271: return;
272:
273: case T_TVTRACE:
274: fprintf(f, "&trace = %d", k_trace);
275: return;
276:
277: case T_ESTACK:
278: fprintf(f, "co-expression");
279: return;
280:
281: default:
282: if (TYPE(*d) <= MAXTYPE)
283: fprintf(f, "%s", blkname[TYPE(*d)]);
284: else
285: syserr("outimage: unknown type");
286: }
287: }
288:
289: /*
290: * printimage - print character c on file f using escape conventions
291: * if c is unprintable, '\', or equal to q.
292: */
293:
294: static printimage(f, c, q)
295: FILE *f;
296: int c, q;
297: {
298: if (c >= ' ' && c < '\177') {
299: /*
300: * c is printable, but special case ", ', and \.
301: */
302: switch (c) {
303: case '"':
304: if (c != q) goto def;
305: fprintf(f, "\\\"");
306: return;
307: case '\'':
308: if (c != q) goto def;
309: fprintf(f, "\\'");
310: return;
311: case '\\':
312: fprintf(f, "\\\\");
313: return;
314: default:
315: def:
316: putc(c, f);
317: return;
318: }
319: }
320:
321: /*
322: * c is some sort of unprintable character. If it one of the common
323: * ones, produce a special representation for it, otherwise, produce
324: * its octal value.
325: */
326: switch (c) {
327: case '\b': /* backspace */
328: fprintf(f, "\\b");
329: return;
330: case '\177': /* delete */
331: fprintf(f, "\\d");
332: return;
333: case '\33': /* escape */
334: fprintf(f, "\\e");
335: return;
336: case '\f': /* form feed */
337: fprintf(f, "\\f");
338: return;
339: case '\n': /* new line */
340: fprintf(f, "\\n");
341: return;
342: case '\r': /* return */
343: fprintf(f, "\\r");
344: return;
345: case '\t': /* horizontal tab */
346: fprintf(f, "\\t");
347: return;
348: case '\13': /* vertical tab */
349: fprintf(f, "\\v");
350: return;
351: default: /* octal constant */
352: fprintf(f, "\\%03o", c&0377);
353: return;
354: }
355: }
356:
357: /*
358: * listimage - print an image of a list.
359: */
360:
361: static listimage(f, lp, restrict)
362: FILE *f;
363: struct b_list *lp;
364: int restrict;
365: {
366: register int i, j;
367: register struct b_lelem *bp;
368: int size, count;
369:
370: bp = (struct b_lelem *) BLKLOC(lp->listhead);
371: size = lp->cursize;
372:
373: if (restrict > 0 && size > 0) {
374: /*
375: * Just give indication of size if the list isn't empty.
376: */
377: fprintf(f, "list(%d)", size);
378: return;
379: }
380:
381: /*
382: * Print [e1,...,en] on f. If more than LISTLIMIT elements are in the
383: * list, produce the first LISTLIMIT/2 elements, an ellipsis, and the
384: * last LISTLIMIT elements.
385: */
386: putc('[', f);
387: count = 1;
388: i = 0;
389: if (size > 0) {
390: for (;;) {
391: if (++i > bp->nused) {
392: i = 1;
393: bp = (struct b_lelem *) BLKLOC(bp->listnext);
394: }
395: if (count <= LISTLIMIT/2 || count > size - LISTLIMIT/2) {
396: j = bp->first + i - 1;
397: if (j >= bp->nelem)
398: j -= bp->nelem;
399: outimage(f, &bp->lslots[j], restrict+1);
400: if (count >= size)
401: break;
402: putc(',', f);
403: }
404: else if (count == LISTLIMIT/2 + 1)
405: fprintf(f, "...,");
406: count++;
407: }
408: }
409: putc(']', f);
410: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.