[BACK]Return to glob.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / lib / libc / gen

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/lib/libc/gen/glob.c between version 1.1.1.1 and 1.1.1.2

version 1.1.1.1, 1993/03/21 09:45:37 version 1.1.1.2, 1995/02/25 09:12:07
Line 1 
Line 1 
 /*  /*
  * Copyright (c) 1989 The Regents of the University of California.   * Copyright (c) 1989, 1993
  * All rights reserved.   *      The Regents of the University of California.  All rights reserved.
  *   *
  * This code is derived from software contributed to Berkeley by   * This code is derived from software contributed to Berkeley by
  * Guido van Rossum.   * Guido van Rossum.
Line 35 
Line 35 
  */   */
   
 #if defined(LIBC_SCCS) && !defined(lint)  #if defined(LIBC_SCCS) && !defined(lint)
 static char sccsid[] = "@(#)glob.c      5.12 (Berkeley) 6/24/91";  static char sccsid[] = "@(#)glob.c      8.3 (Berkeley) 10/13/93";
 #endif /* LIBC_SCCS and not lint */  #endif /* LIBC_SCCS and not lint */
   
 /*  /*
Line 50  static char sccsid[] = "@(#)glob.c 5.12 
Line 50  static char sccsid[] = "@(#)glob.c 5.12 
  *      character might have (except \ at end of string is retained).   *      character might have (except \ at end of string is retained).
  * GLOB_MAGCHAR:   * GLOB_MAGCHAR:
  *      Set in gl_flags if pattern contained a globbing character.   *      Set in gl_flags if pattern contained a globbing character.
    * GLOB_NOMAGIC:
    *      Same as GLOB_NOCHECK, but it will only append pattern if it did
    *      not contain any magic characters.  [Used in csh style globbing]
    * GLOB_ALTDIRFUNC:
    *      Use alternately specified directory access functions.
    * GLOB_TILDE:
    *      expand ~user/foo to the /home/dir/of/user/foo
    * GLOB_BRACE:
    *      expand {1,2}{a,b} to 1a 1b 2a 2b
  * gl_matchc:   * gl_matchc:
  *      Number of matches in the current invocation of glob.   *      Number of matches in the current invocation of glob.
  */   */
   
 #include <sys/cdefs.h>  
 #include <sys/param.h>  #include <sys/param.h>
 #include <sys/stat.h>  #include <sys/stat.h>
 #include <dirent.h>  
 #include <glob.h>  
 #include <ctype.h>  #include <ctype.h>
   #include <dirent.h>
 #include <errno.h>  #include <errno.h>
 #include <string.h>  #include <glob.h>
   #include <pwd.h>
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
   #include <string.h>
   #include <unistd.h>
   
 #define DOLLAR          '$'  #define DOLLAR          '$'
 #define DOT             '.'  #define DOT             '.'
Line 78  static char sccsid[] = "@(#)glob.c 5.12 
Line 89  static char sccsid[] = "@(#)glob.c 5.12 
 #define STAR            '*'  #define STAR            '*'
 #define TILDE           '~'  #define TILDE           '~'
 #define UNDERSCORE      '_'  #define UNDERSCORE      '_'
   #define LBRACE          '{'
   #define RBRACE          '}'
   #define SLASH           '/'
   #define COMMA           ','
   
   #ifndef DEBUG
   
 #define M_QUOTE         0x8000  #define M_QUOTE         0x8000
 #define M_PROTECT       0x4000  #define M_PROTECT       0x4000
 #define M_MASK          0xffff  #define M_MASK          0xffff
 #define M_ASCII         0x00ff  #define M_ASCII         0x00ff
   
 #define CHAR(c)         ((c)&M_ASCII)  typedef u_short Char;
 #define META(c)         ((c)|M_QUOTE)  
   #else
   
   #define M_QUOTE         0x80
   #define M_PROTECT       0x40
   #define M_MASK          0xff
   #define M_ASCII         0x7f
   
   typedef char Char;
   
   #endif
   
   
   #define CHAR(c)         ((Char)((c)&M_ASCII))
   #define META(c)         ((Char)((c)|M_QUOTE))
 #define M_ALL           META('*')  #define M_ALL           META('*')
 #define M_END           META(']')  #define M_END           META(']')
 #define M_NOT           META('!')  #define M_NOT           META('!')
