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