![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to var.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / a / usr / bob / korn|
Return to var.c CVS log | Up to [MW Coherent from dump] / coherent / a / usr / bob / korn |
1.1 root 1: static char *RCSid = "$Header: var.c,v 3.1 88/11/03 09:18:22 egisin Exp $";
2:
3: #include <stddef.h>
4: #include <stdlib.h>
5: #include <string.h>
6: #include <errno.h>
7: #include <setjmp.h>
8: #include <time.h>
9: #include <sys/types.h>
10: #include "sh.h"
11: #include "table.h"
12: #include "expand.h"
13:
14: /*
15: * Variables
16: *
17: * WARNING: unreadable code, needs a rewrite
18: *
19: * if (flag&INTEGER), val.i contains integer value, and type contains base.
20: * otherwise, (val.s + type) contains string value.
21: * if (flag&EXPORT), val.s contains "name=value" for E-Z exporting.
22: */
23: char null [] = "";
24: static struct tbl vtemp;
25: static void getspec(), setspec();
26: static void export ARGS((struct tbl *, char *val));
27: static int special ARGS ((char *name));
28:
29: /*
30: * create a new block for function calls and simple commands
31: * assume caller has allocated and set up e.loc
32: */
33: void
34: newblock()
35: {
36: register struct block *l = e.loc;
37: static char *empty[] = {""};
38:
39: ainit(&l->area);
40: l->argc = 0;
41: l->argv = empty;
42: l->exit = l->error = NULL;
43: tinit(&l->vars, &l->area);
44: tinit(&l->funs, &l->area);
45: }
46:
47: /*
48: * pop a block handling special variables
49: */
50: void
51: popblock()
52: {
53: register struct block *l = e.loc;
54: register struct tbl *vp, **vpp = l->vars.tbls;
55: register int i;
56:
57: e.loc = l->next; /* pop block */
58: for (i = l->vars.size; --i >= 0; )
59: if ((vp = *vpp++) != NULL && (vp->flag&SPECIAL))
60: setspec(global(vp->name));
61: afreeall(&l->area);
62: }
63:
64: /*
65: * Search for variable, if not found create globally.
66: */
67: struct tbl *
68: global(n)
69: register char *n;
70: {
71: register struct block *l = e.loc;
72: register struct tbl *vp;
73: register int c;
74: unsigned h = hash(n);
75:
76: c = n[0];
77: if (digit(c)) {
78: vp = &vtemp;
79: lastarea = ATEMP;
80: vp->flag = (DEFINED|RDONLY);
81: vp->type = 0;
82: *vp->name = c; /* should strncpy */
83: for (c = 0; digit(*n) && c < 1000; n++)
84: c = c*10 + *n-'0';
85: if (c <= l->argc)
86: setstr(vp, l->argv[c]);
87: return vp;
88: } else
89: if (!letter(c)) {
90: vp = &vtemp;
91: lastarea = ATEMP;
92: vp->flag = (DEFINED|RDONLY);
93: vp->type = 0;
94: *vp->name = c;
95: if (n[1] != '\0')
96: return vp;
97: vp->flag |= ISSET|INTEGER;
98: switch (c) {
99: case '$':
100: vp->val.i = getpid();
101: break;
102: case '!':
103: vp->val.i = async;
104: break;
105: case '?':
106: vp->val.i = exstat;
107: break;
108: case '#':
109: vp->val.i = l->argc;
110: break;
111: case '-':
112: vp->flag &= ~ INTEGER;
113: vp->val.s = getoptions();
114: break;
115: default:
116: vp->flag &= ~(ISSET|INTEGER);
117: }
118: return vp;
119: }
120: for (l = e.loc; l != NULL; l = l->next) {
121: vp = tsearch(&l->vars, n, h);
122: lastarea = &l->area;
123: if (vp != NULL)
124: return vp;
125: if (l->next == NULL)
126: break;
127: }
128: vp = tenter(&l->vars, n, h);
129: vp->flag |= DEFINED;
130: if (special(n))
131: vp->flag |= SPECIAL;
132: return vp;
133: }
134:
135: /*
136: * Search for local variable, if not found create locally.
137: */
138: struct tbl *
139: local(n)
140: register char *n;
141: {
142: register struct block *l = e.loc;
143: register struct tbl *vp;
144: unsigned h = hash(n);
145:
146: if (!letter(*n)) {
147: vp = &vtemp;
148: lastarea = ATEMP;
149: vp->flag = (DEFINED|RDONLY);
150: vp->type = 0;
151: return vp;
152: }
153: vp = tenter(&l->vars, n, h);
154: lastarea = &l->area;
155: vp->flag |= DEFINED;
156: if (special(n))
157: vp->flag |= SPECIAL;
158: return vp;
159: }
160:
161: /* get variable string value */
162: char *
163: strval(vp)
164: register struct tbl *vp;
165: {
166: register char *s;
167: static char strbuf[40];
168:
169: if ((vp->flag&SPECIAL))
170: getspec(vp);
171: if (!(vp->flag&ISSET))
172: return null; /* special to dollar() */
173: if (!(vp->flag&INTEGER)) /* string source */
174: s = vp->val.s + vp->type;
175: else { /* integer source */
176: register unsigned long n;
177: register int base;
178:
179: s = strbuf + sizeof(strbuf);
180: n = (vp->val.i < 0) ? -vp->val.i : vp->val.i;
181: base = (vp->type == 0) ? 10 : vp->type;
182:
183: *--s = '\0';
184: do {
185: *--s = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[n%base];
186: n /= base;
187: } while (n != 0);
188: /* todo: should we output base# ? */
189: if (vp->val.i < 0)
190: *--s = '-';
191: }
192: return s;
193: }
194:
195: /* get variable integer value */
196: long
197: intval(vp)
198: register struct tbl *vp;
199: {
200: register struct tbl *vq;
201:
202: if ((vp->flag&SPECIAL))
203: getspec(vp);
204: if ((vp->flag&INTEGER))
205: return vp->val.i;
206: vq = &vtemp;
207: vq->flag = (INTEGER);
208: vq->type = 0;
209: strint(vq, vp);
210: return vq->val.i;
211: }
212:
213: /* set variable to string value */
214: void
215: setstr(vq, s)
216: register struct tbl *vq;
217: char *s;
218: {
219: if (!(vq->flag&INTEGER)) { /* string dest */
220: if ((vq->flag&ALLOC))
221: afree((Void*)vq->val.s, lastarea);
222: vq->flag &= ~ (ISSET|ALLOC);
223: vq->type = 0;
224: if ((vq->flag&EXPORT))
225: export(vq, s);
226: else
227: vq->val.s = strsave(s, lastarea);
228: vq->flag |= ALLOC;
229: } else { /* integer dest */
230: register struct tbl *vp = &vtemp;
231: vp->flag = (DEFINED|ISSET);
232: vp->type = 0;
233: vp->val.s = s;
234: strint(vq, vp);
235: }
236: vq->flag |= ISSET;
237: if ((vq->flag&SPECIAL))
238: setspec(vq);
239: }
240:
241: /* convert variable to integer variable */
242: struct tbl *
243: strint(vq, vp)
244: register struct tbl *vq, *vp;
245: {
246: register char *s = vp->val.s + vp->type;
247: register int c;
248: int base, neg = 0;
249:
250: vq->flag |= INTEGER;
251: if ((vp->flag&INTEGER)) {
252: vq->val.i = vp->val.i;
253: return vq;
254: }
255: vq->val.i = 0;
256: base = 10;
257: for (c = *s++; c ; c = *s++)
258: if (c == '-') {
259: neg++;
260: } else if (c == '#') {
261: base = vq->type = vq->val.i;
262: vq->val.i = 0;
263: } else if (letnum(c)) {
264: if ('0' <= c && c <= '9')
265: c -= '0';
266: else if ('a' <= c && c <= 'z') /* fuck EBCDIC */
267: c -= 'a'-10;
268: else if ('A' <= c && c <= 'Z')
269: c -= 'A'-10;
270: vq->val.i = (vq->val.i*base) + c;
271: } else
272: break;
273: if (neg)
274: vq->val.i = -vq->val.i;
275: if (vq->type < 2 || vq->type > 36)
276: vq->type = 0; /* default base (10) */
277: return vq;
278: }
279:
280: /* set variable to integer */
281: void
282: setint(vq, n)
283: register struct tbl *vq;
284: long n;
285: {
286: if (!(vq->flag&INTEGER)) {
287: register struct tbl *vp = &vtemp;
288: vp->flag = (ISSET|INTEGER);
289: vp->type = 0;
290: vp->val.i = n;
291: setstr(vq, strval(vp)); /* ? */
292: } else
293: vq->val.i = n;
294: vq->flag |= ISSET;
295: if ((vq->flag&SPECIAL))
296: setspec(vq);
297: }
298:
299: /* set variable from enviroment */
300: import(thing)
301: char *thing;
302: {
303: register struct tbl *vp;
304: register char *val;
305:
306: val = strchr(thing, '=');
307: if (val == NULL)
308: return 0;
309: *val = '\0';
310: vp = local(thing);
311: *val++ = '=';
312: vp->flag |= DEFINED|ISSET|EXPORT;
313: vp->val.s = thing;
314: vp->type = val - thing;
315: if ((vp->flag&SPECIAL))
316: setspec(vp);
317: return 1;
318: }
319:
320: /*
321: * make vp->val.s be "name=value" for quick exporting.
322: */
323: static void
324: export(vp, val)
325: register struct tbl *vp;
326: char *val;
327: {
328: register char *cp, *xp;
329: char *op = (vp->flag&ALLOC) ? vp->val.s : NULL;
330:
331: xp = (char*)alloc(strlen(vp->name) + strlen(val) + 2, lastarea);
332: vp->flag |= ALLOC;
333: vp->val.s = xp;
334: for (cp = vp->name; (*xp = *cp++) != '\0'; xp++)
335: ;
336: *xp++ = '=';
337: vp->type = xp - vp->val.s; /* offset to value */
338: for (cp = val; (*xp++ = *cp++) != '\0'; )
339: ;
340: if (op != NULL)
341: afree((Void*)op, lastarea);
342: }
343:
344: /*
345: * lookup variable (according to (set&LOCAL)),
346: * set its attributes (INTEGER, RDONLY, EXPORT, TRACE),
347: * and optionally set its value if an assignment.
348: */
349: struct tbl *
350: typeset(var, set, clr)
351: register char *var;
352: int clr, set;
353: {
354: register struct tbl *vp;
355: register char *val;
356:
357: /* check for valid variable name, search for value */
358: val = var;
359: if (!letter(*val))
360: return NULL;
361: for (val++; *val != '\0'; val++)
362: if (*val == '=')
363: break;
364: else if (letnum(*val))
365: ;
366: else
367: return NULL;
368: if (*val == '=')
369: *val = '\0';
370: else
371: val = NULL;
372: vp = (set&LOCAL) ? local(var) : global(var);
373: set &= ~ LOCAL;
374: if (val != NULL)
375: *val++ = '=';
376:
377: if (!(vp->flag&ISSET))
378: vp->flag = vp->flag & ~clr | set;
379: else
380: if (!(vp->flag&INTEGER) && (set&INTEGER)) {
381: /* string to integer */
382: vtemp.flag = (ISSET);
383: vtemp.type = 0;
384: vtemp.val.s = vp->val.s + vp->type;
385: if ((vp->flag&ALLOC))
386: afree((Void*)vp->val.s, lastarea); /* dangerous, used later */
387: vp->flag &= ~ ALLOC;
388: vp->flag |= INTEGER;
389: vp->type = 0;
390: strint(vp, &vtemp);
391: } else
392: if ((clr&INTEGER) && (vp->flag&INTEGER)) {
393: /* integer to string */
394: vtemp.val.s = strval(vp);
395: vp->flag &= ~ INTEGER;
396: setstr(vp, vtemp.val.s);
397: }
398:
399: vp->flag = vp->flag & ~clr | set;
400:
401: if (val != NULL) {
402: if ((vp->flag&RDONLY))
403: errorf("cannot set readonly %s\n", var);
404: if ((vp->flag&INTEGER))
405: /* setstr should be able to handle this */
406: (void)evaluate(var);
407: else
408: setstr(vp, val);
409: }
410:
411: if ((vp->flag&EXPORT) && !(vp->flag&INTEGER) && vp->type == 0)
412: export(vp, (vp->flag&ISSET) ? vp->val.s : null);
413:
414: return vp;
415: }
416:
417: void
418: unset(vp)
419: register struct tbl *vp;
420: {
421: if ((vp->flag&ALLOC))
422: afree((Void*)vp->val.s, lastarea);
423: vp->flag &= ~ (ALLOC|ISSET);
424: }
425:
426: int
427: isassign(s)
428: register char *s;
429: {
430: if (!letter(*s))
431: return (0);
432: for (s++; *s != '='; s++)
433: if (*s == 0 || !letnum(*s))
434: return (0);
435: return (1);
436: }
437:
438: /*
439: * Make the exported environment from the exported names in the dictionary.
440: */
441: char **
442: makenv()
443: {
444: struct block *l = e.loc;
445: XPtrV env;
446: register struct tbl *vp, **vpp;
447: register int i;
448:
449: XPinit(env, 64);
450: for (l = e.loc; l != NULL; l = l->next)
451: for (vpp = l->vars.tbls, i = l->vars.size; --i >= 0; )
452: if ((vp = *vpp++) != NULL
453: && (vp->flag&(ISSET|EXPORT)) == (ISSET|EXPORT)) {
454: register struct block *l2;
455: register struct tbl *vp2;
456: unsigned h = hash(vp->name);
457:
458: lastarea = &l->area;
459:
460: /* unexport any redefined instances */
461: for (l2 = l->next; l2 != NULL; l2 = l2->next) {
462: vp2 = tsearch(&l2->vars, vp->name, h);
463: if (vp2 != NULL)
464: vp2->flag &= ~ EXPORT;
465: }
466: if ((vp->flag&INTEGER)) {
467: /* integer to string */
468: char *val;
469: val = strval(vp);
470: vp->flag &= ~ INTEGER;
471: setstr(vp, val);
472: }
473: XPput(env, vp->val.s);
474: }
475: XPput(env, NULL);
476: return (char **) XPclose(env);
477: }
478:
479: /*
480: * handle special variables with side effects - PATH, SECONDS.
481: */
482:
483: static int
484: special(name)
485: register char * name;
486: {
487: if (strcmp("PATH", name) == 0)
488: return V_PATH;
489: if (strcmp("IFS", name) == 0)
490: return V_IFS;
491: if (strcmp("SECONDS", name) == 0)
492: return V_SECONDS;
493: if (strcmp("OPTIND", name) == 0)
494: return V_OPTIND;
495: return V_NONE;
496: }
497:
498: extern time_t time();
499: static time_t seconds; /* time SECONDS last set */
500:
501: static void
502: getspec(vp)
503: register struct tbl *vp;
504: {
505: switch (special(vp->name)) {
506: case V_SECONDS:
507: vp->flag &= ~ SPECIAL;
508: setint(vp, time((time_t *)0) - seconds);
509: vp->flag |= SPECIAL;
510: break;
511: }
512: }
513:
514: static void
515: setspec(vp)
516: register struct tbl *vp;
517: {
518: switch (special(vp->name)) {
519: case V_PATH:
520: path = strval(vp);
521: flushcom(1); /* clear tracked aliases */
522: break;
523: case V_IFS:
524: setctypes(strval(vp), C_IFS);
525: break;
526: case V_SECONDS:
527: seconds = time((time_t *)0);
528: break;
529: case V_OPTIND:
530: if (intval(vp) == 1)
531: resetopts();
532: break;
533: }
534: }
535:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.