![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to name.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / bin / sh|
Return to name.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / bin / sh |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)name.c 4.4 10/31/85";
3: #endif
4:
5: #
6: /*
7: * UNIX shell
8: *
9: * S. R. Bourne
10: * Bell Telephone Laboratories
11: *
12: */
13:
14: #include "defs.h"
15:
16: PROC BOOL chkid();
17:
18:
19: NAMNOD ps2nod = { NIL, NIL, ps2name},
20: fngnod = { NIL, NIL, fngname},
21: pathnod = { NIL, NIL, pathname},
22: ifsnod = { NIL, NIL, ifsname},
23: ps1nod = { &pathnod, &ps2nod, ps1name},
24: homenod = { &fngnod, &ifsnod, homename},
25: mailnod = { &homenod, &ps1nod, mailname};
26:
27: NAMPTR namep = &mailnod;
28:
29:
30: /* ======== variable and string handling ======== */
31:
32: syslook(w,syswds)
33: STRING w;
34: SYSTAB syswds;
35: {
36: REG CHAR first;
37: REG STRING s;
38: REG SYSPTR syscan;
39:
40: syscan=syswds; first = *w;
41:
42: WHILE s=syscan->sysnam
43: DO IF first == *s
44: ANDF eq(w,s)
45: THEN return(syscan->sysval);
46: FI
47: syscan++;
48: OD
49: return(0);
50: }
51:
52: setlist(arg,xp)
53: REG ARGPTR arg;
54: INT xp;
55: {
56: WHILE arg
57: DO REG STRING s=mactrim(arg->argval);
58: setname(s, xp);
59: arg=arg->argnxt;
60: IF flags&execpr
61: THEN prs(s);
62: IF arg THEN blank(); ELSE newline(); FI
63: FI
64: OD
65: }
66:
67: VOID setname(argi, xp)
68: STRING argi;
69: INT xp;
70: {
71: REG STRING argscan=argi;
72: REG NAMPTR n;
73:
74: IF letter(*argscan)
75: THEN WHILE alphanum(*argscan) DO argscan++ OD
76: IF *argscan=='='
77: THEN *argscan = 0;
78: n=lookup(argi);
79: *argscan++ = '=';
80: attrib(n, xp);
81: IF xp&N_ENVNAM
82: THEN
83: /*
84: * Importing IFS can be very dangerous
85: */
86: IF !bcmp(argi, "IFS=", sizeof("IFS=") - 1)
87: THEN
88: int uid;
89: IF (uid = getuid())!=geteuid() ORF !uid
90: THEN
91: return;
92: FI
93: FI
94: n->namenv = n->namval = argscan;
95: ELSE assign(n, argscan);
96: FI
97: return;
98: FI
99: FI
100: failed(argi,notid);
101: }
102:
103: replace(a, v)
104: REG STRING *a;
105: STRING v;
106: {
107: free(*a); *a=make(v);
108: }
109:
110: dfault(n,v)
111: NAMPTR n;
112: STRING v;
113: {
114: IF n->namval==0
115: THEN assign(n,v)
116: FI
117: }
118:
119: assign(n,v)
120: NAMPTR n;
121: STRING v;
122: {
123: IF n->namflg&N_RDONLY
124: THEN failed(n->namid,wtfailed);
125: ELSE replace(&n->namval,v);
126: FI
127: }
128:
129: INT readvar(names)
130: STRING *names;
131: {
132: FILEBLK fb;
133: REG FILE f = &fb;
134: REG CHAR c;
135: REG INT rc=0;
136: NAMPTR n=lookup(*names++); /* done now to avoid storage mess */
137: STKPTR rel=relstak();
138:
139: push(f); initf(dup(0));
140: IF lseek(0,0L,1)==-1
141: THEN f->fsiz=1;
142: FI
143:
144: LOOP c=nextc(0);
145: IF (*names ANDF any(c, ifsnod.namval)) ORF eolchar(c)
146: THEN zerostak();
147: assign(n,absstak(rel)); setstak(rel);
148: IF *names
149: THEN n=lookup(*names++);
150: ELSE n=0;
151: FI
152: IF eolchar(c)
153: THEN break;
154: FI
155: ELSE pushstak(c);
156: FI
157: POOL
158: WHILE n
159: DO assign(n, nullstr);
160: IF *names THEN n=lookup(*names++); ELSE n=0; FI
161: OD
162:
163: IF eof THEN rc=1 FI
164: lseek(0, (long)(f->fnxt-f->fend), 1);
165: pop();
166: return(rc);
167: }
168:
169: assnum(p, i)
170: STRING *p;
171: INT i;
172: {
173: itos(i); replace(p,numbuf);
174: }
175:
176: STRING make(v)
177: STRING v;
178: {
179: REG STRING p;
180:
181: IF v
182: THEN movstr(v,p=alloc(length(v)));
183: return(p);
184: ELSE return(0);
185: FI
186: }
187:
188:
189: NAMPTR lookup(nam)
190: REG STRING nam;
191: {
192: REG NAMPTR nscan=namep;
193: REG NAMPTR *prev;
194: INT LR;
195:
196: IF !chkid(nam)
197: THEN failed(nam,notid);
198: FI
199: WHILE nscan
200: DO IF (LR=cf(nam,nscan->namid))==0
201: THEN return(nscan);
202: ELIF LR<0
203: THEN prev = &(nscan->namlft);
204: ELSE prev = &(nscan->namrgt);
205: FI
206: nscan = *prev;
207: OD
208:
209: /* add name node */
210: nscan=alloc(sizeof *nscan);
211: nscan->namlft=nscan->namrgt=NIL;
212: nscan->namid=make(nam);
213: nscan->namval=0; nscan->namflg=N_DEFAULT; nscan->namenv=0;
214: return(*prev = nscan);
215: }
216:
217: LOCAL BOOL chkid(nam)
218: STRING nam;
219: {
220: REG CHAR * cp=nam;
221:
222: IF !letter(*cp)
223: THEN return(FALSE);
224: ELSE WHILE *++cp
225: DO IF !alphanum(*cp)
226: THEN return(FALSE);
227: FI
228: OD
229: FI
230: return(TRUE);
231: }
232:
233: LOCAL VOID (*namfn)();
234: namscan(fn)
235: VOID (*fn)();
236: {
237: namfn=fn;
238: namwalk(namep);
239: }
240:
241: LOCAL VOID namwalk(np)
242: REG NAMPTR np;
243: {
244: IF np
245: THEN namwalk(np->namlft);
246: (*namfn)(np);
247: namwalk(np->namrgt);
248: FI
249: }
250:
251: VOID printnam(n)
252: NAMPTR n;
253: {
254: REG STRING s;
255:
256: sigchk();
257: IF s=n->namval
258: THEN prs(n->namid);
259: prc('='); prs(s);
260: newline();
261: FI
262: }
263:
264: LOCAL STRING staknam(n)
265: REG NAMPTR n;
266: {
267: REG STRING p;
268:
269: p=movstr(n->namid,staktop);
270: p=movstr("=",p);
271: p=movstr(n->namval,p);
272: return(getstak(p+1-ADR(stakbot)));
273: }
274:
275: VOID exname(n)
276: REG NAMPTR n;
277: {
278: IF n->namflg&N_EXPORT
279: THEN free(n->namenv);
280: n->namenv = make(n->namval);
281: ELSE free(n->namval);
282: n->namval = make(n->namenv);
283: FI
284: }
285:
286: VOID printflg(n)
287: REG NAMPTR n;
288: {
289: IF n->namflg&N_EXPORT
290: THEN prs(export); blank();
291: FI
292: IF n->namflg&N_RDONLY
293: THEN prs(readonly); blank();
294: FI
295: IF n->namflg&(N_EXPORT|N_RDONLY)
296: THEN prs(n->namid); newline();
297: FI
298: }
299:
300: VOID setupenv()
301: {
302: REG STRING *e=environ;
303:
304: WHILE *e
305: DO setname(*e++, N_ENVNAM) OD
306: }
307:
308: LOCAL INT namec;
309:
310: VOID countnam(n)
311: NAMPTR n;
312: {
313: namec++;
314: }
315:
316: LOCAL STRING *argnam;
317:
318: VOID pushnam(n)
319: NAMPTR n;
320: {
321: IF n->namval
322: THEN *argnam++ = staknam(n);
323: FI
324: }
325:
326: STRING *setenv()
327: {
328: REG STRING *er;
329:
330: namec=0;
331: namscan(countnam);
332: argnam = er = getstak(namec*BYTESPERWORD+BYTESPERWORD);
333: namscan(pushnam);
334: *argnam++ = 0;
335: return(er);
336: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.