![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sh.misc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd / csh|
Return to sh.misc.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / csh |
1.1 root 1: /* Copyright (c) 1979 Regents of the University of California */
2: #include "sh.h"
3:
4: /*
5: * C Shell
6: */
7:
8: letter(c)
9: register char c;
10: {
11:
12: return (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c == '_');
13: }
14:
15: digit(c)
16: register char c;
17: {
18:
19: return (c >= '0' && c <= '9');
20: }
21:
22: any(c, s)
23: register int c;
24: register char *s;
25: {
26:
27: while (*s)
28: if (*s++ == c)
29: return(1);
30: return(0);
31: }
32:
33: char *
34: calloc(i, j)
35: register int i;
36: int j;
37: {
38: register char *cp, *dp;
39:
40: i *= j;
41: cp = (char *) malloc(i);
42: if (cp == 0) {
43: child++;
44: error("Out of memory");
45: chdir("/usr/bill/cshcore");
46: abort();
47: }
48: dp = cp;
49: if (i > 0)
50: do
51: *dp++ = 0;
52: while (--i);
53: return (cp);
54: }
55:
56: cfree(p)
57: char *p;
58: {
59:
60: free(p);
61: }
62:
63: char **
64: blkend(up)
65: register char **up;
66: {
67:
68: while (*up)
69: up++;
70: return (up);
71: }
72:
73: blkpr(av)
74: register int *av;
75: {
76:
77: for (; *av; av++) {
78: printf("%s", *av);
79: if (av[1])
80: printf(" ");
81: }
82: }
83:
84: blklen(av)
85: register char **av;
86: {
87: register int i = 0;
88:
89: while (*av++)
90: i++;
91: return (i);
92: }
93:
94: char **
95: blkcpy(oav, bv)
96: char **oav;
97: register char **bv;
98: {
99: register char **av = oav;
100:
101: while (*av++ = *bv++)
102: continue;
103: return (oav);
104: }
105:
106: char **
107: blkcat(up, vp)
108: char **up, **vp;
109: {
110:
111: blkcpy(blkend(up), vp);
112: return (up);
113: }
114:
115: blkfree(av0)
116: char **av0;
117: {
118: register char **av = av0;
119:
120: while (*av)
121: xfree(*av++);
122: xfree(av0);
123: }
124:
125: char **
126: saveblk(v)
127: register char **v;
128: {
129: register int len = blklen(v) + 1;
130: register char **newv = (char **) calloc(len, sizeof (char **));
131: char **onewv = newv;
132:
133: while (*v)
134: *newv++ = savestr(*v++);
135: return (onewv);
136: }
137:
138: char *
139: strspl(cp, dp)
140: register char *cp, *dp;
141: {
142: register char *ep = calloc(1, strlen(cp) + strlen(dp) + 1);
143:
144: strcpy(ep, cp);
145: return (strcat(ep, dp));
146: }
147:
148: char **
149: blkspl(up, vp)
150: register char **up, **vp;
151: {
152: register char **wp = (char **) calloc(blklen(up) + blklen(vp) + 1, sizeof (char **));
153:
154: blkcpy(wp, up);
155: return (blkcat(wp, vp));
156: }
157:
158: lastchr(cp)
159: register char *cp;
160: {
161:
162: if (!*cp)
163: return (0);
164: while (cp[1])
165: cp++;
166: return (*cp);
167: }
168:
169: /*
170: * This routine is called after an error to close up
171: * any units which may have been left open accidentally.
172: */
173: closem()
174: {
175: register int f;
176:
177: for (f = 0; f < NOFILE; f++)
178: if (f != SHIN && f != SHOUT && f != SHDIAG && f != OLDSTD)
179: close(f);
180: }
181:
182: /*
183: * Close files before executing a file.
184: * We could be MUCH more intelligent, since (on a version 7 system)
185: * we need only close files here during a source, the other
186: * shell fd's being in units 16-19 which are closed automatically!
187: */
188: closech()
189: {
190: register int f;
191:
192: if (didcch)
193: return;
194: didcch = 1;
195: SHIN = 0; SHOUT = 1; SHDIAG = 2; OLDSTD = 0;
196: for (f = 3; f < NOFILE; f++)
197: close(f);
198: }
199:
200: donefds()
201: {
202:
203: close(0), close(1), close(2);
204: didfds = 0;
205: }
206:
207: /*
208: * Move descriptor i to j.
209: * If j is -1 then we just want to get i to a safe place,
210: * i.e. to a unit > 2. This also happens in dcopy.
211: */
212: dmove(i, j)
213: register int i, j;
214: {
215:
216: if (i == j || i < 0)
217: return (i);
218: #ifdef V7
219: if (j >= 0) {
220: dup2(i, j);
221: return (j);
222: } else
223: #endif
224: j = dcopy(i, j);
225: if (j != i)
226: close(i);
227: return (j);
228: }
229:
230: dcopy(i, j)
231: register int i, j;
232: {
233:
234: if (i == j || i < 0 || j < 0 && i > 2)
235: return (i);
236: #ifdef V7
237: if (j >= 0) {
238: dup2(i, j);
239: return (j);
240: }
241: #endif
242: close(j);
243: return (renum(i, j));
244: }
245:
246: renum(i, j)
247: register int i, j;
248: {
249: register int k = dup(i);
250:
251: if (k < 0)
252: return (-1);
253: if (j == -1 && k > 2)
254: return (k);
255: if (k != j) {
256: j = renum(k, j);
257: close(k);
258: return (j);
259: }
260: return (k);
261: }
262:
263: copy(to, from, size)
264: register char *to, *from;
265: register int size;
266: {
267:
268: if (size)
269: do
270: *to++ = *from++;
271: while (--size != 0);
272: }
273:
274: /*
275: * Left shift a command argument list, discarding
276: * the first c arguments. Used in "shift" commands
277: * as well as by commands like "repeat".
278: */
279: lshift(v, c)
280: register char **v;
281: register int c;
282: {
283: register char **u = v;
284:
285: while (*u && --c >= 0)
286: xfree(*u++);
287: blkcpy(v, u);
288: }
289:
290: number(cp)
291: char *cp;
292: {
293:
294: if (*cp == '-') {
295: cp++;
296: if (!digit(*cp++))
297: return (0);
298: }
299: while (*cp && digit(*cp))
300: cp++;
301: return (*cp == 0);
302: }
303:
304: char **
305: copyblk(v)
306: register char **v;
307: {
308: register char **nv = (char **) calloc(blklen(v) + 1, sizeof (char **));
309:
310: return (blkcpy(nv, v));
311: }
312:
313: char *
314: strend(cp)
315: register char *cp;
316: {
317:
318: while (*cp)
319: cp++;
320: return (cp);
321: }
322:
323: char *
324: strip(cp)
325: char *cp;
326: {
327: register char *dp = cp;
328:
329: while (*dp++ &= TRIM)
330: continue;
331: return (cp);
332: }
333:
334: udvar(name)
335: char *name;
336: {
337:
338: setname(name);
339: bferr("Undefined variable");
340: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.