![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tclGlob.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / worm / scsi / tcl|
Return to tclGlob.c CVS log | Up to [Research Unix] / researchv10no / cmd / worm / scsi / tcl |
1.1 root 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 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: /sprite/src/lib/tcl/RCS/tclGlob.c,v 1.4 90/04/19 14:53:59 ouster Exp $ SPRITE (Berkeley)";
19: #pragma ref rcsid
20: #endif not lint
21:
22: #define _POSIX_SOURCE
23:
24: #include <stdio.h>
25: #include <errno.h>
26: #include <pwd.h>
27: #include <stdlib.h>
28: #include <string.h>
29: #include <sys/types.h>
30: #include <dirent.h>
31: #include <sys/stat.h>
32: #include <tcl.h>
33: #include "tclInt.h"
34:
35: /*
36: * The structure below is used to keep track of a globbing result
37: * being built up (i.e. a partial list of file names). The list
38: * grows dynamically to be as big as needed.
39: */
40:
41: typedef struct {
42: char *result; /* Pointer to result area. */
43: int totalSpace; /* Total number of characters allocated
44: * for result. */
45: int spaceUsed; /* Number of characters currently in use
46: * to hold the partial result (not including
47: * the terminating NULL). */
48: int dynamic; /* 0 means result is static space, 1 means
49: * it's dynamic. */
50: } GlobResult;
51:
52: /*
53: *----------------------------------------------------------------------
54: *
55: * AppendResult --
56: *
57: * Given two parts of a file name (directory and element within
58: * directory), concatenate the two together and add them to a
59: * partially-formed result.
60: *
61: * Results:
62: * There is no return value. The structure at *resPtr is modified
63: * to hold more information.
64: *
65: * Side effects:
66: * Storage may be allocated if we run out of space in *resPtr.
67: *
68: *----------------------------------------------------------------------
69: */
70:
71: static void
72: AppendResult(dir, name, nameLength, resPtr)
73: char *dir; /* Name of directory (without trailing
74: * slash). */
75: char *name; /* Name of file withing directory (NOT
76: * necessarily null-terminated!). */
77: int nameLength; /* Number of characters in name. */
78: register GlobResult *resPtr;/* Structure in which to append info. */
79: {
80: int dirLength, totalLength;
81: char *p;
82:
83: /*
84: * Make sure there's enough space in the result area for this
85: * new name (need two extra chars. besides what's in dir and
86: * name, for a separating space after the last name and for a
87: * terminating NULL).
88: */
89:
90: dirLength = strlen(dir);
91: totalLength = resPtr->spaceUsed + dirLength + nameLength + 2;
92: if (totalLength > resPtr->totalSpace) {
93: char *newSpace;
94: int newSize;
95:
96: newSize = 2*resPtr->totalSpace;
97: if (newSize < totalLength) {
98: newSize = totalLength;
99: }
100: newSpace = malloc((unsigned) newSize);
101: bcopy(resPtr->result, newSpace, resPtr->spaceUsed);
102: if (resPtr->dynamic) {
103: free(resPtr->result);
104: }
105: resPtr->result = newSpace;
106: resPtr->totalSpace = newSize;
107: resPtr->dynamic = 1;
108: }
109:
110: /*
111: * Now append the new information onto the end of the result.
112: */
113:
114: p = resPtr->result + resPtr->spaceUsed;
115: if (resPtr->spaceUsed != 0) {
116: *p = ' ';
117: p++;
118: resPtr->spaceUsed++;
119: }
120: strcpy(p, dir);
121: p += dirLength;
122: strncpy(p, name, nameLength);
123: p[nameLength] = 0;
124: resPtr->spaceUsed += nameLength+dirLength;
125: }
126:
127: /*
128: *----------------------------------------------------------------------
129: *
130: * DoGlob --
131: *
132: * This recursive procedure forms the heart of the globbing
133: * code. It performs a depth-first traversal of the tree
134: * given by the path name to be globbed.
135: *
136: * Results:
137: * The return value is a standard Tcl result indicating whether
138: * an error occurred in globbing. The result in interp will be
139: * set to hold an error message, if any. The result pointed
140: * to by resPtr is updated to hold all file names given by
141: * the dir and rem arguments.
142: *
143: * Side effects:
144: * None.
145: *
146: *----------------------------------------------------------------------
147: */
148:
149: static int
150: DoGlob(interp, dir, rem, resPtr)
151: Tcl_Interp *interp; /* Interpreter to use for error
152: * reporting (e.g. unmatched brace). */
153: char *dir; /* Name of a directory at which to
154: * start glob expansion. This name
155: * is fixed: it doesn't contain any
156: * globbing chars. If it's non-empty
157: * then it should end with a slash. */
158: char *rem; /* Path to glob-expand. */
159: GlobResult *resPtr; /* Where to store fully-expanded file
160: * names.*/
161: {
162: /*
163: * When this procedure is entered, the name to be globbed may
164: * already have been partly expanded by ancestor invocations of
165: * DoGlob. The part that's already been expanded is in "dir"
166: * (this may initially be empty), and the part still to expand
167: * is in "rem". This procedure expands "rem" one level, making
168: * recursive calls to itself if there's still more stuff left
169: * in the remainder.
170: */
171:
172: register char *p;
173: register char c;
174: char *openBrace, *closeBrace;
175: int gotSpecial, result;
176:
177: /*
178: * When generating information for the next lower call,
179: * use static areas if the name is short, and malloc if the name
180: * is longer.
181: */
182:
183: #define STATIC_SIZE 200
184:
185: /*
186: * First, find the end of the next element in rem, checking
187: * along the way for special globbing characters.
188: */
189:
190: gotSpecial = 0;
191: openBrace = closeBrace = NULL;
192: for (p = rem; ; p++) {
193: c = *p;
194: if ((c == '\0') || (c == '/')) {
195: break;
196: }
197: if ((c == '{') && (openBrace == NULL)) {
198: openBrace = p;
199: }
200: if ((c == '}') && (closeBrace == NULL)) {
201: closeBrace = p;
202: }
203: if ((c == '*') || (c == '[') || (c == '\\') || (c == '?')) {
204: gotSpecial = 1;
205: }
206: }
207:
208: /*
209: * If there is an open brace in the argument, then make a recursive
210: * call for each element between the braces. In this case, the
211: * recursive call to DoGlob uses the same "dir" that we got.
212: * If there are several brace-pairs in a single name, we just handle
213: * one here, and the others will be handled in recursive calls.
214: */
215:
216: if (openBrace != NULL) {
217: int remLength, l1, l2;
218: char static1[STATIC_SIZE];
219: char *element, *newRem;
220:
221: if (closeBrace == NULL) {
222: interp->result = "unmatched open-brace in file name";
223: return TCL_ERROR;
224: }
225: remLength = strlen(rem) + 1;
226: if (remLength <= STATIC_SIZE) {
227: newRem = static1;
228: } else {
229: newRem = malloc((unsigned) remLength);
230: }
231: l1 = openBrace-rem;
232: strncpy(newRem, rem, l1);
233: p = openBrace;
234: for (p = openBrace; *p != '}'; ) {
235: element = p+1;
236: for (p = element; ((*p != '}') && (*p != ',')); p++) {
237: /* Empty body: just find end of this element. */
238: }
239: l2 = p - element;
240: strncpy(newRem+l1, element, l2);
241: strcpy(newRem+l1+l2, closeBrace+1);
242: if (DoGlob(interp, dir, newRem, resPtr) != TCL_OK) {
243: return TCL_ERROR;
244: }
245: }
246: if (remLength > STATIC_SIZE) {
247: free(newRem);
248: }
249: return TCL_OK;
250: }
251:
252: /*
253: * If there were any pattern-matching characters, then scan through
254: * the directory to find all the matching names.
255: */
256:
257: if (gotSpecial) {
258: DIR *d;
259: struct dirent *entryPtr;
260: int l1, l2;
261: char *pattern, *newDir;
262: char static1[STATIC_SIZE], static2[STATIC_SIZE];
263: struct stat statBuf;
264:
265: if ((stat(dir, &statBuf) != 0)
266: || !S_ISDIR(statBuf.st_mode)) {
267: return TCL_OK;
268: }
269: d = opendir(dir);
270: if (d == NULL) {
271: sprintf(interp->result,
272: "couldn't read directory \"%.50s\": %.50s",
273: dir, strerror(errno));
274: return TCL_ERROR;
275: }
276: l1 = strlen(dir);
277: l2 = (p - rem);
278: if (l2 < STATIC_SIZE) {
279: pattern = static2;
280: } else {
281: pattern = malloc((unsigned) (l2+1));
282: }
283: strncpy(pattern, rem, l2);
284: pattern[l2] = '\0';
285: result = TCL_OK;
286: while (1) {
287: entryPtr = readdir(d);
288: if (entryPtr == NULL) {
289: break;
290: }
291:
292: /*
293: * Don't match names starting with "." unless the "." is
294: * present in the pattern.
295: */
296:
297: if ((*entryPtr->d_name == '.') && (*pattern != '.')) {
298: continue;
299: }
300: if (Tcl_StringMatch(entryPtr->d_name, pattern)) {
301: if (*p == 0) {
302: AppendResult(dir, entryPtr->d_name,
303: (int) entryPtr->d_namlen, resPtr);
304: } else {
305: if ((l1+entryPtr->d_namlen+2) <= STATIC_SIZE) {
306: newDir = static1;
307: } else {
308: newDir = malloc((unsigned) (l1+entryPtr->d_namlen+2));
309: }
310: sprintf(newDir, "%s%s/", dir, entryPtr->d_name);
311: result = DoGlob(interp, newDir, p+1, resPtr);
312: if (newDir != static1) {
313: free(newDir);
314: }
315: if (result != TCL_OK) {
316: break;
317: }
318: }
319: }
320: }
321: if (pattern != static2) {
322: free(pattern);
323: }
324: return result;
325: }
326:
327: /*
328: * This is the simplest case: just another path element. Move
329: * it to the dir side and recurse (or just add the name to the
330: * list, if we're at the end of the path).
331: */
332:
333: if (*p == 0) {
334: AppendResult(dir, rem, p-rem, resPtr);
335: } else {
336: int l1, l2;
337: char *newDir;
338: char static1[STATIC_SIZE];
339:
340: l1 = strlen(dir);
341: l2 = l1 + (p - rem) + 2;
342: if (l2 <= STATIC_SIZE) {
343: newDir = static1;
344: } else {
345: newDir = malloc((unsigned) l2);
346: }
347: strcpy(newDir, dir);
348: strncpy(newDir+l1, rem, p-rem);
349: newDir[l2-2] = '/';
350: newDir[l2-1] = 0;
351: result = DoGlob(interp, newDir, p+1, resPtr);
352: if (newDir != static1) {
353: free(newDir);
354: }
355: if (result != TCL_OK) {
356: return TCL_ERROR;
357: }
358: }
359: return TCL_OK;
360: }
361:
362: /*
363: *----------------------------------------------------------------------
364: *
365: * Tcl_TildeSubst --
366: *
367: * Given a name starting with a tilde, produce a name where
368: * the tilde and following characters have been replaced by
369: * the home directory location for the named user.
370: *
371: * Results:
372: * The result is a pointer to a static string containing
373: * the new name. This name will only persist until the next
374: * call to Tcl_TildeSubst; save it if you care about it for
375: * the long term. If there was an error in processing the
376: * tilde, then an error message is left in interp->result
377: * and the return value is NULL.
378: *
379: * Side effects:
380: * None that the caller needs to worry about.
381: *
382: *----------------------------------------------------------------------
383: */
384:
385: char *
386: Tcl_TildeSubst(interp, name)
387: Tcl_Interp *interp; /* Interpreter in which to store error
388: * message (if necessary). */
389: char *name; /* File name, which may begin with "~/"
390: * (to indicate current user's home directory)
391: * or "~<user>/" (to indicate any user's
392: * home directory). */
393: {
394: #define STATIC_BUF_SIZE 50
395: static char staticBuf[STATIC_BUF_SIZE];
396: static int curSize = STATIC_BUF_SIZE;
397: static char *curBuf = staticBuf;
398: char *dir;
399: int length;
400: int fromPw = 0;
401: register char *p;
402:
403: if (name[0] != '~') {
404: return name;
405: }
406:
407: /*
408: * First, find the directory name corresponding to the tilde entry.
409: */
410:
411: if ((name[1] == '/') || (name[1] == '\0')) {
412: dir = getenv("HOME");
413: if (dir == NULL) {
414: sprintf(interp->result,
415: "couldn't find HOME env. variable to expand \"%.100s\"",
416: name);
417: return NULL;
418: }
419: p = name+1;
420: } else {
421: struct passwd *pwPtr;
422:
423: for (p = &name[1]; (*p != 0) && (*p != '/'); p++) {
424: /* Null body; just find end of name. */
425: }
426: length = p-&name[1];
427: if (length >= curSize) {
428: length = curSize-1;
429: }
430: bcopy(name+1, curBuf, length);
431: curBuf[length] = '\0';
432: pwPtr = getpwnam(curBuf);
433: if (pwPtr == NULL) {
434: sprintf(interp->result, "user \"%.50s\" doesn't exist", curBuf);
435: return NULL;
436: }
437: dir = pwPtr->pw_dir;
438: fromPw = 1;
439: }
440:
441: /*
442: * Grow the buffer if necessary to make enough space for the
443: * full file name.
444: */
445:
446: length = strlen(dir) + strlen(p);
447: if (length >= curSize) {
448: if (curBuf != staticBuf) {
449: free(curBuf);
450: }
451: curSize = length + 1;
452: curBuf = malloc((unsigned) curSize);
453: }
454:
455: /*
456: * Finally, concatenate the directory name with the remainder
457: * of the path in the buffer.
458: */
459:
460: strcpy(curBuf, dir);
461: strcat(curBuf, p);
462: if (fromPw) {
463: endpwent();
464: }
465: return curBuf;
466: }
467:
468: /*
469: *----------------------------------------------------------------------
470: *
471: * Tcl_GlobCmd --
472: *
473: * This procedure is invoked to process the "glob" Tcl command.
474: * See the user documentation for details on what it does.
475: *
476: * Results:
477: * A standard Tcl result.
478: *
479: * Side effects:
480: * See the user documentation.
481: *
482: *----------------------------------------------------------------------
483: */
484:
485: /* ARGSUSED */
486: int
487: Tcl_GlobCmd(dummy, interp, argc, argv)
488: ClientData dummy; /* Not used. */
489: Tcl_Interp *interp; /* Current interpreter. */
490: int argc; /* Number of arguments. */
491: char **argv; /* Argument strings. */
492: {
493: #pragma ref dummy
494: GlobResult globRes;
495: char staticSpace[TCL_RESULT_SIZE];
496: int i, result;
497:
498: globRes.result = staticSpace;
499: globRes.totalSpace = TCL_RESULT_SIZE;
500: globRes.spaceUsed = 0;
501: globRes.dynamic = 0;
502: for (i = 1; i < argc; i++) {
503: char *thisName;
504:
505: /*
506: * Do special checks for names starting at the root and for
507: * names beginning with ~. Then let DoGlob do the rest.
508: */
509:
510: thisName = argv[i];
511: if (*thisName == '~') {
512: thisName = Tcl_TildeSubst(interp, thisName);
513: if (thisName == NULL) {
514: return TCL_ERROR;
515: }
516: }
517: if (*thisName == '/') {
518: result = DoGlob(interp, "/", thisName+1, &globRes);
519: } else {
520: result = DoGlob(interp, "", thisName, &globRes);
521: }
522: if (result != TCL_OK) {
523: goto error;
524: }
525: }
526: if (globRes.spaceUsed == 0) {
527: sprintf(interp->result, "no files matched glob pattern(s)");
528: result = TCL_ERROR;
529: goto error;
530: }
531: if (globRes.dynamic) {
532: interp->result = globRes.result;
533: interp->dynamic = 1;
534: } else {
535: strcpy(interp->result, globRes.result);
536: }
537: return TCL_OK;
538:
539: error:
540: if (globRes.dynamic) {
541: free(globRes.result);
542: }
543: return result;
544: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.