]>
Commit | Line | Data |
---|---|---|
6a5fa4e0 MG |
1 | /* |
2 | * tclGlob.c -- | |
3 | * | |
4 | * This file provides procedures and commands for file name | |
5 | * manipulation, such as tilde expansion and globbing. | |
6 | * | |
7 | * Copyright 1990-1991 Regents of the University of California | |
8 | * Permission to use, copy, modify, and distribute this | |
9 | * software and its documentation for any purpose and without | |
10 | * fee is hereby granted, provided that the above copyright | |
11 | * notice appear in all copies. The University of California | |
12 | * makes no representations about the suitability of this | |
13 | * software for any purpose. It is provided "as is" without | |
14 | * express or implied warranty. | |
15 | */ | |
16 | ||
17 | #ifndef lint | |
18 | static char rcsid[] = "$Header: /user6/ouster/tcl/RCS/tclGlob.c,v 1.24 92/07/01 08:51:50 ouster Exp $ SPRITE (Berkeley)"; | |
19 | #endif /* not lint */ | |
20 | ||
21 | #include <sys/types.h> | |
22 | ||
23 | #include "tclint.h" | |
24 | #include "tclunix.h" | |
25 | ||
26 | void dvpath(char *); | |
27 | ||
28 | /* | |
29 | * The structure below is used to keep track of a globbing result | |
30 | * being built up (i.e. a partial list of file names). The list | |
31 | * grows dynamically to be as big as needed. | |
32 | */ | |
33 | ||
34 | typedef struct { | |
35 | char *result; /* Pointer to result area. */ | |
36 | int totalSpace; /* Total number of characters allocated | |
37 | * for result. */ | |
38 | int spaceUsed; /* Number of characters currently in use | |
39 | * to hold the partial result (not including | |
40 | * the terminating NULL). */ | |
41 | int dynamic; /* 0 means result is static space, 1 means | |
42 | * it's dynamic. */ | |
43 | } GlobResult; | |
44 | ||
45 | /* | |
46 | * Declarations for procedures local to this file: | |
47 | */ | |
48 | ||
49 | static void AppendResult _ANSI_ARGS_((Tcl_Interp *interp, | |
50 | char *dir, char *separator, char *name, | |
51 | int nameLength)); | |
52 | static int DoGlob _ANSI_ARGS_((Tcl_Interp *interp, char *dir, | |
53 | char *rem)); | |
54 | \f | |
55 | /* | |
56 | *---------------------------------------------------------------------- | |
57 | * | |
58 | * AppendResult -- | |
59 | * | |
60 | * Given two parts of a file name (directory and element within | |
61 | * directory), concatenate the two together and append them to | |
62 | * the result building up in interp. | |
63 | * | |
64 | * Results: | |
65 | * There is no return value. | |
66 | * | |
67 | * Side effects: | |
68 | * Interp->result gets extended. | |
69 | * | |
70 | *---------------------------------------------------------------------- | |
71 | */ | |
72 | ||
73 | static void | |
74 | AppendResult(interp, dir, separator, name, nameLength) | |
75 | Tcl_Interp *interp; /* Interpreter whose result should be | |
76 | * appended to. */ | |
77 | char *dir; /* Name of directory, without trailing | |
78 | * slash except for root directory. */ | |
79 | char *separator; /* Separator string so use between dir and | |
80 | * name: either "/" or "" depending on dir. */ | |
81 | char *name; /* Name of file withing directory (NOT | |
82 | * necessarily null-terminated!). */ | |
83 | int nameLength; /* Number of characters in name. */ | |
84 | { | |
85 | int dirFlags, nameFlags; | |
86 | char *p, saved; | |
87 | ||
88 | /* | |
89 | * Next, see if we can put together a valid list element from dir | |
90 | * and name by calling Tcl_AppendResult. | |
91 | */ | |
92 | ||
93 | if (*dir == 0) { | |
94 | dirFlags = 0; | |
95 | } else { | |
96 | Tcl_ScanElement(dir, &dirFlags); | |
97 | } | |
98 | saved = name[nameLength]; | |
99 | name[nameLength] = 0; | |
100 | Tcl_ScanElement(name, &nameFlags); | |
101 | if ((dirFlags == 0) && (nameFlags == 0)) { | |
102 | if (*interp->result != 0) { | |
103 | Tcl_AppendResult(interp, " ", dir, separator, name, (char *) NULL); | |
104 | } else { | |
105 | Tcl_AppendResult(interp, dir, separator, name, (char *) NULL); | |
106 | } | |
107 | name[nameLength] = saved; | |
108 | return; | |
109 | } | |
110 | ||
111 | /* | |
112 | * This name has weird characters in it, so we have to convert it to | |
113 | * a list element. To do that, we have to merge the characters | |
114 | * into a single name. To do that, malloc a buffer to hold everything. | |
115 | */ | |
116 | ||
117 | p = (char *) ckalloc((unsigned) (strlen(dir) + strlen(separator) | |
118 | + nameLength + 1)); | |
119 | sprintf(p, "%s%s%s", dir, separator, name); | |
120 | name[nameLength] = saved; | |
121 | Tcl_AppendElement(interp, p, 0); | |
122 | ckfree(p); | |
123 | } | |
124 | \f | |
125 | /* | |
126 | *---------------------------------------------------------------------- | |
127 | * | |
128 | * DoGlob -- | |
129 | * | |
130 | * This recursive procedure forms the heart of the globbing | |
131 | * code. It performs a depth-first traversal of the tree | |
132 | * given by the path name to be globbed. | |
133 | * | |
134 | * Results: | |
135 | * The return value is a standard Tcl result indicating whether | |
136 | * an error occurred in globbing. After a normal return the | |
137 | * result in interp will be set to hold all of the file names | |
138 | * given by the dir and rem arguments. After an error the | |
139 | * result in interp will hold an error message. | |
140 | * | |
141 | * Side effects: | |
142 | * None. | |
143 | * | |
144 | *---------------------------------------------------------------------- | |
145 | */ | |
146 | ||
147 | static int | |
148 | DoGlob(interp, dir, rem) | |
149 | Tcl_Interp *interp; /* Interpreter to use for error | |
150 | * reporting (e.g. unmatched brace). */ | |
151 | char *dir; /* Name of a directory at which to | |
152 | * start glob expansion. This name | |
153 | * is fixed: it doesn't contain any | |
154 | * globbing chars. */ | |
155 | char *rem; /* Path to glob-expand. */ | |
156 | { | |
157 | /* | |
158 | * When this procedure is entered, the name to be globbed may | |
159 | * already have been partly expanded by ancestor invocations of | |
160 | * DoGlob. The part that's already been expanded is in "dir" | |
161 | * (this may initially be empty), and the part still to expand | |
162 | * is in "rem". This procedure expands "rem" one level, making | |
163 | * recursive calls to itself if there's still more stuff left | |
164 | * in the remainder. | |
165 | */ | |
166 | ||
167 | register char *p; | |
168 | register char c; | |
169 | char *openBrace, *closeBrace; | |
170 | int gotSpecial, result; | |
171 | char *separator; | |
172 | ||
173 | /* | |
174 | * Figure out whether we'll need to add a slash between the directory | |
175 | * name and file names within the directory when concatenating them | |
176 | * together. | |
177 | */ | |
178 | ||
179 | if ((dir[0] == 0) || ((dir[0] == '/') && (dir[1] == 0))) { | |
180 | separator = ""; | |
181 | } else { | |
182 | separator = "/"; | |
183 | } | |
184 | ||
185 | /* | |
186 | * When generating information for the next lower call, | |
187 | * use static areas if the name is short, and malloc if the name | |
188 | * is longer. | |
189 | */ | |
190 | ||
191 | #define STATIC_SIZE 200 | |
192 | ||
193 | /* | |
194 | * First, find the end of the next element in rem, checking | |
195 | * along the way for special globbing characters. | |
196 | */ | |
197 | ||
198 | gotSpecial = 0; | |
199 | openBrace = closeBrace = NULL; | |
200 | for (p = rem; ; p++) { | |
201 | c = *p; | |
202 | if ((c == '\0') || (c == '/')) { | |
203 | break; | |
204 | } | |
205 | if ((c == '{') && (openBrace == NULL)) { | |
206 | openBrace = p; | |
207 | } | |
208 | if ((c == '}') && (closeBrace == NULL)) { | |
209 | closeBrace = p; | |
210 | } | |
211 | if ((c == '*') || (c == '[') || (c == '\\') || (c == '?')) { | |
212 | gotSpecial = 1; | |
213 | } | |
214 | } | |
215 | ||
216 | /* | |
217 | * If there is an open brace in the argument, then make a recursive | |
218 | * call for each element between the braces. In this case, the | |
219 | * recursive call to DoGlob uses the same "dir" that we got. | |
220 | * If there are several brace-pairs in a single name, we just handle | |
221 | * one here, and the others will be handled in recursive calls. | |
222 | */ | |
223 | ||
224 | if (openBrace != NULL) { | |
225 | int remLength, l1, l2; | |
226 | char static1[STATIC_SIZE]; | |
227 | char *element, *newRem; | |
228 | ||
229 | if (closeBrace == NULL) { | |
230 | Tcl_ResetResult(interp); | |
231 | interp->result = "unmatched open-brace in file name"; | |
232 | return TCL_ERROR; | |
233 | } | |
234 | remLength = strlen(rem) + 1; | |
235 | if (remLength <= STATIC_SIZE) { | |
236 | newRem = static1; | |
237 | } else { | |
238 | newRem = (char *) ckalloc((unsigned) remLength); | |
239 | } | |
240 | l1 = openBrace-rem; | |
241 | strncpy(newRem, rem, l1); | |
242 | p = openBrace; | |
243 | for (p = openBrace; *p != '}'; ) { | |
244 | element = p+1; | |
245 | for (p = element; ((*p != '}') && (*p != ',')); p++) { | |
246 | /* Empty loop body: just find end of this element. */ | |
247 | } | |
248 | l2 = p - element; | |
249 | strncpy(newRem+l1, element, l2); | |
250 | strcpy(newRem+l1+l2, closeBrace+1); | |
251 | if (DoGlob(interp, dir, newRem) != TCL_OK) { | |
252 | return TCL_ERROR; | |
253 | } | |
254 | } | |
255 | if (remLength > STATIC_SIZE) { | |
256 | ckfree(newRem); | |
257 | } | |
258 | return TCL_OK; | |
259 | } | |
260 | ||
261 | /* | |
262 | * If there were any pattern-matching characters, then scan through | |
263 | * the directory to find all the matching names. | |
264 | */ | |
265 | ||
266 | if (gotSpecial) { | |
267 | DIR *d; | |
268 | struct dirent *entryPtr; | |
269 | int l1, l2; | |
270 | char *pattern, *newDir, *dirName; | |
271 | char static1[STATIC_SIZE], static2[STATIC_SIZE]; | |
272 | struct stat statBuf; | |
273 | ||
274 | /* | |
275 | * Be careful not to do any actual file system operations on a | |
276 | * directory named ""; instead, use ".". This is needed because | |
277 | * some versions of UNIX don't treat "" like "." automatically. | |
278 | */ | |
279 | ||
280 | if (*dir == '\0') { | |
281 | dirName = "."; | |
282 | } else { | |
283 | dirName = dir; | |
284 | } | |
285 | if ((stat(dirName, &statBuf) != 0) | |
286 | || ((statBuf.st_mode & S_IFMT) != S_IFDIR)) { | |
287 | return TCL_OK; | |
288 | } | |
289 | d = opendir(dirName); | |
290 | if (d == NULL) { | |
291 | Tcl_ResetResult(interp); | |
292 | Tcl_AppendResult(interp, "couldn't read directory \"", | |
293 | dirName, "\": ", Tcl_UnixError(interp), (char *) NULL); | |
294 | return TCL_ERROR; | |
295 | } | |
296 | l1 = strlen(dir); | |
297 | l2 = (p - rem); | |
298 | if (l2 < STATIC_SIZE) { | |
299 | pattern = static2; | |
300 | } else { | |
301 | pattern = (char *) ckalloc((unsigned) (l2+1)); | |
302 | } | |
303 | strncpy(pattern, rem, l2); | |
304 | pattern[l2] = '\0'; | |
305 | result = TCL_OK; | |
306 | while (1) { | |
307 | entryPtr = readdir(d); | |
308 | if (entryPtr == NULL) { | |
309 | break; | |
310 | } | |
311 | ||
312 | /* | |
313 | * Don't match names starting with "." unless the "." is | |
314 | * present in the pattern. | |
315 | */ | |
316 | ||
317 | if ((*entryPtr->d_name == '.') && (*pattern != '.')) { | |
318 | continue; | |
319 | } | |
320 | if (Tcl_StringMatch(entryPtr->d_name, pattern)) { | |
321 | int nameLength = strlen(entryPtr->d_name); | |
322 | if (*p == 0) { | |
323 | AppendResult(interp, dir, separator, entryPtr->d_name, | |
324 | nameLength); | |
325 | } else { | |
326 | if ((l1+nameLength+2) <= STATIC_SIZE) { | |
327 | newDir = static1; | |
328 | } else { | |
329 | newDir = (char *) ckalloc((unsigned) (l1+nameLength+2)); | |
330 | } | |
331 | sprintf(newDir, "%s%s%s", dir, separator, entryPtr->d_name); | |
332 | result = DoGlob(interp, newDir, p+1); | |
333 | if (newDir != static1) { | |
334 | ckfree(newDir); | |
335 | } | |
336 | if (result != TCL_OK) { | |
337 | break; | |
338 | } | |
339 | } | |
340 | } | |
341 | } | |
342 | closedir(d); | |
343 | if (pattern != static2) { | |
344 | ckfree(pattern); | |
345 | } | |
346 | return result; | |
347 | } | |
348 | ||
349 | /* | |
350 | * This is the simplest case: just another path element. Move | |
351 | * it to the dir side and recurse (or just add the name to the | |
352 | * list, if we're at the end of the path). | |
353 | */ | |
354 | ||
355 | if (*p == 0) { | |
356 | AppendResult(interp, dir, separator, rem, p-rem); | |
357 | } else { | |
358 | int l1, l2; | |
359 | char *newDir; | |
360 | char static1[STATIC_SIZE]; | |
361 | ||
362 | l1 = strlen(dir); | |
363 | l2 = l1 + (p - rem) + 2; | |
364 | if (l2 <= STATIC_SIZE) { | |
365 | newDir = static1; | |
366 | } else { | |
367 | newDir = (char *) ckalloc((unsigned) l2); | |
368 | } | |
369 | sprintf(newDir, "%s%s%.*s", dir, separator, p-rem, rem); | |
370 | result = DoGlob(interp, newDir, p+1); | |
371 | if (newDir != static1) { | |
372 | ckfree(newDir); | |
373 | } | |
374 | if (result != TCL_OK) { | |
375 | return TCL_ERROR; | |
376 | } | |
377 | } | |
378 | return TCL_OK; | |
379 | } | |
380 | \f | |
381 | /* | |
382 | *---------------------------------------------------------------------- | |
383 | * | |
384 | * Tcl_TildeSubst -- | |
385 | * | |
386 | * Given a name starting with a tilde, produce a name where | |
387 | * the tilde and following characters have been replaced by | |
388 | * the home directory location for the named user. | |
389 | * | |
390 | * Results: | |
391 | * The result is a pointer to a static string containing | |
392 | * the new name. This name will only persist until the next | |
393 | * call to Tcl_TildeSubst; save it if you care about it for | |
394 | * the long term. If there was an error in processing the | |
395 | * tilde, then an error message is left in interp->result | |
396 | * and the return value is NULL. | |
397 | * | |
398 | * Side effects: | |
399 | * None that the caller needs to worry about. | |
400 | * | |
401 | *---------------------------------------------------------------------- | |
402 | */ | |
403 | ||
404 | char * | |
405 | Tcl_TildeSubst(interp, name) | |
406 | Tcl_Interp *interp; /* Interpreter in which to store error | |
407 | * message (if necessary). */ | |
408 | char *name; /* File name, which may begin with "~/" | |
409 | * (to indicate current user's home directory) | |
410 | * or "~<user>/" (to indicate any user's | |
411 | * home directory). */ | |
412 | { | |
413 | #define STATIC_BUF_SIZE 50 | |
414 | static char staticBuf[STATIC_BUF_SIZE]; | |
415 | static int curSize = STATIC_BUF_SIZE; | |
416 | static char *curBuf = staticBuf; | |
417 | char *dir; | |
418 | int length; | |
419 | int fromPw = 0; | |
420 | register char *p; | |
421 | ||
422 | if (name[0] != '~') { | |
423 | return name; | |
424 | } | |
425 | ||
426 | #ifdef MSDOS | |
427 | dvpath(dir); | |
428 | if (name[1] != '/') { | |
429 | strcat(dir,"/"); | |
430 | p = name; | |
431 | } | |
432 | else | |
433 | p = name +1; | |
434 | #else | |
435 | ||
436 | /* | |
437 | * First, find the directory name corresponding to the tilde entry. | |
438 | */ | |
439 | ||
440 | if ((name[1] == '/') || (name[1] == '\0')) { | |
441 | dir = getenv("HOME"); | |
442 | if (dir == NULL) { | |
443 | Tcl_ResetResult(interp); | |
444 | Tcl_AppendResult(interp, "couldn't find HOME environment ", | |
445 | "variable to expand \"", name, "\"", (char *) NULL); | |
446 | return NULL; | |
447 | } | |
448 | p = name+1; | |
449 | } else { | |
450 | struct passwd *pwPtr; | |
451 | ||
452 | for (p = &name[1]; (*p != 0) && (*p != '/'); p++) { | |
453 | /* Null body; just find end of name. */ | |
454 | } | |
455 | length = p-&name[1]; | |
456 | if (length >= curSize) { | |
457 | length = curSize-1; | |
458 | } | |
459 | memcpy((VOID *) curBuf, (VOID *) (name+1), length); | |
460 | curBuf[length] = '\0'; | |
461 | pwPtr = getpwnam(curBuf); | |
462 | if (pwPtr == NULL) { | |
463 | Tcl_ResetResult(interp); | |
464 | Tcl_AppendResult(interp, "user \"", curBuf, | |
465 | "\" doesn't exist", (char *) NULL); | |
466 | return NULL; | |
467 | } | |
468 | dir = pwPtr->pw_dir; | |
469 | fromPw = 1; | |
470 | } | |
471 | #endif | |
472 | ||
473 | /* | |
474 | * Grow the buffer if necessary to make enough space for the | |
475 | * full file name. | |
476 | */ | |
477 | ||
478 | length = strlen(dir) + strlen(p); | |
479 | if (length >= curSize) { | |
480 | if (curBuf != staticBuf) { | |
481 | ckfree(curBuf); | |
482 | } | |
483 | curSize = length + 1; | |
484 | curBuf = (char *) ckalloc((unsigned) curSize); | |
485 | } | |
486 | ||
487 | /* | |
488 | * Finally, concatenate the directory name with the remainder | |
489 | * of the path in the buffer. | |
490 | */ | |
491 | ||
492 | strcpy(curBuf, dir); | |
493 | strcat(curBuf, p); | |
494 | #ifndef MSDOS | |
495 | if (fromPw) { | |
496 | endpwent(); | |
497 | } | |
498 | #endif | |
499 | return curBuf; | |
500 | } | |
501 | \f | |
502 | /* | |
503 | *---------------------------------------------------------------------- | |
504 | * | |
505 | * Tcl_GlobCmd -- | |
506 | * | |
507 | * This procedure is invoked to process the "glob" Tcl command. | |
508 | * See the user documentation for details on what it does. | |
509 | * | |
510 | * Results: | |
511 | * A standard Tcl result. | |
512 | * | |
513 | * Side effects: | |
514 | * See the user documentation. | |
515 | * | |
516 | *---------------------------------------------------------------------- | |
517 | */ | |
518 | ||
519 | /* ARGSUSED */ | |
520 | int | |
521 | Tcl_GlobCmd(dummy, interp, argc, argv) | |
522 | ClientData dummy; /* Not used. */ | |
523 | Tcl_Interp *interp; /* Current interpreter. */ | |
524 | int argc; /* Number of arguments. */ | |
525 | char **argv; /* Argument strings. */ | |
526 | { | |
527 | int i, result, noComplain; | |
528 | ||
529 | if (argc < 2) { | |
530 | notEnoughArgs: | |
531 | Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], | |
532 | " ?-nocomplain? name ?name ...?\"", (char *) NULL); | |
533 | return TCL_ERROR; | |
534 | } | |
535 | noComplain = 0; | |
536 | if ((argv[1][0] == '-') && (strcmp(argv[1], "-nocomplain") == 0)) { | |
537 | if (argc < 3) { | |
538 | goto notEnoughArgs; | |
539 | } | |
540 | noComplain = 1; | |
541 | } | |
542 | ||
543 | for (i = 1 + noComplain; i < argc; i++) { | |
544 | char *thisName; | |
545 | ||
546 | /* | |
547 | * Do special checks for names starting at the root and for | |
548 | * names beginning with ~. Then let DoGlob do the rest. | |
549 | */ | |
550 | ||
551 | thisName = argv[i]; | |
552 | if (*thisName == '~') { | |
553 | thisName = Tcl_TildeSubst(interp, thisName); | |
554 | if (thisName == NULL) { | |
555 | return TCL_ERROR; | |
556 | } | |
557 | } | |
558 | if (*thisName == '/') { | |
559 | result = DoGlob(interp, "/", thisName+1); | |
560 | } else { | |
561 | result = DoGlob(interp, "", thisName); | |
562 | } | |
563 | if (result != TCL_OK) { | |
564 | return result; | |
565 | } | |
566 | } | |
567 | if ((*interp->result == 0) && !noComplain) { | |
568 | char *sep = ""; | |
569 | ||
570 | Tcl_AppendResult(interp, "no files matched glob pattern", | |
571 | (argc == 2) ? " \"" : "s \"", (char *) NULL); | |
572 | for (i = 1; i < argc; i++) { | |
573 | Tcl_AppendResult(interp, sep, argv[i], (char *) NULL); | |
574 | sep = " "; | |
575 | } | |
576 | Tcl_AppendResult(interp, "\"", (char *) NULL); | |
577 | return TCL_ERROR; | |
578 | } | |
579 | return TCL_OK; | |
580 | } |