Commit | Line | Data |
---|---|---|
b79f4fa9 DF |
1 | /* |
2 | * Copyright (c) 1980 Regents of the University of California. | |
094e80ed | 3 | * All rights reserved. The Berkeley Software License Agreement |
b79f4fa9 DF |
4 | * specifies the terms and conditions for redistribution. |
5 | */ | |
6 | ||
35371dec | 7 | #ifndef lint |
c2dc294d | 8 | static char *sccsid = "@(#)misc.c 5.3 (Berkeley) %G%"; |
094e80ed | 9 | #endif |
cf8f66fb BJ |
10 | |
11 | #include "sh.h" | |
12 | ||
13 | /* | |
14 | * C Shell | |
15 | */ | |
16 | ||
cf8f66fb BJ |
17 | any(c, s) |
18 | register int c; | |
19 | register char *s; | |
20 | { | |
21 | ||
22 | while (*s) | |
23 | if (*s++ == c) | |
24 | return(1); | |
25 | return(0); | |
26 | } | |
27 | ||
35371dec EW |
28 | onlyread(cp) |
29 | char *cp; | |
30 | { | |
31 | extern char end[]; | |
32 | ||
33 | return (cp < end); | |
34 | } | |
35 | ||
36 | xfree(cp) | |
37 | char *cp; | |
38 | { | |
39 | extern char end[]; | |
40 | ||
41 | if (cp >= end && cp < (char *) &cp) | |
42 | free(cp); | |
43 | } | |
44 | ||
45 | char * | |
46 | savestr(s) | |
47 | register char *s; | |
48 | { | |
49 | char *n; | |
50 | register char *p; | |
51 | ||
52 | if (s == 0) | |
53 | s = ""; | |
54 | for (p = s; *p++;) | |
55 | ; | |
56 | n = p = xalloc((unsigned) (p - s)); | |
57 | while (*p++ = *s++) | |
58 | ; | |
59 | return (n); | |
60 | } | |
61 | ||
cf8f66fb BJ |
62 | char * |
63 | calloc(i, j) | |
64 | register unsigned i; | |
65 | unsigned j; | |
66 | { | |
c2dc294d | 67 | char *cp; |
cf8f66fb BJ |
68 | |
69 | i *= j; | |
c2dc294d JL |
70 | cp = xalloc(i); |
71 | bzero(cp, (int)i); | |
cf8f66fb BJ |
72 | return (cp); |
73 | } | |
74 | ||
35371dec EW |
75 | nomem(i) |
76 | unsigned i; | |
77 | { | |
78 | #ifdef debug | |
79 | static char *av[2] = {0, 0}; | |
80 | #endif | |
81 | ||
82 | child++; | |
83 | #ifndef debug | |
84 | error("Out of memory"); | |
85 | #ifdef lint | |
86 | i = i; | |
87 | #endif | |
88 | #else | |
89 | showall(av); | |
90 | printf("i=%d: Out of memory\n", i); | |
91 | chdir("/usr/bill/cshcore"); | |
92 | abort(); | |
93 | #endif | |
94 | return 0; /* fool lint */ | |
95 | } | |
96 | ||
cf8f66fb BJ |
97 | char ** |
98 | blkend(up) | |
99 | register char **up; | |
100 | { | |
101 | ||
102 | while (*up) | |
103 | up++; | |
104 | return (up); | |
105 | } | |
106 | ||
107 | blkpr(av) | |
108 | register char **av; | |
109 | { | |
110 | ||
111 | for (; *av; av++) { | |
112 | printf("%s", *av); | |
113 | if (av[1]) | |
114 | printf(" "); | |
115 | } | |
116 | } | |
117 | ||
118 | blklen(av) | |
119 | register char **av; | |
120 | { | |
121 | register int i = 0; | |
122 | ||
123 | while (*av++) | |
124 | i++; | |
125 | return (i); | |
126 | } | |
127 | ||
128 | char ** | |
129 | blkcpy(oav, bv) | |
130 | char **oav; | |
131 | register char **bv; | |
132 | { | |
133 | register char **av = oav; | |
134 | ||
135 | while (*av++ = *bv++) | |
136 | continue; | |
137 | return (oav); | |
138 | } | |
139 | ||
140 | char ** | |
141 | blkcat(up, vp) | |
142 | char **up, **vp; | |
143 | { | |
144 | ||
35371dec | 145 | (void) blkcpy(blkend(up), vp); |
cf8f66fb BJ |
146 | return (up); |
147 | } | |
148 | ||
149 | blkfree(av0) | |
150 | char **av0; | |
151 | { | |
152 | register char **av = av0; | |
153 | ||
35371dec EW |
154 | for (; *av; av++) |
155 | XFREE(*av) | |
156 | XFREE((char *)av0) | |
cf8f66fb BJ |
157 | } |
158 | ||
159 | char ** | |
160 | saveblk(v) | |
161 | register char **v; | |
162 | { | |
35371dec EW |
163 | register char **newv = |
164 | (char **) calloc((unsigned) (blklen(v) + 1), sizeof (char **)); | |
cf8f66fb BJ |
165 | char **onewv = newv; |
166 | ||
167 | while (*v) | |
168 | *newv++ = savestr(*v++); | |
169 | return (onewv); | |
170 | } | |
171 | ||
172 | char * | |
173 | strspl(cp, dp) | |
35371dec | 174 | char *cp, *dp; |
cf8f66fb | 175 | { |
35371dec EW |
176 | char *ep; |
177 | register char *p, *q; | |
178 | ||
179 | for (p = cp; *p++;) | |
180 | ; | |
181 | for (q = dp; *q++;) | |
182 | ; | |
183 | ep = xalloc((unsigned) ((p - cp) + (q - dp) - 1)); | |
184 | for (p = ep, q = cp; *p++ = *q++;) | |
185 | ; | |
186 | for (p--, q = dp; *p++ = *q++;) | |
187 | ; | |
cf8f66fb BJ |
188 | return (ep); |
189 | } | |
190 | ||
191 | char ** | |
192 | blkspl(up, vp) | |
193 | register char **up, **vp; | |
194 | { | |
35371dec EW |
195 | register char **wp = |
196 | (char **) calloc((unsigned) (blklen(up) + blklen(vp) + 1), | |
197 | sizeof (char **)); | |
cf8f66fb | 198 | |
35371dec | 199 | (void) blkcpy(wp, up); |
cf8f66fb BJ |
200 | return (blkcat(wp, vp)); |
201 | } | |
202 | ||
203 | lastchr(cp) | |
204 | register char *cp; | |
205 | { | |
206 | ||
207 | if (!*cp) | |
208 | return (0); | |
209 | while (cp[1]) | |
210 | cp++; | |
211 | return (*cp); | |
212 | } | |
213 | ||
214 | /* | |
215 | * This routine is called after an error to close up | |
216 | * any units which may have been left open accidentally. | |
217 | */ | |
218 | closem() | |
219 | { | |
220 | register int f; | |
221 | ||
222 | for (f = 0; f < NOFILE; f++) | |
223 | if (f != SHIN && f != SHOUT && f != SHDIAG && f != OLDSTD && | |
224 | f != FSHTTY) | |
35371dec | 225 | (void) close(f); |
cf8f66fb BJ |
226 | } |
227 | ||
228 | donefds() | |
229 | { | |
230 | ||
35371dec EW |
231 | (void) close(0); |
232 | (void) close(1); | |
233 | (void) close(2); | |
cf8f66fb BJ |
234 | didfds = 0; |
235 | } | |
236 | ||
237 | /* | |
238 | * Move descriptor i to j. | |
239 | * If j is -1 then we just want to get i to a safe place, | |
240 | * i.e. to a unit > 2. This also happens in dcopy. | |
241 | */ | |
242 | dmove(i, j) | |
243 | register int i, j; | |
244 | { | |
245 | ||
246 | if (i == j || i < 0) | |
247 | return (i); | |
cf8f66fb | 248 | if (j >= 0) { |
35371dec | 249 | (void) dup2(i, j); |
cf8f66fb | 250 | return (j); |
35371dec EW |
251 | } |
252 | j = dcopy(i, j); | |
cf8f66fb | 253 | if (j != i) |
35371dec | 254 | (void) close(i); |
cf8f66fb BJ |
255 | return (j); |
256 | } | |
257 | ||
258 | dcopy(i, j) | |
259 | register int i, j; | |
260 | { | |
261 | ||
262 | if (i == j || i < 0 || j < 0 && i > 2) | |
263 | return (i); | |
cf8f66fb | 264 | if (j >= 0) { |
35371dec | 265 | (void) dup2(i, j); |
cf8f66fb BJ |
266 | return (j); |
267 | } | |
35371dec | 268 | (void) close(j); |
cf8f66fb BJ |
269 | return (renum(i, j)); |
270 | } | |
271 | ||
272 | renum(i, j) | |
273 | register int i, j; | |
274 | { | |
275 | register int k = dup(i); | |
276 | ||
277 | if (k < 0) | |
278 | return (-1); | |
279 | if (j == -1 && k > 2) | |
280 | return (k); | |
281 | if (k != j) { | |
282 | j = renum(k, j); | |
35371dec | 283 | (void) close(k); |
cf8f66fb BJ |
284 | return (j); |
285 | } | |
286 | return (k); | |
287 | } | |
288 | ||
a6f57ddd | 289 | #ifndef copy |
cf8f66fb BJ |
290 | copy(to, from, size) |
291 | register char *to, *from; | |
292 | register int size; | |
293 | { | |
294 | ||
295 | if (size) | |
296 | do | |
297 | *to++ = *from++; | |
298 | while (--size != 0); | |
299 | } | |
a6f57ddd | 300 | #endif |
cf8f66fb BJ |
301 | |
302 | /* | |
303 | * Left shift a command argument list, discarding | |
304 | * the first c arguments. Used in "shift" commands | |
305 | * as well as by commands like "repeat". | |
306 | */ | |
307 | lshift(v, c) | |
308 | register char **v; | |
309 | register int c; | |
310 | { | |
311 | register char **u = v; | |
312 | ||
313 | while (*u && --c >= 0) | |
314 | xfree(*u++); | |
35371dec | 315 | (void) blkcpy(v, u); |
cf8f66fb BJ |
316 | } |
317 | ||
318 | number(cp) | |
319 | char *cp; | |
320 | { | |
321 | ||
322 | if (*cp == '-') { | |
323 | cp++; | |
324 | if (!digit(*cp++)) | |
325 | return (0); | |
326 | } | |
327 | while (*cp && digit(*cp)) | |
328 | cp++; | |
329 | return (*cp == 0); | |
330 | } | |
331 | ||
332 | char ** | |
333 | copyblk(v) | |
334 | register char **v; | |
335 | { | |
35371dec EW |
336 | register char **nv = |
337 | (char **) calloc((unsigned) (blklen(v) + 1), sizeof (char **)); | |
cf8f66fb BJ |
338 | |
339 | return (blkcpy(nv, v)); | |
340 | } | |
341 | ||
342 | char * | |
343 | strend(cp) | |
344 | register char *cp; | |
345 | { | |
346 | ||
347 | while (*cp) | |
348 | cp++; | |
349 | return (cp); | |
350 | } | |
351 | ||
352 | char * | |
353 | strip(cp) | |
354 | char *cp; | |
355 | { | |
356 | register char *dp = cp; | |
357 | ||
358 | while (*dp++ &= TRIM) | |
359 | continue; | |
360 | return (cp); | |
361 | } | |
362 | ||
363 | udvar(name) | |
364 | char *name; | |
365 | { | |
366 | ||
367 | setname(name); | |
368 | bferr("Undefined variable"); | |
369 | } | |
370 | ||
371 | prefix(sub, str) | |
372 | register char *sub, *str; | |
373 | { | |
374 | ||
375 | for (;;) { | |
376 | if (*sub == 0) | |
377 | return (1); | |
378 | if (*str == 0) | |
379 | return (0); | |
380 | if (*sub++ != *str++) | |
381 | return (0); | |
382 | } | |
383 | } |