![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to eval.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / sh|
Return to eval.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / sh |
1.1 root 1: /*
2: * sh/eval.c
3: * Bourne shell.
4: * Evaluation of parameter substitution, command substitution,
5: * blank interpretation, and file name generation.
6: */
7:
8: #include "sh.h"
9:
10: char *arcp; /* character position in argument */
11: int argf = 1; /* First argument flag */
12: int argg = 0; /* Glob seek, escape quoted glob chars */
13: int argq = 0; /* Quotation flag, no blanks or glob */
14:
15: /*
16: * Evaluate a string.
17: */
18: eval(cp, f)
19: char *cp;
20: {
21: register int m, c;
22:
23: strp = strt;
24: arcp = cp;
25: argf = 1;
26: if (f==EHERE) {
27: m = MHERE;
28: argq = 2;
29: } else if (f==EWORD) {
30: m = MNQUO;
31: argq = 2;
32: } else {
33: m = MNQUO;
34: argq = 0;
35: }
36: argg = (f==EARGS || f==EPATT);
37:
38: while ((c = *arcp++) != '\0') {
39: if (!class(c, m)) {
40: add_char(c);
41: continue;
42: }
43: switch (c) {
44: case '"': /* m == MNQUO || m == MDQUO */
45: m = ((argq ^= 1) & 1) ? MDQUO : MNQUO;
46: if (m==MDQUO && strcmp(arcp, "$@\"")!=0)
47: argf = 0;
48: continue;
49: case '\'': /* m == MNQUO */
50: while ((c = *arcp++) != '\'')
51: add_quoted(c);
52: argf = 0;
53: continue;
54: case '\\': /* m == MDQUO || m == MNQUO */
55: c = *arcp++;
56: if (m != MNQUO && ! class(c, m)) {
57: add_char('\\');
58: add_char(c);
59: } else
60: add_quoted(c);
61: argf = 0;
62: continue;
63: case '$': /* m == MNQUO || m = MDQUO */
64: variable();
65: continue;
66: case '`': /* m == MNQUO || m = MDQUO */
67: graves();
68: continue;
69: default:
70: add_char(c);
71: continue;
72: }
73: }
74: if (f==EARGS)
75: end_arg();
76: else
77: *strp++ = '\0';
78: }
79:
80: /*
81: * Read the name of a shell variable and perform the appropriate substitution.
82: * Doesn't check for end of buffer.
83: */
84: variable()
85: {
86: VAR *vp;
87: int s;
88: char *wp, *sav;
89: register int c, count, quote;
90: register char *cp, *pp;
91:
92: cp = strp;
93: s = '\0';
94: c = *arcp++;
95: if (class(c, MSVAR)) {
96: special(c);
97: return;
98: } else if (class(c, MRVAR)) {
99: while (class(c, MRVAR)) {
100: *cp++ = c;
101: c = *arcp++;
102: }
103: --arcp;
104: } else if (c != '{') {
105: /* Not a legal variable name, put it back. */
106: add_char('$');
107: add_char(c);
108: return;
109: } else {
110: /* c == '{' */
111: if (index("#?$!-@*0123456789", arcp[0]) != NULL && arcp[1] == '}') {
112: /* Allow specials of the form "${?}" etc. */
113: special(arcp[0]);
114: arcp += 2;
115: return;
116: }
117: while (index("}-=?+", c = *arcp++) == NULL)
118: *cp++ = c;
119: if (c != '}') {
120: /* ${VAR [-=?+] token} */
121: s = c;
122: if (cp[-1] == ':')
123: --cp; /* allow e.g. ${VAR:=foo} */
124: *cp++ = '=';
125: wp = cp;
126: if ((quote = *arcp) == '"' || quote =='\'')
127: ++arcp;
128: else
129: quote = 0;
130: for (count = 1; ; ) {
131: c = *arcp++;
132: if (c == '}' && count-- == 1)
133: break;
134: else if (c == '$' && quote != '\'') {
135: /*
136: * steve 6/24/92
137: * This truly sleazy hack handles e.g. "${V1-$V2}", oy.
138: * It doesn't do it very well, paying no attention to quotes (for example).
139: * The recursive call to variable() should be straightforward but is not,
140: * the hacky way this module uses globals like strp requires the save/restore.
141: */
142: sav = strp;
143: strp = cp;
144: variable();
145: cp = strp;
146: strp = sav;
147: continue;
148: } else if (c == '{')
149: ++count;
150: else if (quote != 0 && c == quote) {
151: quote = 0;
152: continue;
153: }
154: *cp++ = c;
155: }
156: }
157: }
158: *cp++ = '\0';
159: if (class((c = *strp), MDIGI)) {
160: if ((c -= '1') >= sargc)
161: pp = NULL;
162: else
163: pp = sargp[c];
164: } else if (namevar(strp) == 0) {
165: eillvar(strp);
166: return;
167: } else {
168: pp = NULL;
169: if ((vp=findvar(strp)) != NULL) {
170: pp = convvar(vp);
171: if (*pp == '\0')
172: pp = NULL; /* regard value "" as not set */
173: }
174: }
175: switch (s) {
176: case '\0':
177: if (uflag!=0 && pp==NULL)
178: enotdef(strp);
179: break;
180: case '-':
181: if (pp == NULL)
182: pp = wp;
183: break;
184: case '=':
185: if (pp == NULL) {
186: pp = wp;
187: if (class(*strp, MDIGI)) {
188: printe("Illegal substitution");
189: return;
190: }
191: setsvar(strp);
192: }
193: break;
194: case '?':
195: if (pp != NULL)
196: break;
197: if (*wp != '\0')
198: prints("%s\n", wp);
199: else {
200: *--wp = '\0';
201: enotdef(strp);
202: }
203: reset(RUABORT);
204: NOTREACHED;
205: case '+':
206: if (pp != NULL)
207: pp = wp;
208: break;
209: }
210: if (pp == NULL)
211: return;
212: while ((c = *pp++) != '\0')
213: add_char(c);
214: }
215:
216: /*
217: * Return the value of the special shell variables.
218: * No check for end of buffer.
219: */
220: special(n)
221: register int n;
222: {
223: register char *sp;
224: register int flag;
225:
226: sp = strp;
227: switch (n) {
228: case '#':
229: n = sargc;
230: goto maked;
231: case '?':
232: n = slret;
233: goto maked;
234: case '$':
235: n = shpid;
236: goto maked;
237: case '!':
238: n = sback;
239: goto maked;
240: maked:
241: sprintf(sp, "%d", n);
242: break;
243: case '-':
244: for (sp = &eflag; sp <= &xflag; sp += 1)
245: if (*sp)
246: add_char(*sp);
247: return;
248: case '@':
249: case '*':
250: flag = (argq == 1 && n == '@');
251: for (n = 0; n < sargc; n++) {
252: if (n) {
253: argq ^= flag;
254: add_char(' ');
255: argq ^= flag;
256: }
257: sp = sargp[n];
258: while (*sp)
259: add_char(*sp++);
260: }
261: return;
262: case '0':
263: sp = sarg0;
264: break;
265: default:
266: if ((n-='1') >= sargc) {
267: if (uflag)
268: printe("Unset parameter: %c", n+'1');
269: return;
270: }
271: sp = sargp[n];
272: break;
273: }
274: while (*sp)
275: add_char(*sp++);
276: }
277:
278: /*
279: * Read and evaluate a command found between graves.
280: */
281: graves()
282: {
283: int pipev[2], f, oslret, oargf;
284: register FILE *fp;
285: register int c;
286: register int nnl;
287: char *cmdp;
288:
289: oargf = argf;
290: oslret = slret;
291: cmdp = arcp;
292: while ((c = *arcp++) != '`')
293: ;
294: if ((f = pipeline(pipev)) == 0) {
295: slret = oslret; /* in case grave command uses $? */
296: dup2(pipev[1], 1);
297: close(pipev[0]);
298: close(pipev[1]);
299: *--arcp = '\0';
300: exit(session(SARGS, cmdp));
301: NOTREACHED;
302: }
303: close(pipev[1]);
304: if ((fp=fdopen(pipev[0], "r")) == NULL) {
305: close(pipev[0]);
306: ecantfdop();
307: return;
308: }
309: argf = 1;
310: nnl = 0;
311: while ((c=getc(fp)) != EOF) {
312: if ( ! recover(IEVAL)) {
313: #ifdef VERBOSE
314: if (xflag) prints("Interrupt in eval\n");
315: #endif
316: errflag++;
317: break;
318: }
319: if (c=='\n')
320: ++nnl;
321: else {
322: while (nnl) {
323: nnl--;
324: add_char('\n');
325: }
326: add_char(c);
327: }
328: }
329: argf = oargf;
330: fclose(fp);
331: waitc(f);
332: }
333:
334: /*
335: * Add a character to the current argument.
336: * If no quotation is set, pick off blanks and globs.
337: */
338: add_char(c)
339: register int c;
340: {
341: if (argq==0) {
342: if (index(vifs, c) != NULL) {
343: end_arg();
344: return;
345: }
346: if (argg && class(c, MGLOB)) {
347: add_arg(c);
348: return;
349: }
350: }
351: add_quoted(c);
352: }
353:
354: /*
355: * Add a quoted character to the current argument.
356: * if argg is set, then glob characters are quoted with a \,
357: * as well as \ itself.
358: */
359: add_quoted(c) register int c;
360: {
361: if (argg && (class(c, MGLOB) || c == '\\'))
362: add_arg('\\');
363: add_arg(c);
364: }
365:
366: /*
367: * Add a character to the current argument
368: * and check for end of buffer.
369: */
370: add_arg(c) register int c;
371: {
372: if (strp >= &strt[STRSIZE]) /* Should do more */
373: etoolong();
374: else
375: *strp++ = c;
376: argf = 0;
377: }
378:
379: /*
380: * Terminate the current argument if it is non-empty.
381: * If argg is set, then glob the argument to expand globs
382: * or to simply remove any quotes.
383: */
384: end_arg()
385: {
386: if (argf != 0)
387: return;
388: *strp++ = '\0';
389: if (argg)
390: glob1(duplstr(strt, 0));
391: else {
392: nargv = addargl(nargv, duplstr(strt, 0));
393: nargc += 1;
394: }
395: strp = strt;
396: argf = 1;
397: return;
398: }
399:
400: /*
401: * Evaluate a here document.
402: * Unevaluated document is on u2, put the evaluated document there, too.
403: */
404: evalhere(u2)
405: {
406: register int u1;
407: register FILE *f2;
408: char buf[128];
409: char *tmp;
410:
411: tmp = shtmp();
412: if ((u1=creat(tmp, 0666))<0) {
413: ecantmake(tmp);
414: return -1;
415: }
416: if ((f2=fdopen(u2, "r"))==NULL) {
417: ecantfdop();
418: close(u1);
419: close(u2);
420: return -1;
421: }
422: while (fgets(buf, 128, f2) != NULL) {
423: eval(buf, EHERE);
424: write(u1, strt, strp-1-strt);
425: }
426: close(u1);
427: fclose(f2);
428: if ((u2 = open(tmp, 0))<0) {
429: ecantopen(tmp);
430: u2 = -1;
431: }
432: unlink(tmp);
433: return u2;
434: }
435:
436: /* end of sh/eval.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.