xref: /illumos-gate/usr/src/cmd/sh/func.c (revision 002c70ff32f5df6f93c15f88d351ce26443e6ee7)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 
23 /*
24  * Copyright 1996 Sun Microsystems, Inc.  All rights reserved.
25  * Use is subject to license terms.
26  */
27 
28 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
29 /*	  All Rights Reserved  	*/
30 
31 #pragma ident	"%Z%%M%	%I%	%E% SMI"
32 /*
33  * UNIX shell
34  */
35 
36 #include	"defs.h"
37 
38 static void freetree(struct trenod *);
39 static void free_arg(struct argnod *);
40 static void freeio(struct ionod *);
41 static void freereg(struct regnod *);
42 static void prarg(struct argnod *argp);
43 static void prio(struct ionod *iop);
44 
45 void
46 freefunc(struct namnod 	*n)
47 {
48 	freetree((struct trenod *)(n->namenv));
49 }
50 
51 static void
52 freetree(struct trenod *t)
53 {
54 	if (t)
55 	{
56 		int type;
57 
58 		if (t->tretyp & CNTMSK)
59 		{
60 			t->tretyp--;
61 			return;
62 		}
63 
64 		type = t->tretyp & COMMSK;
65 
66 		switch (type)
67 		{
68 			case TFND:
69 				free(fndptr(t)->fndnam);
70 				freetree(fndptr(t)->fndval);
71 				break;
72 
73 			case TCOM:
74 				freeio(comptr(t)->comio);
75 				free_arg(comptr(t)->comarg);
76 				free_arg(comptr(t)->comset);
77 				break;
78 
79 			case TFORK:
80 				freeio(forkptr(t)->forkio);
81 				freetree(forkptr(t)->forktre);
82 				break;
83 
84 			case TPAR:
85 				freetree(parptr(t)->partre);
86 				break;
87 
88 			case TFIL:
89 			case TLST:
90 			case TAND:
91 			case TORF:
92 				freetree(lstptr(t)->lstlef);
93 				freetree(lstptr(t)->lstrit);
94 				break;
95 
96 			case TFOR:
97 			{
98 				struct fornod *f = (struct fornod *)t;
99 
100 				free(f->fornam);
101 				freetree(f->fortre);
102 				if (f->forlst)
103 				{
104 					freeio(f->forlst->comio);
105 					free_arg(f->forlst->comarg);
106 					free_arg(f->forlst->comset);
107 					free(f->forlst);
108 				}
109 			}
110 			break;
111 
112 			case TWH:
113 			case TUN:
114 				freetree(whptr(t)->whtre);
115 				freetree(whptr(t)->dotre);
116 				break;
117 
118 			case TIF:
119 				freetree(ifptr(t)->iftre);
120 				freetree(ifptr(t)->thtre);
121 				freetree(ifptr(t)->eltre);
122 				break;
123 
124 			case TSW:
125 				free(swptr(t)->swarg);
126 				freereg(swptr(t)->swlst);
127 				break;
128 		}
129 		free(t);
130 	}
131 }
132 
133 static void
134 free_arg(struct argnod *argp)
135 {
136 	struct argnod 	*sav;
137 
138 	while (argp)
139 	{
140 		sav = argp->argnxt;
141 		free(argp);
142 		argp = sav;
143 	}
144 }
145 
146 void
147 freeio(struct ionod *iop)
148 {
149 	struct ionod *sav;
150 
151 	while (iop)
152 	{
153 		if (iop->iofile & IODOC)
154 		{
155 
156 #ifdef DEBUG
157 			prs("unlinking ");
158 			prs(iop->ioname);
159 			newline();
160 #endif
161 
162 			unlink(iop->ioname);
163 
164 			if (fiotemp == iop)
165 				fiotemp = iop->iolst;
166 			else
167 			{
168 				struct ionod *fiop = fiotemp;
169 
170 				while (fiop->iolst != iop)
171 					fiop = fiop->iolst;
172 
173 				fiop->iolst = iop->iolst;
174 			}
175 		}
176 		free(iop->ioname);
177 		free(iop->iolink);
178 		sav = iop->ionxt;
179 		free(iop);
180 		iop = sav;
181 	}
182 }
183 
184 static void
185 freereg(struct regnod *regp)
186 {
187 	struct regnod 	*sav;
188 
189 	while (regp)
190 	{
191 		free_arg(regp->regptr);
192 		freetree(regp->regcom);
193 		sav = regp->regnxt;
194 		free(regp);
195 		regp = sav;
196 	}
197 }
198 
199 
200 static int nonl = 0;
201 
202 void
203 prbgnlst(void)
204 {
205 	if (nonl)
206 		prc_buff(SPACE);
207 	else
208 		prc_buff(NL);
209 }
210 
211 void
212 prendlst(void)
213 {
214 	if (nonl) {
215 		prc_buff(';');
216 		prc_buff(SPACE);
217 	}
218 	else
219 		prc_buff(NL);
220 }
221 
222 void
223 prcmd(struct trenod *t)
224 {
225 	nonl++;
226 	prf(t);
227 	nonl = 0;
228 }
229 
230 void
231 prf(struct trenod *t)
232 {
233 	sigchk();
234 
235 	if (t)
236 	{
237 		int	type;
238 
239 		type = t->tretyp & COMMSK;
240 
241 		switch(type)
242 		{
243 			case TFND:
244 			{
245 				struct fndnod *f = (struct fndnod *)t;
246 
247 				prs_buff(f->fndnam);
248 				prs_buff("(){");
249 				prbgnlst();
250 				prf(f->fndval);
251 				prbgnlst();
252 				prs_buff("}");
253 				break;
254 			}
255 
256 			case TCOM:
257 				if (comptr(t)->comset) {
258 					prarg(comptr(t)->comset);
259 					prc_buff(SPACE);
260 				}
261 				prarg(comptr(t)->comarg);
262 				prio(comptr(t)->comio);
263 				break;
264 
265 			case TFORK:
266 				prf(forkptr(t)->forktre);
267 				prio(forkptr(t)->forkio);
268 				if (forkptr(t)->forktyp & FAMP)
269 					prs_buff(" &");
270 				break;
271 
272 			case TPAR:
273 				prs_buff("(");
274 				prf(parptr(t)->partre);
275 				prs_buff(")");
276 				break;
277 
278 			case TFIL:
279 				prf(lstptr(t)->lstlef);
280 				prs_buff(" | ");
281 				prf(lstptr(t)->lstrit);
282 				break;
283 
284 			case TLST:
285 				prf(lstptr(t)->lstlef);
286 				prendlst();
287 				prf(lstptr(t)->lstrit);
288 				break;
289 
290 			case TAND:
291 				prf(lstptr(t)->lstlef);
292 				prs_buff(" && ");
293 				prf(lstptr(t)->lstrit);
294 				break;
295 
296 			case TORF:
297 				prf(lstptr(t)->lstlef);
298 				prs_buff(" || ");
299 				prf(lstptr(t)->lstrit);
300 				break;
301 
302 			case TFOR:
303 				{
304 					struct argnod	*arg;
305 					struct fornod 	*f = (struct fornod *)t;
306 
307 					prs_buff("for ");
308 					prs_buff(f->fornam);
309 
310 					if (f->forlst)
311 					{
312 						arg = f->forlst->comarg;
313 						prs_buff(" in");
314 
315 						while(arg != ENDARGS)
316 						{
317 							prc_buff(SPACE);
318 							prs_buff(arg->argval);
319 							arg = arg->argnxt;
320 						}
321 					}
322 
323 					prendlst();
324 					prs_buff("do");
325 					prbgnlst();
326 					prf(f->fortre);
327 					prendlst();
328 					prs_buff("done");
329 				}
330 				break;
331 
332 			case TWH:
333 			case TUN:
334 				if (type == TWH)
335 					prs_buff("while ");
336 				else
337 					prs_buff("until ");
338 				prf(whptr(t)->whtre);
339 				prendlst();
340 				prs_buff("do");
341 				prbgnlst();
342 				prf(whptr(t)->dotre);
343 				prendlst();
344 				prs_buff("done");
345 				break;
346 
347 			case TIF:
348 			{
349 				struct ifnod *f = (struct ifnod *)t;
350 
351 				prs_buff("if ");
352 				prf(f->iftre);
353 				prendlst();
354 				prs_buff("then");
355 				prendlst();
356 				prf(f->thtre);
357 
358 				if (f->eltre)
359 				{
360 					prendlst();
361 					prs_buff("else");
362 					prendlst();
363 					prf(f->eltre);
364 				}
365 
366 				prendlst();
367 				prs_buff("fi");
368 				break;
369 			}
370 
371 			case TSW:
372 				{
373 					struct regnod 	*swl;
374 
375 					prs_buff("case ");
376 					prs_buff(swptr(t)->swarg);
377 
378 					swl = swptr(t)->swlst;
379 					while(swl)
380 					{
381 						struct argnod	*arg = swl->regptr;
382 
383 						if (arg)
384 						{
385 							prs_buff(arg->argval);
386 							arg = arg->argnxt;
387 						}
388 
389 						while(arg)
390 						{
391 							prs_buff(" | ");
392 							prs_buff(arg->argval);
393 							arg = arg->argnxt;
394 						}
395 
396 						prs_buff(")");
397 						prf(swl->regcom);
398 						prs_buff(";;");
399 						swl = swl->regnxt;
400 					}
401 				}
402 				break;
403 			}
404 		}
405 
406 	sigchk();
407 }
408 
409 static void
410 prarg(struct argnod *argp)
411 {
412 	while (argp)
413 	{
414 		prs_buff(argp->argval);
415 		argp=argp->argnxt;
416 		if (argp)
417 			prc_buff(SPACE);
418 	}
419 }
420 
421 static void
422 prio(struct ionod *iop)
423 {
424 	int	iof;
425 	unsigned char	*ion;
426 
427 	while (iop)
428 	{
429 		iof = iop->iofile;
430 		ion = (unsigned char *) iop->ioname;
431 
432 		if (*ion)
433 		{
434 			prc_buff(SPACE);
435 
436 			prn_buff(iof & IOUFD);
437 
438 			if (iof & IODOC)
439 				prs_buff("<<");
440 			else if (iof & IOMOV)
441 			{
442 				if (iof & IOPUT)
443 					prs_buff(">&");
444 				else
445 					prs_buff("<&");
446 
447 			}
448 			else if ((iof & IOPUT) == 0)
449 				prc_buff('<');
450 			else if (iof & IOAPP)
451 				prs_buff(">>");
452 			else
453 				prc_buff('>');
454 
455 			prs_buff(ion);
456 		}
457 		iop = iop->ionxt;
458 	}
459 }
460