eval.c revision 1.4 1 1.1 cgd /*-
2 1.1 cgd * Copyright (c) 1991 The Regents of the University of California.
3 1.1 cgd * All rights reserved.
4 1.1 cgd *
5 1.1 cgd * This code is derived from software contributed to Berkeley by
6 1.1 cgd * Kenneth Almquist.
7 1.1 cgd *
8 1.1 cgd * Redistribution and use in source and binary forms, with or without
9 1.1 cgd * modification, are permitted provided that the following conditions
10 1.1 cgd * are met:
11 1.1 cgd * 1. Redistributions of source code must retain the above copyright
12 1.1 cgd * notice, this list of conditions and the following disclaimer.
13 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
14 1.1 cgd * notice, this list of conditions and the following disclaimer in the
15 1.1 cgd * documentation and/or other materials provided with the distribution.
16 1.1 cgd * 3. All advertising materials mentioning features or use of this software
17 1.1 cgd * must display the following acknowledgement:
18 1.1 cgd * This product includes software developed by the University of
19 1.1 cgd * California, Berkeley and its contributors.
20 1.1 cgd * 4. Neither the name of the University nor the names of its contributors
21 1.1 cgd * may be used to endorse or promote products derived from this software
22 1.1 cgd * without specific prior written permission.
23 1.1 cgd *
24 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 1.1 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 1.1 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 1.1 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 1.1 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 1.1 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 1.1 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 1.1 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 1.1 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 1.1 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 1.1 cgd * SUCH DAMAGE.
35 1.1 cgd */
36 1.1 cgd
37 1.1 cgd #ifndef lint
38 1.1 cgd static char sccsid[] = "@(#)eval.c 5.3 (Berkeley) 4/12/91";
39 1.4 jtc static char rcsid[] = "$Header: /tank/opengrok/rsync2/NetBSD/src/bin/sh/eval.c,v 1.4 1993/07/07 01:11:57 jtc Exp $";
40 1.1 cgd #endif /* not lint */
41 1.1 cgd
42 1.1 cgd /*
43 1.1 cgd * Evaluate a command.
44 1.1 cgd */
45 1.1 cgd
46 1.1 cgd #include "shell.h"
47 1.1 cgd #include "nodes.h"
48 1.1 cgd #include "syntax.h"
49 1.1 cgd #include "expand.h"
50 1.1 cgd #include "parser.h"
51 1.1 cgd #include "jobs.h"
52 1.1 cgd #include "eval.h"
53 1.1 cgd #include "builtins.h"
54 1.1 cgd #include "options.h"
55 1.1 cgd #include "exec.h"
56 1.1 cgd #include "redir.h"
57 1.1 cgd #include "input.h"
58 1.1 cgd #include "output.h"
59 1.1 cgd #include "trap.h"
60 1.1 cgd #include "var.h"
61 1.1 cgd #include "memalloc.h"
62 1.1 cgd #include "error.h"
63 1.1 cgd #include "mystring.h"
64 1.1 cgd #include <signal.h>
65 1.1 cgd
66 1.1 cgd
67 1.1 cgd /* flags in argument to evaltree */
68 1.1 cgd #define EV_EXIT 01 /* exit after evaluating tree */
69 1.1 cgd #define EV_TESTED 02 /* exit status is checked; ignore -e flag */
70 1.1 cgd #define EV_BACKCMD 04 /* command executing within back quotes */
71 1.1 cgd
72 1.1 cgd
73 1.1 cgd /* reasons for skipping commands (see comment on breakcmd routine) */
74 1.1 cgd #define SKIPBREAK 1
75 1.1 cgd #define SKIPCONT 2
76 1.1 cgd #define SKIPFUNC 3
77 1.1 cgd
78 1.1 cgd MKINIT int evalskip; /* set if we are skipping commands */
79 1.1 cgd STATIC int skipcount; /* number of levels to skip */
80 1.1 cgd MKINIT int loopnest; /* current loop nesting level */
81 1.1 cgd int funcnest; /* depth of function calls */
82 1.1 cgd
83 1.1 cgd
84 1.1 cgd char *commandname;
85 1.1 cgd struct strlist *cmdenviron;
86 1.1 cgd int exitstatus; /* exit status of last command */
87 1.1 cgd
88 1.1 cgd
89 1.1 cgd #ifdef __STDC__
90 1.1 cgd STATIC void evalloop(union node *);
91 1.1 cgd STATIC void evalfor(union node *);
92 1.1 cgd STATIC void evalcase(union node *, int);
93 1.1 cgd STATIC void evalsubshell(union node *, int);
94 1.1 cgd STATIC void expredir(union node *);
95 1.1 cgd STATIC void evalpipe(union node *);
96 1.1 cgd STATIC void evalcommand(union node *, int, struct backcmd *);
97 1.1 cgd STATIC void prehash(union node *);
98 1.1 cgd #else
99 1.1 cgd STATIC void evalloop();
100 1.1 cgd STATIC void evalfor();
101 1.1 cgd STATIC void evalcase();
102 1.1 cgd STATIC void evalsubshell();
103 1.1 cgd STATIC void expredir();
104 1.1 cgd STATIC void evalpipe();
105 1.1 cgd STATIC void evalcommand();
106 1.1 cgd STATIC void prehash();
107 1.1 cgd #endif
108 1.1 cgd
109 1.1 cgd
110 1.1 cgd
111 1.1 cgd /*
112 1.1 cgd * Called to reset things after an exception.
113 1.1 cgd */
114 1.1 cgd
115 1.1 cgd #ifdef mkinit
116 1.1 cgd INCLUDE "eval.h"
117 1.1 cgd
118 1.1 cgd RESET {
119 1.1 cgd evalskip = 0;
120 1.1 cgd loopnest = 0;
121 1.1 cgd funcnest = 0;
122 1.1 cgd }
123 1.1 cgd
124 1.1 cgd SHELLPROC {
125 1.1 cgd exitstatus = 0;
126 1.1 cgd }
127 1.1 cgd #endif
128 1.1 cgd
129 1.1 cgd
130 1.1 cgd
131 1.1 cgd /*
132 1.1 cgd * The eval commmand.
133 1.1 cgd */
134 1.1 cgd
135 1.1 cgd evalcmd(argc, argv)
136 1.1 cgd char **argv;
137 1.1 cgd {
138 1.1 cgd char *p;
139 1.1 cgd char *concat;
140 1.1 cgd char **ap;
141 1.1 cgd
142 1.1 cgd if (argc > 1) {
143 1.1 cgd p = argv[1];
144 1.1 cgd if (argc > 2) {
145 1.1 cgd STARTSTACKSTR(concat);
146 1.1 cgd ap = argv + 2;
147 1.1 cgd for (;;) {
148 1.1 cgd while (*p)
149 1.1 cgd STPUTC(*p++, concat);
150 1.1 cgd if ((p = *ap++) == NULL)
151 1.1 cgd break;
152 1.1 cgd STPUTC(' ', concat);
153 1.1 cgd }
154 1.1 cgd STPUTC('\0', concat);
155 1.1 cgd p = grabstackstr(concat);
156 1.1 cgd }
157 1.1 cgd evalstring(p);
158 1.1 cgd }
159 1.1 cgd return exitstatus;
160 1.1 cgd }
161 1.1 cgd
162 1.1 cgd
163 1.1 cgd /*
164 1.1 cgd * Execute a command or commands contained in a string.
165 1.1 cgd */
166 1.1 cgd
167 1.1 cgd void
168 1.1 cgd evalstring(s)
169 1.1 cgd char *s;
170 1.1 cgd {
171 1.1 cgd union node *n;
172 1.1 cgd struct stackmark smark;
173 1.1 cgd
174 1.1 cgd setstackmark(&smark);
175 1.1 cgd setinputstring(s, 1);
176 1.1 cgd while ((n = parsecmd(0)) != NEOF) {
177 1.1 cgd evaltree(n, 0);
178 1.1 cgd popstackmark(&smark);
179 1.1 cgd }
180 1.1 cgd popfile();
181 1.1 cgd popstackmark(&smark);
182 1.1 cgd }
183 1.1 cgd
184 1.1 cgd
185 1.1 cgd
186 1.1 cgd /*
187 1.1 cgd * Evaluate a parse tree. The value is left in the global variable
188 1.1 cgd * exitstatus.
189 1.1 cgd */
190 1.1 cgd
191 1.1 cgd void
192 1.1 cgd evaltree(n, flags)
193 1.1 cgd union node *n;
194 1.1 cgd {
195 1.1 cgd if (n == NULL) {
196 1.1 cgd TRACE(("evaltree(NULL) called\n"));
197 1.1 cgd return;
198 1.1 cgd }
199 1.1 cgd TRACE(("evaltree(0x%x: %d) called\n", (int)n, n->type));
200 1.1 cgd switch (n->type) {
201 1.1 cgd case NSEMI:
202 1.1 cgd evaltree(n->nbinary.ch1, 0);
203 1.1 cgd if (evalskip)
204 1.1 cgd goto out;
205 1.1 cgd evaltree(n->nbinary.ch2, flags);
206 1.1 cgd break;
207 1.1 cgd case NAND:
208 1.1 cgd evaltree(n->nbinary.ch1, EV_TESTED);
209 1.1 cgd if (evalskip || exitstatus != 0)
210 1.1 cgd goto out;
211 1.1 cgd evaltree(n->nbinary.ch2, flags);
212 1.1 cgd break;
213 1.1 cgd case NOR:
214 1.1 cgd evaltree(n->nbinary.ch1, EV_TESTED);
215 1.1 cgd if (evalskip || exitstatus == 0)
216 1.1 cgd goto out;
217 1.1 cgd evaltree(n->nbinary.ch2, flags);
218 1.1 cgd break;
219 1.1 cgd case NREDIR:
220 1.1 cgd expredir(n->nredir.redirect);
221 1.1 cgd redirect(n->nredir.redirect, REDIR_PUSH);
222 1.1 cgd evaltree(n->nredir.n, flags);
223 1.1 cgd popredir();
224 1.1 cgd break;
225 1.1 cgd case NSUBSHELL:
226 1.1 cgd evalsubshell(n, flags);
227 1.1 cgd break;
228 1.1 cgd case NBACKGND:
229 1.1 cgd evalsubshell(n, flags);
230 1.1 cgd break;
231 1.1 cgd case NIF: {
232 1.1 cgd int status = 0;
233 1.1 cgd
234 1.1 cgd evaltree(n->nif.test, EV_TESTED);
235 1.1 cgd if (evalskip)
236 1.1 cgd goto out;
237 1.1 cgd if (exitstatus == 0) {
238 1.1 cgd evaltree(n->nif.ifpart, flags);
239 1.1 cgd status = exitstatus;
240 1.1 cgd } else if (n->nif.elsepart) {
241 1.1 cgd evaltree(n->nif.elsepart, flags);
242 1.1 cgd status = exitstatus;
243 1.1 cgd }
244 1.1 cgd exitstatus = status;
245 1.1 cgd break;
246 1.1 cgd }
247 1.1 cgd case NWHILE:
248 1.1 cgd case NUNTIL:
249 1.1 cgd evalloop(n);
250 1.1 cgd break;
251 1.1 cgd case NFOR:
252 1.1 cgd evalfor(n);
253 1.1 cgd break;
254 1.1 cgd case NCASE:
255 1.1 cgd evalcase(n, flags);
256 1.1 cgd break;
257 1.1 cgd case NDEFUN:
258 1.1 cgd defun(n->narg.text, n->narg.next);
259 1.1 cgd exitstatus = 0;
260 1.1 cgd break;
261 1.1 cgd case NPIPE:
262 1.1 cgd evalpipe(n);
263 1.1 cgd break;
264 1.1 cgd case NCMD:
265 1.1 cgd evalcommand(n, flags, (struct backcmd *)NULL);
266 1.1 cgd break;
267 1.1 cgd default:
268 1.1 cgd out1fmt("Node type = %d\n", n->type);
269 1.1 cgd flushout(&output);
270 1.1 cgd break;
271 1.1 cgd }
272 1.1 cgd out:
273 1.1 cgd if (pendingsigs)
274 1.1 cgd dotrap();
275 1.1 cgd if ((flags & EV_EXIT) || (eflag && exitstatus && !(flags & EV_TESTED)))
276 1.1 cgd exitshell(exitstatus);
277 1.1 cgd }
278 1.1 cgd
279 1.1 cgd
280 1.1 cgd STATIC void
281 1.1 cgd evalloop(n)
282 1.1 cgd union node *n;
283 1.1 cgd {
284 1.1 cgd int status;
285 1.1 cgd
286 1.1 cgd loopnest++;
287 1.1 cgd status = 0;
288 1.1 cgd for (;;) {
289 1.1 cgd evaltree(n->nbinary.ch1, EV_TESTED);
290 1.1 cgd if (evalskip) {
291 1.1 cgd skipping: if (evalskip == SKIPCONT && --skipcount <= 0) {
292 1.1 cgd evalskip = 0;
293 1.1 cgd continue;
294 1.1 cgd }
295 1.1 cgd if (evalskip == SKIPBREAK && --skipcount <= 0)
296 1.1 cgd evalskip = 0;
297 1.1 cgd break;
298 1.1 cgd }
299 1.1 cgd if (n->type == NWHILE) {
300 1.1 cgd if (exitstatus != 0)
301 1.1 cgd break;
302 1.1 cgd } else {
303 1.1 cgd if (exitstatus == 0)
304 1.1 cgd break;
305 1.1 cgd }
306 1.1 cgd evaltree(n->nbinary.ch2, 0);
307 1.1 cgd status = exitstatus;
308 1.1 cgd if (evalskip)
309 1.1 cgd goto skipping;
310 1.1 cgd }
311 1.1 cgd loopnest--;
312 1.1 cgd exitstatus = status;
313 1.1 cgd }
314 1.1 cgd
315 1.1 cgd
316 1.1 cgd
317 1.1 cgd STATIC void
318 1.1 cgd evalfor(n)
319 1.1 cgd union node *n;
320 1.1 cgd {
321 1.1 cgd struct arglist arglist;
322 1.1 cgd union node *argp;
323 1.1 cgd struct strlist *sp;
324 1.1 cgd struct stackmark smark;
325 1.1 cgd
326 1.1 cgd setstackmark(&smark);
327 1.1 cgd arglist.lastp = &arglist.list;
328 1.1 cgd for (argp = n->nfor.args ; argp ; argp = argp->narg.next) {
329 1.1 cgd expandarg(argp, &arglist, 1);
330 1.1 cgd if (evalskip)
331 1.1 cgd goto out;
332 1.1 cgd }
333 1.1 cgd *arglist.lastp = NULL;
334 1.1 cgd
335 1.1 cgd exitstatus = 0;
336 1.1 cgd loopnest++;
337 1.1 cgd for (sp = arglist.list ; sp ; sp = sp->next) {
338 1.1 cgd setvar(n->nfor.var, sp->text, 0);
339 1.1 cgd evaltree(n->nfor.body, 0);
340 1.1 cgd if (evalskip) {
341 1.1 cgd if (evalskip == SKIPCONT && --skipcount <= 0) {
342 1.1 cgd evalskip = 0;
343 1.1 cgd continue;
344 1.1 cgd }
345 1.1 cgd if (evalskip == SKIPBREAK && --skipcount <= 0)
346 1.1 cgd evalskip = 0;
347 1.1 cgd break;
348 1.1 cgd }
349 1.1 cgd }
350 1.1 cgd loopnest--;
351 1.1 cgd out:
352 1.1 cgd popstackmark(&smark);
353 1.1 cgd }
354 1.1 cgd
355 1.1 cgd
356 1.1 cgd
357 1.1 cgd STATIC void
358 1.1 cgd evalcase(n, flags)
359 1.1 cgd union node *n;
360 1.1 cgd {
361 1.1 cgd union node *cp;
362 1.1 cgd union node *patp;
363 1.1 cgd struct arglist arglist;
364 1.1 cgd struct stackmark smark;
365 1.1 cgd
366 1.1 cgd setstackmark(&smark);
367 1.1 cgd arglist.lastp = &arglist.list;
368 1.1 cgd expandarg(n->ncase.expr, &arglist, 0);
369 1.1 cgd for (cp = n->ncase.cases ; cp && evalskip == 0 ; cp = cp->nclist.next) {
370 1.1 cgd for (patp = cp->nclist.pattern ; patp ; patp = patp->narg.next) {
371 1.1 cgd if (casematch(patp, arglist.list->text)) {
372 1.1 cgd if (evalskip == 0) {
373 1.1 cgd evaltree(cp->nclist.body, flags);
374 1.1 cgd }
375 1.1 cgd goto out;
376 1.1 cgd }
377 1.1 cgd }
378 1.1 cgd }
379 1.1 cgd out:
380 1.1 cgd popstackmark(&smark);
381 1.1 cgd }
382 1.1 cgd
383 1.1 cgd
384 1.1 cgd
385 1.1 cgd /*
386 1.1 cgd * Kick off a subshell to evaluate a tree.
387 1.1 cgd */
388 1.1 cgd
389 1.1 cgd STATIC void
390 1.1 cgd evalsubshell(n, flags)
391 1.1 cgd union node *n;
392 1.1 cgd {
393 1.1 cgd struct job *jp;
394 1.1 cgd int backgnd = (n->type == NBACKGND);
395 1.1 cgd
396 1.1 cgd expredir(n->nredir.redirect);
397 1.1 cgd jp = makejob(n, 1);
398 1.1 cgd if (forkshell(jp, n, backgnd) == 0) {
399 1.1 cgd if (backgnd)
400 1.1 cgd flags &=~ EV_TESTED;
401 1.1 cgd redirect(n->nredir.redirect, 0);
402 1.1 cgd evaltree(n->nredir.n, flags | EV_EXIT); /* never returns */
403 1.1 cgd }
404 1.1 cgd if (! backgnd) {
405 1.1 cgd INTOFF;
406 1.1 cgd exitstatus = waitforjob(jp);
407 1.1 cgd INTON;
408 1.1 cgd }
409 1.1 cgd }
410 1.1 cgd
411 1.1 cgd
412 1.1 cgd
413 1.1 cgd /*
414 1.1 cgd * Compute the names of the files in a redirection list.
415 1.1 cgd */
416 1.1 cgd
417 1.1 cgd STATIC void
418 1.1 cgd expredir(n)
419 1.1 cgd union node *n;
420 1.1 cgd {
421 1.1 cgd register union node *redir;
422 1.1 cgd
423 1.1 cgd for (redir = n ; redir ; redir = redir->nfile.next) {
424 1.1 cgd if (redir->type == NFROM
425 1.1 cgd || redir->type == NTO
426 1.1 cgd || redir->type == NAPPEND) {
427 1.1 cgd struct arglist fn;
428 1.1 cgd fn.lastp = &fn.list;
429 1.1 cgd expandarg(redir->nfile.fname, &fn, 0);
430 1.1 cgd redir->nfile.expfname = fn.list->text;
431 1.1 cgd }
432 1.1 cgd }
433 1.1 cgd }
434 1.1 cgd
435 1.1 cgd
436 1.1 cgd
437 1.1 cgd /*
438 1.1 cgd * Evaluate a pipeline. All the processes in the pipeline are children
439 1.1 cgd * of the process creating the pipeline. (This differs from some versions
440 1.1 cgd * of the shell, which make the last process in a pipeline the parent
441 1.1 cgd * of all the rest.)
442 1.1 cgd */
443 1.1 cgd
444 1.1 cgd STATIC void
445 1.1 cgd evalpipe(n)
446 1.1 cgd union node *n;
447 1.1 cgd {
448 1.1 cgd struct job *jp;
449 1.1 cgd struct nodelist *lp;
450 1.1 cgd int pipelen;
451 1.1 cgd int prevfd;
452 1.1 cgd int pip[2];
453 1.1 cgd
454 1.1 cgd TRACE(("evalpipe(0x%x) called\n", (int)n));
455 1.1 cgd pipelen = 0;
456 1.1 cgd for (lp = n->npipe.cmdlist ; lp ; lp = lp->next)
457 1.1 cgd pipelen++;
458 1.1 cgd INTOFF;
459 1.1 cgd jp = makejob(n, pipelen);
460 1.1 cgd prevfd = -1;
461 1.1 cgd for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
462 1.1 cgd prehash(lp->n);
463 1.1 cgd pip[1] = -1;
464 1.1 cgd if (lp->next) {
465 1.1 cgd if (pipe(pip) < 0) {
466 1.1 cgd close(prevfd);
467 1.1 cgd error("Pipe call failed");
468 1.1 cgd }
469 1.1 cgd }
470 1.1 cgd if (forkshell(jp, lp->n, n->npipe.backgnd) == 0) {
471 1.1 cgd INTON;
472 1.1 cgd if (prevfd > 0) {
473 1.1 cgd close(0);
474 1.1 cgd copyfd(prevfd, 0);
475 1.1 cgd close(prevfd);
476 1.1 cgd }
477 1.1 cgd if (pip[1] >= 0) {
478 1.1 cgd close(pip[0]);
479 1.1 cgd if (pip[1] != 1) {
480 1.1 cgd close(1);
481 1.1 cgd copyfd(pip[1], 1);
482 1.1 cgd close(pip[1]);
483 1.1 cgd }
484 1.1 cgd }
485 1.1 cgd evaltree(lp->n, EV_EXIT);
486 1.1 cgd }
487 1.1 cgd if (prevfd >= 0)
488 1.1 cgd close(prevfd);
489 1.1 cgd prevfd = pip[0];
490 1.1 cgd close(pip[1]);
491 1.1 cgd }
492 1.1 cgd INTON;
493 1.1 cgd if (n->npipe.backgnd == 0) {
494 1.1 cgd INTOFF;
495 1.1 cgd exitstatus = waitforjob(jp);
496 1.1 cgd TRACE(("evalpipe: job done exit status %d\n", exitstatus));
497 1.1 cgd INTON;
498 1.1 cgd }
499 1.1 cgd }
500 1.1 cgd
501 1.1 cgd
502 1.1 cgd
503 1.1 cgd /*
504 1.1 cgd * Execute a command inside back quotes. If it's a builtin command, we
505 1.1 cgd * want to save its output in a block obtained from malloc. Otherwise
506 1.1 cgd * we fork off a subprocess and get the output of the command via a pipe.
507 1.1 cgd * Should be called with interrupts off.
508 1.1 cgd */
509 1.1 cgd
510 1.1 cgd void
511 1.1 cgd evalbackcmd(n, result)
512 1.1 cgd union node *n;
513 1.1 cgd struct backcmd *result;
514 1.1 cgd {
515 1.1 cgd int pip[2];
516 1.1 cgd struct job *jp;
517 1.1 cgd struct stackmark smark; /* unnecessary */
518 1.1 cgd
519 1.1 cgd setstackmark(&smark);
520 1.1 cgd result->fd = -1;
521 1.1 cgd result->buf = NULL;
522 1.1 cgd result->nleft = 0;
523 1.1 cgd result->jp = NULL;
524 1.1 cgd if (n->type == NCMD) {
525 1.1 cgd evalcommand(n, EV_BACKCMD, result);
526 1.1 cgd } else {
527 1.1 cgd if (pipe(pip) < 0)
528 1.1 cgd error("Pipe call failed");
529 1.1 cgd jp = makejob(n, 1);
530 1.1 cgd if (forkshell(jp, n, FORK_NOJOB) == 0) {
531 1.1 cgd FORCEINTON;
532 1.1 cgd close(pip[0]);
533 1.1 cgd if (pip[1] != 1) {
534 1.1 cgd close(1);
535 1.1 cgd copyfd(pip[1], 1);
536 1.1 cgd close(pip[1]);
537 1.1 cgd }
538 1.1 cgd evaltree(n, EV_EXIT);
539 1.1 cgd }
540 1.1 cgd close(pip[1]);
541 1.1 cgd result->fd = pip[0];
542 1.1 cgd result->jp = jp;
543 1.1 cgd }
544 1.1 cgd popstackmark(&smark);
545 1.1 cgd TRACE(("evalbackcmd done: fd=%d buf=0x%x nleft=%d jp=0x%x\n",
546 1.1 cgd result->fd, result->buf, result->nleft, result->jp));
547 1.1 cgd }
548 1.1 cgd
549 1.1 cgd
550 1.1 cgd
551 1.1 cgd /*
552 1.1 cgd * Execute a simple command.
553 1.1 cgd */
554 1.1 cgd
555 1.1 cgd STATIC void
556 1.1 cgd evalcommand(cmd, flags, backcmd)
557 1.1 cgd union node *cmd;
558 1.1 cgd struct backcmd *backcmd;
559 1.1 cgd {
560 1.1 cgd struct stackmark smark;
561 1.1 cgd union node *argp;
562 1.1 cgd struct arglist arglist;
563 1.1 cgd struct arglist varlist;
564 1.1 cgd char **argv;
565 1.1 cgd int argc;
566 1.1 cgd char **envp;
567 1.1 cgd int varflag;
568 1.1 cgd struct strlist *sp;
569 1.1 cgd register char *p;
570 1.1 cgd int mode;
571 1.1 cgd int pip[2];
572 1.1 cgd struct cmdentry cmdentry;
573 1.1 cgd struct job *jp;
574 1.1 cgd struct jmploc jmploc;
575 1.1 cgd struct jmploc *volatile savehandler;
576 1.1 cgd char *volatile savecmdname;
577 1.1 cgd volatile struct shparam saveparam;
578 1.1 cgd struct localvar *volatile savelocalvars;
579 1.1 cgd volatile int e;
580 1.1 cgd char *lastarg;
581 1.1 cgd
582 1.1 cgd /* First expand the arguments. */
583 1.1 cgd TRACE(("evalcommand(0x%x, %d) called\n", (int)cmd, flags));
584 1.1 cgd setstackmark(&smark);
585 1.1 cgd arglist.lastp = &arglist.list;
586 1.1 cgd varlist.lastp = &varlist.list;
587 1.1 cgd varflag = 1;
588 1.1 cgd for (argp = cmd->ncmd.args ; argp ; argp = argp->narg.next) {
589 1.1 cgd p = argp->narg.text;
590 1.1 cgd if (varflag && is_name(*p)) {
591 1.1 cgd do {
592 1.1 cgd p++;
593 1.1 cgd } while (is_in_name(*p));
594 1.1 cgd if (*p == '=') {
595 1.1 cgd expandarg(argp, &varlist, 0);
596 1.1 cgd continue;
597 1.1 cgd }
598 1.1 cgd }
599 1.1 cgd expandarg(argp, &arglist, 1);
600 1.1 cgd varflag = 0;
601 1.1 cgd }
602 1.1 cgd *arglist.lastp = NULL;
603 1.1 cgd *varlist.lastp = NULL;
604 1.1 cgd expredir(cmd->ncmd.redirect);
605 1.1 cgd argc = 0;
606 1.1 cgd for (sp = arglist.list ; sp ; sp = sp->next)
607 1.1 cgd argc++;
608 1.1 cgd argv = stalloc(sizeof (char *) * (argc + 1));
609 1.1 cgd for (sp = arglist.list ; sp ; sp = sp->next)
610 1.1 cgd *argv++ = sp->text;
611 1.1 cgd *argv = NULL;
612 1.1 cgd lastarg = NULL;
613 1.1 cgd if (iflag && funcnest == 0 && argc > 0)
614 1.1 cgd lastarg = argv[-1];
615 1.1 cgd argv -= argc;
616 1.1 cgd
617 1.1 cgd /* Print the command if xflag is set. */
618 1.1 cgd if (xflag) {
619 1.1 cgd outc('+', &errout);
620 1.1 cgd for (sp = varlist.list ; sp ; sp = sp->next) {
621 1.1 cgd outc(' ', &errout);
622 1.1 cgd out2str(sp->text);
623 1.1 cgd }
624 1.1 cgd for (sp = arglist.list ; sp ; sp = sp->next) {
625 1.1 cgd outc(' ', &errout);
626 1.1 cgd out2str(sp->text);
627 1.1 cgd }
628 1.1 cgd outc('\n', &errout);
629 1.1 cgd flushout(&errout);
630 1.1 cgd }
631 1.1 cgd
632 1.1 cgd /* Now locate the command. */
633 1.1 cgd if (argc == 0) {
634 1.1 cgd cmdentry.cmdtype = CMDBUILTIN;
635 1.1 cgd cmdentry.u.index = BLTINCMD;
636 1.1 cgd } else {
637 1.1 cgd find_command(argv[0], &cmdentry, 1);
638 1.1 cgd if (cmdentry.cmdtype == CMDUNKNOWN) { /* command not found */
639 1.1 cgd exitstatus = 2;
640 1.1 cgd flushout(&errout);
641 1.1 cgd return;
642 1.1 cgd }
643 1.1 cgd /* implement the bltin builtin here */
644 1.1 cgd if (cmdentry.cmdtype == CMDBUILTIN && cmdentry.u.index == BLTINCMD) {
645 1.1 cgd for (;;) {
646 1.1 cgd argv++;
647 1.1 cgd if (--argc == 0)
648 1.1 cgd break;
649 1.1 cgd if ((cmdentry.u.index = find_builtin(*argv)) < 0) {
650 1.1 cgd outfmt(&errout, "%s: not found\n", *argv);
651 1.1 cgd exitstatus = 2;
652 1.1 cgd flushout(&errout);
653 1.1 cgd return;
654 1.1 cgd }
655 1.1 cgd if (cmdentry.u.index != BLTINCMD)
656 1.1 cgd break;
657 1.1 cgd }
658 1.1 cgd }
659 1.1 cgd }
660 1.1 cgd
661 1.1 cgd /* Fork off a child process if necessary. */
662 1.1 cgd if (cmd->ncmd.backgnd
663 1.1 cgd || cmdentry.cmdtype == CMDNORMAL && (flags & EV_EXIT) == 0
664 1.1 cgd || (flags & EV_BACKCMD) != 0
665 1.1 cgd && (cmdentry.cmdtype != CMDBUILTIN
666 1.1 cgd || cmdentry.u.index == DOTCMD
667 1.1 cgd || cmdentry.u.index == EVALCMD)) {
668 1.1 cgd jp = makejob(cmd, 1);
669 1.1 cgd mode = cmd->ncmd.backgnd;
670 1.1 cgd if (flags & EV_BACKCMD) {
671 1.1 cgd mode = FORK_NOJOB;
672 1.1 cgd if (pipe(pip) < 0)
673 1.1 cgd error("Pipe call failed");
674 1.1 cgd }
675 1.1 cgd if (forkshell(jp, cmd, mode) != 0)
676 1.1 cgd goto parent; /* at end of routine */
677 1.1 cgd if (flags & EV_BACKCMD) {
678 1.1 cgd FORCEINTON;
679 1.1 cgd close(pip[0]);
680 1.1 cgd if (pip[1] != 1) {
681 1.1 cgd close(1);
682 1.1 cgd copyfd(pip[1], 1);
683 1.1 cgd close(pip[1]);
684 1.1 cgd }
685 1.1 cgd }
686 1.1 cgd flags |= EV_EXIT;
687 1.1 cgd }
688 1.1 cgd
689 1.1 cgd /* This is the child process if a fork occurred. */
690 1.1 cgd /* Execute the command. */
691 1.1 cgd if (cmdentry.cmdtype == CMDFUNCTION) {
692 1.1 cgd trputs("Shell function: "); trargs(argv);
693 1.1 cgd redirect(cmd->ncmd.redirect, REDIR_PUSH);
694 1.1 cgd saveparam = shellparam;
695 1.1 cgd shellparam.malloc = 0;
696 1.1 cgd shellparam.nparam = argc - 1;
697 1.1 cgd shellparam.p = argv + 1;
698 1.1 cgd shellparam.optnext = NULL;
699 1.1 cgd INTOFF;
700 1.1 cgd savelocalvars = localvars;
701 1.1 cgd localvars = NULL;
702 1.1 cgd INTON;
703 1.1 cgd if (setjmp(jmploc.loc)) {
704 1.1 cgd if (exception == EXSHELLPROC)
705 1.1 cgd freeparam((struct shparam *)&saveparam);
706 1.1 cgd else {
707 1.1 cgd freeparam(&shellparam);
708 1.1 cgd shellparam = saveparam;
709 1.1 cgd }
710 1.1 cgd poplocalvars();
711 1.1 cgd localvars = savelocalvars;
712 1.1 cgd handler = savehandler;
713 1.1 cgd longjmp(handler->loc, 1);
714 1.1 cgd }
715 1.1 cgd savehandler = handler;
716 1.1 cgd handler = &jmploc;
717 1.1 cgd for (sp = varlist.list ; sp ; sp = sp->next)
718 1.1 cgd mklocal(sp->text);
719 1.1 cgd funcnest++;
720 1.1 cgd evaltree(cmdentry.u.func, 0);
721 1.1 cgd funcnest--;
722 1.1 cgd INTOFF;
723 1.1 cgd poplocalvars();
724 1.1 cgd localvars = savelocalvars;
725 1.1 cgd freeparam(&shellparam);
726 1.1 cgd shellparam = saveparam;
727 1.1 cgd handler = savehandler;
728 1.1 cgd popredir();
729 1.1 cgd INTON;
730 1.1 cgd if (evalskip == SKIPFUNC) {
731 1.1 cgd evalskip = 0;
732 1.1 cgd skipcount = 0;
733 1.1 cgd }
734 1.1 cgd if (flags & EV_EXIT)
735 1.1 cgd exitshell(exitstatus);
736 1.1 cgd } else if (cmdentry.cmdtype == CMDBUILTIN) {
737 1.1 cgd trputs("builtin command: "); trargs(argv);
738 1.1 cgd mode = (cmdentry.u.index == EXECCMD)? 0 : REDIR_PUSH;
739 1.1 cgd if (flags == EV_BACKCMD) {
740 1.1 cgd memout.nleft = 0;
741 1.1 cgd memout.nextc = memout.buf;
742 1.1 cgd memout.bufsize = 64;
743 1.1 cgd mode |= REDIR_BACKQ;
744 1.1 cgd }
745 1.1 cgd redirect(cmd->ncmd.redirect, mode);
746 1.1 cgd savecmdname = commandname;
747 1.1 cgd cmdenviron = varlist.list;
748 1.1 cgd e = -1;
749 1.1 cgd if (setjmp(jmploc.loc)) {
750 1.1 cgd e = exception;
751 1.1 cgd exitstatus = (e == EXINT)? SIGINT+128 : 2;
752 1.1 cgd goto cmddone;
753 1.1 cgd }
754 1.1 cgd savehandler = handler;
755 1.1 cgd handler = &jmploc;
756 1.1 cgd commandname = argv[0];
757 1.1 cgd argptr = argv + 1;
758 1.1 cgd optptr = NULL; /* initialize nextopt */
759 1.1 cgd exitstatus = (*builtinfunc[cmdentry.u.index])(argc, argv);
760 1.1 cgd flushall();
761 1.1 cgd cmddone:
762 1.1 cgd out1 = &output;
763 1.1 cgd out2 = &errout;
764 1.1 cgd freestdout();
765 1.1 cgd if (e != EXSHELLPROC) {
766 1.1 cgd commandname = savecmdname;
767 1.1 cgd if (flags & EV_EXIT) {
768 1.1 cgd exitshell(exitstatus);
769 1.1 cgd }
770 1.1 cgd }
771 1.1 cgd handler = savehandler;
772 1.1 cgd if (e != -1) {
773 1.1 cgd if (e != EXERROR || cmdentry.u.index == BLTINCMD
774 1.1 cgd || cmdentry.u.index == DOTCMD
775 1.1 cgd || cmdentry.u.index == EVALCMD
776 1.1 cgd || cmdentry.u.index == EXECCMD)
777 1.1 cgd exraise(e);
778 1.1 cgd FORCEINTON;
779 1.1 cgd }
780 1.1 cgd if (cmdentry.u.index != EXECCMD)
781 1.1 cgd popredir();
782 1.1 cgd if (flags == EV_BACKCMD) {
783 1.1 cgd backcmd->buf = memout.buf;
784 1.1 cgd backcmd->nleft = memout.nextc - memout.buf;
785 1.1 cgd memout.buf = NULL;
786 1.1 cgd }
787 1.1 cgd } else {
788 1.1 cgd trputs("normal command: "); trargs(argv);
789 1.1 cgd clearredir();
790 1.1 cgd redirect(cmd->ncmd.redirect, 0);
791 1.1 cgd if (varlist.list) {
792 1.1 cgd p = stalloc(strlen(pathval()) + 1);
793 1.1 cgd scopy(pathval(), p);
794 1.1 cgd } else {
795 1.1 cgd p = pathval();
796 1.1 cgd }
797 1.1 cgd for (sp = varlist.list ; sp ; sp = sp->next)
798 1.1 cgd setvareq(sp->text, VEXPORT|VSTACK);
799 1.1 cgd envp = environment();
800 1.1 cgd shellexec(argv, envp, p, cmdentry.u.index);
801 1.1 cgd /*NOTREACHED*/
802 1.1 cgd }
803 1.1 cgd goto out;
804 1.1 cgd
805 1.1 cgd parent: /* parent process gets here (if we forked) */
806 1.1 cgd if (mode == 0) { /* argument to fork */
807 1.1 cgd INTOFF;
808 1.1 cgd exitstatus = waitforjob(jp);
809 1.1 cgd INTON;
810 1.1 cgd } else if (mode == 2) {
811 1.1 cgd backcmd->fd = pip[0];
812 1.1 cgd close(pip[1]);
813 1.1 cgd backcmd->jp = jp;
814 1.1 cgd }
815 1.1 cgd
816 1.1 cgd out:
817 1.1 cgd if (lastarg)
818 1.1 cgd setvar("_", lastarg, 0);
819 1.1 cgd popstackmark(&smark);
820 1.1 cgd }
821 1.1 cgd
822 1.1 cgd
823 1.1 cgd
824 1.1 cgd /*
825 1.1 cgd * Search for a command. This is called before we fork so that the
826 1.1 cgd * location of the command will be available in the parent as well as
827 1.1 cgd * the child. The check for "goodname" is an overly conservative
828 1.1 cgd * check that the name will not be subject to expansion.
829 1.1 cgd */
830 1.1 cgd
831 1.1 cgd STATIC void
832 1.1 cgd prehash(n)
833 1.1 cgd union node *n;
834 1.1 cgd {
835 1.1 cgd struct cmdentry entry;
836 1.1 cgd
837 1.1 cgd if (n->type == NCMD && goodname(n->ncmd.args->narg.text))
838 1.1 cgd find_command(n->ncmd.args->narg.text, &entry, 0);
839 1.1 cgd }
840 1.1 cgd
841 1.1 cgd
842 1.1 cgd
843 1.1 cgd /*
844 1.1 cgd * Builtin commands. Builtin commands whose functions are closely
845 1.1 cgd * tied to evaluation are implemented here.
846 1.1 cgd */
847 1.1 cgd
848 1.1 cgd /*
849 1.1 cgd * No command given, or a bltin command with no arguments. Set the
850 1.1 cgd * specified variables.
851 1.1 cgd */
852 1.1 cgd
853 1.1 cgd bltincmd(argc, argv) char **argv; {
854 1.1 cgd listsetvar(cmdenviron);
855 1.1 cgd return exitstatus;
856 1.1 cgd }
857 1.1 cgd
858 1.1 cgd
859 1.1 cgd /*
860 1.1 cgd * Handle break and continue commands. Break, continue, and return are
861 1.1 cgd * all handled by setting the evalskip flag. The evaluation routines
862 1.1 cgd * above all check this flag, and if it is set they start skipping
863 1.1 cgd * commands rather than executing them. The variable skipcount is
864 1.1 cgd * the number of loops to break/continue, or the number of function
865 1.1 cgd * levels to return. (The latter is always 1.) It should probably
866 1.1 cgd * be an error to break out of more loops than exist, but it isn't
867 1.1 cgd * in the standard shell so we don't make it one here.
868 1.1 cgd */
869 1.1 cgd
870 1.1 cgd breakcmd(argc, argv) char **argv; {
871 1.1 cgd int n;
872 1.1 cgd
873 1.1 cgd n = 1;
874 1.1 cgd if (argc > 1)
875 1.1 cgd n = number(argv[1]);
876 1.1 cgd if (n > loopnest)
877 1.1 cgd n = loopnest;
878 1.1 cgd if (n > 0) {
879 1.1 cgd evalskip = (**argv == 'c')? SKIPCONT : SKIPBREAK;
880 1.1 cgd skipcount = n;
881 1.1 cgd }
882 1.1 cgd return 0;
883 1.1 cgd }
884 1.1 cgd
885 1.1 cgd
886 1.1 cgd /*
887 1.1 cgd * The return command.
888 1.1 cgd */
889 1.1 cgd
890 1.1 cgd returncmd(argc, argv) char **argv; {
891 1.1 cgd int ret;
892 1.1 cgd
893 1.1 cgd ret = exitstatus;
894 1.1 cgd if (argc > 1)
895 1.1 cgd ret = number(argv[1]);
896 1.1 cgd if (funcnest) {
897 1.1 cgd evalskip = SKIPFUNC;
898 1.1 cgd skipcount = 1;
899 1.1 cgd }
900 1.1 cgd return ret;
901 1.1 cgd }
902 1.1 cgd
903 1.4 jtc falsecmd(argc, argv) char **argv; {
904 1.4 jtc return 1;
905 1.4 jtc }
906 1.1 cgd
907 1.1 cgd truecmd(argc, argv) char **argv; {
908 1.1 cgd return 0;
909 1.1 cgd }
910 1.1 cgd
911 1.1 cgd
912 1.1 cgd execcmd(argc, argv) char **argv; {
913 1.1 cgd if (argc > 1) {
914 1.1 cgd iflag = 0; /* exit on error */
915 1.1 cgd setinteractive(0);
916 1.1 cgd #if JOBS
917 1.1 cgd jflag = 0;
918 1.1 cgd setjobctl(0);
919 1.1 cgd #endif
920 1.1 cgd shellexec(argv + 1, environment(), pathval(), 0);
921 1.1 cgd
922 1.1 cgd }
923 1.1 cgd return 0;
924 1.1 cgd }
925