xref: /netbsd/bin/sh/show.c (revision c4a72b64) 
1 /*	$NetBSD: show.c,v 1.23 2002/11/24 22:35:43 christos Exp $	*/
2 
3 /*-
4  * Copyright (c) 1991, 1993
5  *	The Regents of the University of California.  All rights reserved.
6  *
7  * This code is derived from software contributed to Berkeley by
8  * Kenneth Almquist.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. All advertising materials mentioning features or use of this software
19  *    must display the following acknowledgement:
20  *	This product includes software developed by the University of
21  *	California, Berkeley and its contributors.
22  * 4. Neither the name of the University nor the names of its contributors
23  *    may be used to endorse or promote products derived from this software
24  *    without specific prior written permission.
25  *
26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36  * SUCH DAMAGE.
37  */
38 
39 #include <sys/cdefs.h>
40 #ifndef lint
41 #if 0
42 static char sccsid[] = "@(#)show.c	8.3 (Berkeley) 5/4/95";
43 #else
44 __RCSID("$NetBSD: show.c,v 1.23 2002/11/24 22:35:43 christos Exp $");
45 #endif
46 #endif /* not lint */
47 
48 #include <stdio.h>
49 #include <stdarg.h>
50 
51 #include "shell.h"
52 #include "parser.h"
53 #include "nodes.h"
54 #include "mystring.h"
55 #include "show.h"
56 #include "options.h"
57 
58 
59 #ifdef DEBUG
60 static void shtree(union node *, int, char *, FILE*);
61 static void shcmd(union node *, FILE *);
62 static void sharg(union node *, FILE *);
63 static void indent(int, char *, FILE *);
64 static void trstring(char *);
65 
66 
67 void
68 showtree(union node *n)
69 {
70 	trputs("showtree called\n");
71 	shtree(n, 1, NULL, stdout);
72 }
73 
74 
75 static void
76 shtree(union node *n, int ind, char *pfx, FILE *fp)
77 {
78 	struct nodelist *lp;
79 	const char *s;
80 
81 	if (n == NULL)
82 		return;
83 
84 	indent(ind, pfx, fp);
85 	switch(n->type) {
86 	case NSEMI:
87 		s = "; ";
88 		goto binop;
89 	case NAND:
90 		s = " && ";
91 		goto binop;
92 	case NOR:
93 		s = " || ";
94 binop:
95 		shtree(n->nbinary.ch1, ind, NULL, fp);
96 	   /*    if (ind < 0) */
97 			fputs(s, fp);
98 		shtree(n->nbinary.ch2, ind, NULL, fp);
99 		break;
100 	case NCMD:
101 		shcmd(n, fp);
102 		if (ind >= 0)
103 			putc('\n', fp);
104 		break;
105 	case NPIPE:
106 		for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
107 			shcmd(lp->n, fp);
108 			if (lp->next)
109 				fputs(" | ", fp);
110 		}
111 		if (n->npipe.backgnd)
112 			fputs(" &", fp);
113 		if (ind >= 0)
114 			putc('\n', fp);
115 		break;
116 	default:
117 		fprintf(fp, "<node type %d>", n->type);
118 		if (ind >= 0)
119 			putc('\n', fp);
120 		break;
121 	}
122 }
123 
124 
125 
126 static void
127 shcmd(union node *cmd, FILE *fp)
128 {
129 	union node *np;
130 	int first;
131 	const char *s;
132 	int dftfd;
133 
134 	first = 1;
135 	for (np = cmd->ncmd.args ; np ; np = np->narg.next) {
136 		if (! first)
137 			putchar(' ');
138 		sharg(np, fp);
139 		first = 0;
140 	}
141 	for (np = cmd->ncmd.redirect ; np ; np = np->nfile.next) {
142 		if (! first)
143 			putchar(' ');
144 		switch (np->nfile.type) {
145 			case NTO:	s = ">";  dftfd = 1; break;
146 			case NCLOBBER:	s = ">|"; dftfd = 1; break;
147 			case NAPPEND:	s = ">>"; dftfd = 1; break;
148 			case NTOFD:	s = ">&"; dftfd = 1; break;
149 			case NFROM:	s = "<";  dftfd = 0; break;
150 			case NFROMFD:	s = "<&"; dftfd = 0; break;
151 			case NFROMTO:	s = "<>"; dftfd = 0; break;
152 			default:  	s = "*error*"; dftfd = 0; break;
153 		}
154 		if (np->nfile.fd != dftfd)
155 			fprintf(fp, "%d", np->nfile.fd);
156 		fputs(s, fp);
157 		if (np->nfile.type == NTOFD || np->nfile.type == NFROMFD) {
158 			fprintf(fp, "%d", np->ndup.dupfd);
159 		} else {
160 			sharg(np->nfile.fname, fp);
161 		}
162 		first = 0;
163 	}
164 }
165 
166 
167 
168 static void
169 sharg(union node *arg, FILE *fp)
170 {
171 	char *p;
172 	struct nodelist *bqlist;
173 	int subtype;
174 
175 	if (arg->type != NARG) {
176 		printf("<node type %d>\n", arg->type);
177 		abort();
178 	}
179 	bqlist = arg->narg.backquote;
180 	for (p = arg->narg.text ; *p ; p++) {
181 		switch (*p) {
182 		case CTLESC:
183 			putc(*++p, fp);
184 			break;
185 		case CTLVAR:
186 			putc('$', fp);
187 			putc('{', fp);
188 			subtype = *++p;
189 			if (subtype == VSLENGTH)
190 				putc('#', fp);
191 
192 			while (*p != '=')
193 				putc(*p++, fp);
194 
195 			if (subtype & VSNUL)
196 				putc(':', fp);
197 
198 			switch (subtype & VSTYPE) {
199 			case VSNORMAL:
200 				putc('}', fp);
201 				break;
202 			case VSMINUS:
203 				putc('-', fp);
204 				break;
205 			case VSPLUS:
206 				putc('+', fp);
207 				break;
208 			case VSQUESTION:
209 				putc('?', fp);
210 				break;
211 			case VSASSIGN:
212 				putc('=', fp);
213 				break;
214 			case VSTRIMLEFT:
215 				putc('#', fp);
216 				break;
217 			case VSTRIMLEFTMAX:
218 				putc('#', fp);
219 				putc('#', fp);
220 				break;
221 			case VSTRIMRIGHT:
222 				putc('%', fp);
223 				break;
224 			case VSTRIMRIGHTMAX:
225 				putc('%', fp);
226 				putc('%', fp);
227 				break;
228 			case VSLENGTH:
229 				break;
230 			default:
231 				printf("<subtype %d>", subtype);
232 			}
233 			break;
234 		case CTLENDVAR:
235 		     putc('}', fp);
236 		     break;
237 		case CTLBACKQ:
238 		case CTLBACKQ|CTLQUOTE:
239 			putc('$', fp);
240 			putc('(', fp);
241 			shtree(bqlist->n, -1, NULL, fp);
242 			putc(')', fp);
243 			break;
244 		default:
245 			putc(*p, fp);
246 			break;
247 		}
248 	}
249 }
250 
251 
252 static void
253 indent(int amount, char *pfx, FILE *fp)
254 {
255 	int i;
256 
257 	for (i = 0 ; i < amount ; i++) {
258 		if (pfx && i == amount - 1)
259 			fputs(pfx, fp);
260 		putc('\t', fp);
261 	}
262 }
263 #endif
264 
265 
266 
267 /*
268  * Debugging stuff.
269  */
270 
271 
272 FILE *tracefile;
273 
274 
275 #ifdef DEBUG
276 void
277 trputc(int c)
278 {
279 	if (!debug)
280 		return;
281 	putc(c, tracefile);
282 }
283 #endif
284 
285 void
286 trace(const char *fmt, ...)
287 {
288 #ifdef DEBUG
289 	va_list va;
290 
291 	if (!debug)
292 		return;
293 	va_start(va, fmt);
294 	(void) vfprintf(tracefile, fmt, va);
295 	va_end(va);
296 #endif
297 }
298 
299 
300 #ifdef DEBUG
301 void
302 trputs(const char *s)
303 {
304 	if (!debug)
305 		return;
306 	fputs(s, tracefile);
307 }
308 
309 
310 static void
311 trstring(char *s)
312 {
313 	char *p;
314 	char c;
315 
316 	if (!debug)
317 		return;
318 	putc('"', tracefile);
319 	for (p = s ; *p ; p++) {
320 		switch (*p) {
321 		case '\n':  c = 'n';  goto backslash;
322 		case '\t':  c = 't';  goto backslash;
323 		case '\r':  c = 'r';  goto backslash;
324 		case '"':  c = '"';  goto backslash;
325 		case '\\':  c = '\\';  goto backslash;
326 		case CTLESC:  c = 'e';  goto backslash;
327 		case CTLVAR:  c = 'v';  goto backslash;
328 		case CTLVAR+CTLQUOTE:  c = 'V';  goto backslash;
329 		case CTLBACKQ:  c = 'q';  goto backslash;
330 		case CTLBACKQ+CTLQUOTE:  c = 'Q';  goto backslash;
331 backslash:	  putc('\\', tracefile);
332 			putc(c, tracefile);
333 			break;
334 		default:
335 			if (*p >= ' ' && *p <= '~')
336 				putc(*p, tracefile);
337 			else {
338 				putc('\\', tracefile);
339 				putc(*p >> 6 & 03, tracefile);
340 				putc(*p >> 3 & 07, tracefile);
341 				putc(*p & 07, tracefile);
342 			}
343 			break;
344 		}
345 	}
346 	putc('"', tracefile);
347 }
348 #endif
349 
350 
351 void
352 trargs(char **ap)
353 {
354 #ifdef DEBUG
355 	if (!debug)
356 		return;
357 	while (*ap) {
358 		trstring(*ap++);
359 		if (*ap)
360 			putc(' ', tracefile);
361 		else
362 			putc('\n', tracefile);
363 	}
364 #endif
365 }
366 
367 
368 #ifdef DEBUG
369 void
370 opentrace(void)
371 {
372 	char s[100];
373 #ifdef O_APPEND
374 	int flags;
375 #endif
376 
377 	if (!debug) {
378 		if (tracefile)
379 			fflush(tracefile);
380 		/* leave open because libedit might be using it */
381 		return;
382 	}
383 #ifdef not_this_way
384 	{
385 		char *p;
386 		if ((p = getenv("HOME")) == NULL) {
387 			if (geteuid() == 0)
388 				p = "/";
389 			else
390 				p = "/tmp";
391 		}
392 		scopy(p, s);
393 		strcat(s, "/trace");
394 	}
395 #else
396 	scopy("./trace", s);
397 #endif /* not_this_way */
398 	if (tracefile) {
399 		if (!freopen(s, "a", tracefile)) {
400 			fprintf(stderr, "Can't re-open %s\n", s);
401 			debug = 0;
402 			return;
403 		}
404 	} else {
405 		if ((tracefile = fopen(s, "a")) == NULL) {
406 			fprintf(stderr, "Can't open %s\n", s);
407 			debug = 0;
408 			return;
409 		}
410 	}
411 #ifdef O_APPEND
412 	if ((flags = fcntl(fileno(tracefile), F_GETFL, 0)) >= 0)
413 		fcntl(fileno(tracefile), F_SETFL, flags | O_APPEND);
414 #endif
415 	setlinebuf(tracefile);
416 	fputs("\nTracing started.\n", tracefile);
417 }
418 #endif /* DEBUG */
419