Line 94  static char sccsid[] = "@(#)glob.c 5.12 
Line 125  static char sccsid[] = "@(#)glob.c 5.12 
 #define M_SET           META('[')  #define M_SET           META('[')
 #define ismeta(c)       (((c)&M_QUOTE) != 0)  #define ismeta(c)       (((c)&M_QUOTE) != 0)
   
 typedef u_short Char;  
   
 static int       compare __P((const void *, const void *));  static int       compare __P((const void *, const void *));
 static void      g_Ctoc __P((Char *, char *));  static void      g_Ctoc __P((const Char *, char *));
 static int       g_lstat __P((Char *, struct stat *));  static int       g_lstat __P((Char *, struct stat *, glob_t *));
 static DIR      *g_opendir __P((Char *));  static DIR      *g_opendir __P((Char *, glob_t *));
 static Char     *g_strchr __P((Char *, int));  static Char     *g_strchr __P((Char *, int));
 static int       g_stat __P((Char *, struct stat *));  #ifdef notdef
   static Char     *g_strcat __P((Char *, const Char *));
   #endif
   static int       g_stat __P((Char *, struct stat *, glob_t *));
   static int       glob0 __P((const Char *, glob_t *));
 static int       glob1 __P((Char *, glob_t *));  static int       glob1 __P((Char *, glob_t *));
 static int       glob2 __P((Char *, Char *, Char *, glob_t *));  static int       glob2 __P((Char *, Char *, Char *, glob_t *));
 static int       glob3 __P((Char *, Char *, Char *, Char *, glob_t *));  static int       glob3 __P((Char *, Char *, Char *, Char *, glob_t *));
 static int       globextend __P((Char *, glob_t *));  static int       globextend __P((const Char *, glob_t *));
   static const Char *      globtilde __P((const Char *, Char *, glob_t *));
   static int       globexp1 __P((const Char *, glob_t *));
   static int       globexp2 __P((const Char *, const Char *, glob_t *, int *));
 static int       match __P((Char *, Char *, Char *));  static int       match __P((Char *, Char *, Char *));
 #ifdef DEBUG  #ifdef DEBUG
 static void      qprintf __P((Char *));  static void      qprintf __P((const char *, Char *));
 #endif  #endif
   
 /*  int
  * The main glob() routine: compiles the pattern (optionally processing  
  * quotes), calls glob1() to do the real pattern matching, and finally  
  * sorts the list (unless unsorted operation is requested).  Returns 0  
  * if things went well, nonzero if errors occurred.  It is not an error  
  * to find no matches.  
  */  
 glob(pattern, flags, errfunc, pglob)  glob(pattern, flags, errfunc, pglob)
         const char *pattern;          const char *pattern;
         int flags, (*errfunc) __P((char *, int));          int flags, (*errfunc) __P((const char *, int));
         glob_t *pglob;          glob_t *pglob;
 {  {
         const u_char *compilepat, *patnext;          const u_char *patnext;
         int c, err, oldpathc;          int c;
         Char *bufnext, *bufend, *compilebuf, *qpatnext, patbuf[MAXPATHLEN+1];          Char *bufnext, *bufend, patbuf[MAXPATHLEN+1];
   
         patnext = (u_char *) pattern;          patnext = (u_char *) pattern;
         if (!(flags & GLOB_APPEND)) {          if (!(flags & GLOB_APPEND)) {
Line 136  glob(pattern, flags, errfunc, pglob)
Line 167  glob(pattern, flags, errfunc, pglob)
         }          }
         pglob->gl_flags = flags & ~GLOB_MAGCHAR;          pglob->gl_flags = flags & ~GLOB_MAGCHAR;
         pglob->gl_errfunc = errfunc;          pglob->gl_errfunc = errfunc;
         oldpathc = pglob->gl_pathc;  
         pglob->gl_matchc = 0;          pglob->gl_matchc = 0;
   
         bufnext = patbuf;          bufnext = patbuf;
         bufend = bufnext + MAXPATHLEN;          bufend = bufnext + MAXPATHLEN;
         compilebuf = bufnext;  
         compilepat = patnext;  
         if (flags & GLOB_QUOTE) {          if (flags & GLOB_QUOTE) {
                 /* Protect the quoted characters. */                  /* Protect the quoted characters. */
                 while (bufnext < bufend && (c = *patnext++) != EOS)                  while (bufnext < bufend && (c = *patnext++) != EOS)
Line 161  glob(pattern, flags, errfunc, pglob)
Line 189  glob(pattern, flags, errfunc, pglob)
                     *bufnext++ = c;                      *bufnext++ = c;
         *bufnext = EOS;          *bufnext = EOS;
   
           if (flags & GLOB_BRACE)
               return globexp1(patbuf, pglob);
           else
               return glob0(patbuf, pglob);
   }
   
   /*
    * Expand recursively a glob {} pattern. When there is no more expansion
    * invoke the standard globbing routine to glob the rest of the magic
    * characters
    */
   static int globexp1(pattern, pglob)
           const Char *pattern;
           glob_t *pglob;
   {
           const Char* ptr = pattern;
           int rv;
   
           /* Protect a single {}, for find(1), like csh */
           if (pattern[0] == LBRACE && pattern[1] == RBRACE && pattern[2] == EOS)
                   return glob0(pattern, pglob);
   
           while ((ptr = (const Char *) g_strchr((Char *) ptr, LBRACE)) != NULL)
                   if (!globexp2(ptr, pattern, pglob, &rv))
                           return rv;
   
           return glob0(pattern, pglob);
   }
   
   
   /*
    * Recursive brace globbing helper. Tries to expand a single brace.
    * If it succeeds then it invokes globexp1 with the new pattern.
    * If it fails then it tries to glob the rest of the pattern and returns.
    */
   static int globexp2(ptr, pattern, pglob, rv)
           const Char *ptr, *pattern;
           glob_t *pglob;
           int *rv;
   {
           int     i;
           Char   *lm, *ls;
           const Char *pe, *pm, *pl;
           Char    patbuf[MAXPATHLEN + 1];
   
           /* copy part up to the brace */
           for (lm = patbuf, pm = pattern; pm != ptr; *lm++ = *pm++)
                   continue;
           ls = lm;
   
           /* Find the balanced brace */
           for (i = 0, pe = ++ptr; *pe; pe++)
                   if (*pe == LBRACKET) {
                           /* Ignore everything between [] */
                           for (pm = pe++; *pe != RBRACKET && *pe != EOS; pe++)
                                   continue;
                           if (*pe == EOS) {
                                   /*
                                    * We could not find a matching RBRACKET.
                                    * Ignore and just look for RBRACE
                                    */
                                   pe = pm;
                           }
                   }
                   else if (*pe == LBRACE)
                           i++;
                   else if (*pe == RBRACE) {
                           if (i == 0)
                                   break;
                           i--;
                   }
   
           /* Non matching braces; just glob the pattern */
           if (i != 0 || *pe == EOS) {
                   *rv = glob0(patbuf, pglob);
                   return 0;
           }
   
           for (i = 0, pl = pm = ptr; pm <= pe; pm++)
                   switch (*pm) {
                   case LBRACKET:
                           /* Ignore everything between [] */
                           for (pl = pm++; *pm != RBRACKET && *pm != EOS; pm++)
                                   continue;
                           if (*pm == EOS) {
                                   /*
                                    * We could not find a matching RBRACKET.
                                    * Ignore and just look for RBRACE
                                    */
                                   pm = pl;
                           }
                           break;
   
                   case LBRACE:
                           i++;
                           break;
   
                   case RBRACE:
                           if (i) {
                               i--;
                               break;
                           }
                           /* FALLTHROUGH */
                   case COMMA:
                           if (i && *pm == COMMA)
                                   break;
                           else {
                                   /* Append the current string */
                                   for (lm = ls; (pl < pm); *lm++ = *pl++)
                                           continue;
                                   /*
                                    * Append the rest of the pattern after the
                                    * closing brace
                                    */
                                   for (pl = pe + 1; (*lm++ = *pl++) != EOS;)
                                           continue;
   
                                   /* Expand the current pattern */
   #ifdef DEBUG
                                   qprintf("globexp2:", patbuf);
   #endif
                                   *rv = globexp1(patbuf, pglob);
   
                                   /* move after the comma, to the next string */
                                   pl = pm + 1;
                           }
                           break;
   
                   default:
                           break;
                   }
           *rv = 0;
           return 0;
   }
   
   
   
   /*
    * expand tilde from the passwd file.
    */
   static const Char *
   globtilde(pattern, patbuf, pglob)
           const Char *pattern;
           Char *patbuf;
           glob_t *pglob;
   {
           struct passwd *pwd;
           char *h;
           const Char *p;
           Char *b;
   
           if (*pattern != TILDE || !(pglob->gl_flags & GLOB_TILDE))
                   return pattern;
   
           /* Copy up to the end of the string or / */
           for (p = pattern + 1, h = (char *) patbuf; *p && *p != SLASH;
                *h++ = *p++)
                   continue;
   
           *h = EOS;
   
           if (((char *) patbuf)[0] == EOS) {
                   /*
                    * handle a plain ~ or ~/ by expanding $HOME
                    * first and then trying the password file
                    */
                   if ((h = getenv("HOME")) == NULL) {
                           if ((pwd = getpwuid(getuid())) == NULL)
                                   return pattern;
                           else
                                   h = pwd->pw_dir;
                   }
           }
           else {
                   /*
                    * Expand a ~user
                    */
                   if ((pwd = getpwnam((char*) patbuf)) == NULL)
                           return pattern;
                   else
                           h = pwd->pw_dir;
           }
   
           /* Copy the home directory */
           for (b = patbuf; *h; *b++ = *h++)
                   continue;
   
           /* Append the rest of the pattern */
           while ((*b++ = *p++) != EOS)
                   continue;
   
           return patbuf;
   }
   
   
   /*
    * The main glob() routine: compiles the pattern (optionally processing
    * quotes), calls glob1() to do the real pattern matching, and finally
    * sorts the list (unless unsorted operation is requested).  Returns 0
    * if things went well, nonzero if errors occurred.  It is not an error
    * to find no matches.
    */
   static int
   glob0(pattern, pglob)
           const Char *pattern;
           glob_t *pglob;
   {
           const Char *qpatnext;
           int c, err, oldpathc;
           Char *bufnext, patbuf[MAXPATHLEN+1];
   
           qpatnext = globtilde(pattern, patbuf, pglob);
           oldpathc = pglob->gl_pathc;
         bufnext = patbuf;          bufnext = patbuf;
         qpatnext = patbuf;  
         /* We don't need to check for buffer overflow any more. */          /* We don't need to check for buffer overflow any more. */
         while ((c = *qpatnext++) != EOS) {          while ((c = *qpatnext++) != EOS) {
                 switch (c) {                  switch (c) {
                 case LBRACKET:                  case LBRACKET:
                         pglob->gl_flags |= GLOB_MAGCHAR;  
                         c = *qpatnext;                          c = *qpatnext;
                         if (c == NOT)                          if (c == NOT)
                                 ++qpatnext;                                  ++qpatnext;
                         if (*qpatnext == EOS ||                          if (*qpatnext == EOS ||
                             g_strchr(qpatnext+1, RBRACKET) == NULL) {                              g_strchr((Char *) qpatnext+1, RBRACKET) == NULL) {
                                 *bufnext++ = LBRACKET;                                  *bufnext++ = LBRACKET;
                                 if (c == NOT)                                  if (c == NOT)
                                         --qpatnext;                                          --qpatnext;
Line 191  glob(pattern, flags, errfunc, pglob)
Line 431  glob(pattern, flags, errfunc, pglob)
                                         qpatnext += 2;                                          qpatnext += 2;
                                 }                                  }
                         } while ((c = *qpatnext++) != RBRACKET);                          } while ((c = *qpatnext++) != RBRACKET);
                           pglob->gl_flags |= GLOB_MAGCHAR;
                         *bufnext++ = M_END;                          *bufnext++ = M_END;
                         break;                          break;
                 case QUESTION:                  case QUESTION:
Line 199  glob(pattern, flags, errfunc, pglob)
Line 440  glob(pattern, flags, errfunc, pglob)
                         break;                          break;
                 case STAR:                  case STAR:
                         pglob->gl_flags |= GLOB_MAGCHAR;                          pglob->gl_flags |= GLOB_MAGCHAR;
                         *bufnext++ = M_ALL;                          /* collapse adjacent stars to one,
                            * to avoid exponential behavior
                            */
                           if (bufnext == patbuf || bufnext[-1] != M_ALL)
                               *bufnext++ = M_ALL;
                         break;                          break;
                 default:                  default:
                         *bufnext++ = CHAR(c);                          *bufnext++ = CHAR(c);
Line 208  glob(pattern, flags, errfunc, pglob)
Line 453  glob(pattern, flags, errfunc, pglob)
         }          }
         *bufnext = EOS;          *bufnext = EOS;
 #ifdef DEBUG  #ifdef DEBUG
         qprintf(patbuf);          qprintf("glob0:", patbuf);
 #endif  #endif
   
         if ((err = glob1(patbuf, pglob)) != 0)          if ((err = glob1(patbuf, pglob)) != 0)
                 return(err);                  return(err);
   
         if (pglob->gl_pathc == oldpathc && flags & GLOB_NOCHECK) {          /*
                 if (!(flags & GLOB_QUOTE)) {           * If there was no match we are going to append the pattern
                         Char *dp = compilebuf;           * if GLOB_NOCHECK was specified or if GLOB_NOMAGIC was specified
                         const u_char *sp = compilepat;           * and the pattern did not contain any magic characters
                         while (*dp++ = *sp++);           * GLOB_NOMAGIC is there just for compatibility with csh.
                 }           */
                 else {          if (pglob->gl_pathc == oldpathc &&
                         /*              ((pglob->gl_flags & GLOB_NOCHECK) ||
                          * Copy pattern, interpreting quotes; this is slightly                ((pglob->gl_flags & GLOB_NOMAGIC) &&
                          * different than the interpretation of quotes above                 !(pglob->gl_flags & GLOB_MAGCHAR))))
                          * -- which should prevail?                  return(globextend(pattern, pglob));
                          */          else if (!(pglob->gl_flags & GLOB_NOSORT))
                         while (*compilepat != EOS) {  
                                 if (*compilepat == QUOTE) {  
                                         if (*++compilepat == EOS)  
                                                 --compilepat;  
                                 }  
                                 *compilebuf++ = (u_char)*compilepat++;  
                         }  
                         *compilebuf = EOS;  
                 }  
                 return(globextend(patbuf, pglob));  
         } else if (!(flags & GLOB_NOSORT))  
                 qsort(pglob->gl_pathv + pglob->gl_offs + oldpathc,                  qsort(pglob->gl_pathv + pglob->gl_offs + oldpathc,
                     pglob->gl_pathc - oldpathc, sizeof(char *), compare);                      pglob->gl_pathc - oldpathc, sizeof(char *), compare);
         return(0);          return(0);
Line 249  compare(p, q)
Line 483  compare(p, q)
         return(strcmp(*(char **)p, *(char **)q));          return(strcmp(*(char **)p, *(char **)q));
 }  }
   
 static  static int
 glob1(pattern, pglob)  glob1(pattern, pglob)
         Char *pattern;          Char *pattern;
         glob_t *pglob;          glob_t *pglob;
Line 267  glob1(pattern, pglob)
Line 501  glob1(pattern, pglob)
  * of recursion for each segment in the pattern that contains one or more   * of recursion for each segment in the pattern that contains one or more
  * meta characters.   * meta characters.
  */   */
 static  static int
 glob2(pathbuf, pathend, pattern, pglob)  glob2(pathbuf, pathend, pattern, pglob)
         Char *pathbuf, *pathend, *pattern;          Char *pathbuf, *pathend, *pattern;
         glob_t *pglob;          glob_t *pglob;
Line 283  glob2(pathbuf, pathend, pattern, pglob)
Line 517  glob2(pathbuf, pathend, pattern, pglob)
         for (anymeta = 0;;) {          for (anymeta = 0;;) {
                 if (*pattern == EOS) {          /* End of pattern? */                  if (*pattern == EOS) {          /* End of pattern? */
                         *pathend = EOS;                          *pathend = EOS;
                         if (g_stat(pathbuf, &sb))                          if (g_lstat(pathbuf, &sb, pglob))
                                 return(0);                                  return(0);
   
                         if (((pglob->gl_flags & GLOB_MARK) &&                          if (((pglob->gl_flags & GLOB_MARK) &&
                             pathend[-1] != SEP) && (S_ISDIR(sb.st_mode)                              pathend[-1] != SEP) && (S_ISDIR(sb.st_mode)
                             || (S_ISLNK(sb.st_mode) &&                              || (S_ISLNK(sb.st_mode) &&
                             (g_stat(pathbuf, &sb) == 0) &&                              (g_stat(pathbuf, &sb, pglob) == 0) &&
                             S_ISDIR(sb.st_mode)))) {                              S_ISDIR(sb.st_mode)))) {
                                 *pathend++ = SEP;                                  *pathend++ = SEP;
                                 *pathend = EOS;                                  *pathend = EOS;
Line 318  glob2(pathbuf, pathend, pattern, pglob)
Line 552  glob2(pathbuf, pathend, pattern, pglob)
         /* NOTREACHED */          /* NOTREACHED */
 }  }
   
 static  static int
 glob3(pathbuf, pathend, pattern, restpattern, pglob)  glob3(pathbuf, pathend, pattern, restpattern, pglob)
         Char *pathbuf, *pathend, *pattern, *restpattern;          Char *pathbuf, *pathend, *pattern, *restpattern;
         glob_t *pglob;          glob_t *pglob;
 {  {
         register struct dirent *dp;          register struct dirent *dp;
         DIR *dirp;          DIR *dirp;
         int len, err;          int err;
           char buf[MAXPATHLEN];
   
           /*
            * The readdirfunc declaration can't be prototyped, because it is
            * assigned, below, to two functions which are prototyped in glob.h
            * and dirent.h as taking pointers to differently typed opaque
            * structures.
            */
           struct dirent *(*readdirfunc)();
   
         *pathend = EOS;          *pathend = EOS;
         errno = 0;          errno = 0;
   
         if (!(dirp = g_opendir(pathbuf)))          if ((dirp = g_opendir(pathbuf, pglob)) == NULL) {
                 /* TODO: don't call for ENOENT or ENOTDIR? */                  /* TODO: don't call for ENOENT or ENOTDIR? */
                 if (pglob->gl_errfunc &&                  if (pglob->gl_errfunc) {
                     (*pglob->gl_errfunc)(pathbuf, errno) ||                          g_Ctoc(pathbuf, buf);
                     (pglob->gl_flags & GLOB_ERR))                          if (pglob->gl_errfunc(buf, errno) ||
                         return(GLOB_ABEND);                              pglob->gl_flags & GLOB_ERR)
                 else                                  return (GLOB_ABEND);
                         return(0);                  }
                   return(0);
           }
   
         err = 0;          err = 0;
   
         /* Search directory for matching names. */          /* Search directory for matching names. */
         while ((dp = readdir(dirp))) {          if (pglob->gl_flags & GLOB_ALTDIRFUNC)
                   readdirfunc = pglob->gl_readdir;
           else
                   readdirfunc = readdir;
           while ((dp = (*readdirfunc)(dirp))) {
                 register u_char *sc;                  register u_char *sc;
                 register Char *dc;                  register Char *dc;
   
Line 350  glob3(pathbuf, pathend, pattern, restpat
Line 599  glob3(pathbuf, pathend, pattern, restpat
                 if (dp->d_name[0] == DOT && *pattern != DOT)                  if (dp->d_name[0] == DOT && *pattern != DOT)
                         continue;                          continue;
                 for (sc = (u_char *) dp->d_name, dc = pathend;                  for (sc = (u_char *) dp->d_name, dc = pathend;
                      *dc++ = *sc++;);                       (*dc++ = *sc++) != EOS;)
                           continue;
                 if (!match(pathend, pattern, restpattern)) {                  if (!match(pathend, pattern, restpattern)) {
                         *pathend = EOS;                          *pathend = EOS;
                         continue;                          continue;
Line 360  glob3(pathbuf, pathend, pattern, restpat
Line 610  glob3(pathbuf, pathend, pattern, restpat
                         break;                          break;
         }          }
   
         /* TODO: check error from readdir? */          if (pglob->gl_flags & GLOB_ALTDIRFUNC)
         (void)closedir(dirp);                  (*pglob->gl_closedir)(dirp);
           else
                   closedir(dirp);
         return(err);          return(err);
 }  }
   
Line 382  glob3(pathbuf, pathend, pattern, restpat
Line 634  glob3(pathbuf, pathend, pattern, restpat
  */   */
 static int  static int
 globextend(path, pglob)  globextend(path, pglob)
         Char *path;          const Char *path;
         glob_t *pglob;          glob_t *pglob;
 {  {
         register char **pathv;          register char **pathv;
         register int i;          register int i;
         u_int newsize;          u_int newsize;
         char *copy;          char *copy;
         Char *p;          const Char *p;
   
         newsize = sizeof(*pathv) * (2 + pglob->gl_pathc + pglob->gl_offs);          newsize = sizeof(*pathv) * (2 + pglob->gl_pathc + pglob->gl_offs);
         pathv = (char **)realloc((char *)pglob->gl_pathv, newsize);          pathv = pglob->gl_pathv ?
                       realloc((char *)pglob->gl_pathv, newsize) :
                       malloc(newsize);
         if (pathv == NULL)          if (pathv == NULL)
                 return(GLOB_NOSPACE);                  return(GLOB_NOSPACE);
   
Line 404  globextend(path, pglob)
Line 658  globextend(path, pglob)
         }          }
         pglob->gl_pathv = pathv;          pglob->gl_pathv = pathv;
   
         for (p = path; *p++;);          for (p = path; *p++;)
                   continue;
         if ((copy = malloc(p - path)) != NULL) {          if ((copy = malloc(p - path)) != NULL) {
                 g_Ctoc(path, copy);                  g_Ctoc(path, copy);
                 pathv[pglob->gl_offs + pglob->gl_pathc++] = copy;                  pathv[pglob->gl_offs + pglob->gl_pathc++] = copy;
Line 418  globextend(path, pglob)
Line 673  globextend(path, pglob)
  * pattern matching function for filenames.  Each occurrence of the *   * pattern matching function for filenames.  Each occurrence of the *
  * pattern causes a recursion level.   * pattern causes a recursion level.
  */   */
 static  static int
 match(name, pat, patend)  match(name, pat, patend)
         register Char *name, *pat, *patend;          register Char *name, *pat, *patend;
 {  {
Line 431  match(name, pat, patend)
Line 686  match(name, pat, patend)
                 case M_ALL:                  case M_ALL:
                         if (pat == patend)                          if (pat == patend)
                                 return(1);                                  return(1);
                         for (; *name != EOS; ++name)                          do
                                 if (match(name, pat, patend))                              if (match(name, pat, patend))
                                         return(1);                                      return(1);
                           while (*name++ != EOS);
                         return(0);                          return(0);
                 case M_ONE:                  case M_ONE:
                         if (*name++ == EOS)                          if (*name++ == EOS)
Line 441  match(name, pat, patend)
Line 697  match(name, pat, patend)
                         break;                          break;
                 case M_SET:                  case M_SET:
                         ok = 0;                          ok = 0;
                         k = *name++;                          if ((k = *name++) == EOS)
                         if (negate_range = ((*pat & M_MASK) == M_NOT))                                  return(0);
                           if ((negate_range = ((*pat & M_MASK) == M_NOT)) != EOS)
                                 ++pat;                                  ++pat;
                         while (((c = *pat++) & M_MASK) != M_END)                          while (((c = *pat++) & M_MASK) != M_END)
                                 if ((*pat & M_MASK) == M_RNG) {                                  if ((*pat & M_MASK) == M_RNG) {
Line 481  globfree(pglob)
Line 738  globfree(pglob)
 }  }
   
 static DIR *  static DIR *
 g_opendir(str)  g_opendir(str, pglob)
         register Char *str;          register Char *str;
           glob_t *pglob;
 {  {
         char buf[MAXPATHLEN];          char buf[MAXPATHLEN];
   
         if (!*str)          if (!*str)
                 return(opendir("."));                  strcpy(buf, ".");
         g_Ctoc(str, buf);          else
                   g_Ctoc(str, buf);
   
           if (pglob->gl_flags & GLOB_ALTDIRFUNC)
                   return((*pglob->gl_opendir)(buf));
   
         return(opendir(buf));          return(opendir(buf));
 }  }
   
 static int  static int
 g_lstat(fn, sb)  g_lstat(fn, sb, pglob)
         register Char *fn;          register Char *fn;
         struct stat *sb;          struct stat *sb;
           glob_t *pglob;
 {  {
         char buf[MAXPATHLEN];          char buf[MAXPATHLEN];
   
         g_Ctoc(fn, buf);          g_Ctoc(fn, buf);
           if (pglob->gl_flags & GLOB_ALTDIRFUNC)
                   return((*pglob->gl_lstat)(buf, sb));
         return(lstat(buf, sb));          return(lstat(buf, sb));
 }  }
   
 static int  static int
 g_stat(fn, sb)  g_stat(fn, sb, pglob)
         register Char *fn;          register Char *fn;
         struct stat *sb;          struct stat *sb;
           glob_t *pglob;
 {  {
         char buf[MAXPATHLEN];          char buf[MAXPATHLEN];
   
         g_Ctoc(fn, buf);          g_Ctoc(fn, buf);
           if (pglob->gl_flags & GLOB_ALTDIRFUNC)
                   return((*pglob->gl_stat)(buf, sb));
         return(stat(buf, sb));          return(stat(buf, sb));
 }  }
   
Line 526  g_strchr(str, ch)
Line 795  g_strchr(str, ch)
         return (NULL);          return (NULL);
 }  }
   
   #ifdef notdef
   static Char *
   g_strcat(dst, src)
           Char *dst;
           const Char* src;
   {
           Char *sdst = dst;
   
           while (*dst++)
                   continue;
           --dst;
           while((*dst++ = *src++) != EOS)
               continue;
   
           return (sdst);
   }
   #endif
   
 static void  static void
 g_Ctoc(str, buf)  g_Ctoc(str, buf)
         register Char *str;          register const Char *str;
         char *buf;          char *buf;
 {  {
         register char *dc;          register char *dc;
   
         for (dc = buf; *dc++ = *str++;);          for (dc = buf; (*dc++ = *str++) != EOS;)
                   continue;
 }  }
   
 #ifdef DEBUG  #ifdef DEBUG
 static void  static void
 qprintf(s)  qprintf(str, s)
           const char *str;
         register Char *s;          register Char *s;
 {  {
         register Char *p;          register Char *p;
   
           (void)printf("%s:\n", str);
         for (p = s; *p; p++)          for (p = s; *p; p++)
                 (void)printf("%c", *p & 0xff);                  (void)printf("%c", CHAR(*p));
         (void)printf("\n");          (void)printf("\n");
         for (p = s; *p; p++)          for (p = s; *p; p++)
                 (void)printf("%c", *p & M_PROTECT ? '"' : ' ');                  (void)printf("%c", *p & M_PROTECT ? '"' : ' ');
         (void)printf("\n");          (void)printf("\n");
         for (p = s; *p; p++)          for (p = s; *p; p++)
                 (void)printf("%c", *p & M_META ? '_' : ' ');                  (void)printf("%c", ismeta(*p) ? '_' : ' ');
         (void)printf("\n");          (void)printf("\n");
 }  }
 #endif  #endif

Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.2

CVSweb <webmaster@jp.NetBSD.org>