home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 mARCH / PCWK3A99.iso / Linux / DDD331 / DDD-3_1_.000 / DDD-3_1_ / ddd-3.1.1 / ddd / glob.C < prev    next >
C/C++ Source or Header  |  1998-07-06  |  14KB  |  581 lines
  1. /* File-name wildcard pattern matching for GNU.
  2.    Copyright (C) 1985, 1988, 1989, 1991 Free Software Foundation, Inc.
  3.  
  4.    This program is free software; you can redistribute it and/or modify
  5.    it under the terms of the GNU General Public License as published by
  6.    the Free Software Foundation; either version 2 of the License, or
  7.    (at your option) any later version.
  8.  
  9.    This program is distributed in the hope that it will be useful,
  10.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.    GNU General Public License for more details.
  13.  
  14.    You should have received a copy of the GNU General Public License
  15.    along with this program; if not, write to the Free Software
  16.    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17.  
  18.  
  19. /* To whomever it may concern: I have never seen the code which most
  20.    Unix programs use to perform this function.  I wrote this from scratch
  21.    based on specifications for the pattern matching.  --RMS.  */
  22.  
  23. // Arranged for C++ and autoconf by Andreas Zeller
  24. // C++ comments indicate changes to Stallman's original C code.
  25.  
  26. #include "my-alloca.h"
  27.  
  28. // Yep, `#pragma alloca' must come even before this simple stuff.  Sigh.
  29. char glob_rcsid[] = 
  30.     "$Id: glob.C,v 1.20 1998/07/06 11:27:25 zeller Exp $";
  31.  
  32. #include "my-dirent.h"
  33.  
  34. #include "glob.h"
  35.  
  36. // Other headers, hopefully more portable
  37. #if HAVE_SYS_STAT_H
  38. #include <sys/stat.h>
  39. #endif
  40. #if HAVE_SYS_TYPES_H
  41. #include <sys/types.h>
  42. #endif
  43.  
  44. #include <string.h>
  45. #include <stdlib.h>
  46. #include <stdio.h>
  47.  
  48. #if HAVE_MEMCPY && !HAVE_MEMCPY_DECL
  49. extern "C" void *memcpy(void *to, const void *from, size_t size);
  50. #endif
  51.  
  52. // These should be checked by autoconf, but we prefer to play it safe
  53. #ifndef _POSIX_SOURCE
  54. #define _POSIX_SOURCE
  55. #endif
  56.  
  57. #ifndef OPENDIR_NOT_ROBUST
  58. #define OPENDIR_NOT_ROBUST
  59. #endif
  60.  
  61. #if defined (_POSIX_SOURCE)
  62. /* Posix does not require that the d_ino field be present, and some
  63.    systems do not provide it. */
  64. #define REAL_DIR_ENTRY(dp) 1
  65. #else
  66. #define REAL_DIR_ENTRY(dp) (dp->d_ino != 0)
  67. #endif /* _POSIX_SOURCE */
  68.  
  69.  
  70. /* Global variable which controls whether or not * matches .*.
  71.    Non-zero means don't match .*.  */
  72. int noglob_dot_filenames = 1;
  73.  
  74.  
  75. static int glob_match_after_star (char *pattern, char *text);
  76.  
  77. /* Return nonzero if PATTERN has any special globbing chars in it.  */
  78. int
  79. glob_pattern_p (char *pattern)
  80. {
  81.   register char *p = pattern;
  82.   register char c;
  83.   int    open = 0;
  84.  
  85.   while ((c = *p++) != '\0')
  86.     switch (c)
  87.       {
  88.       case '?':
  89.       case '*':
  90.     return 1;
  91.  
  92.       case '[':        /* Only accept an open brace if there is a close */
  93.     open++;        /* brace to match it.  Bracket expressions must be */
  94.     continue;    /* complete, according to Posix.2 */
  95.       case ']':
  96.     if (open)
  97.       return 1;
  98.     continue;      
  99.  
  100.       case '\\':
  101.     if (*p++ == '\0')
  102.       return 0;
  103.       }
  104.  
  105.   return 0;
  106. }
  107.  
  108. /* Match the pattern PATTERN against the string TEXT;
  109.    return 1 if it matches, 0 otherwise.
  110.  
  111.    A match means the entire string TEXT is used up in matching.
  112.  
  113.    In the pattern string, `*' matches any sequence of characters,
  114.    `?' matches any character, [SET] matches any character in the specified set,
  115.    [!SET] matches any character not in the specified set.
  116.  
  117.    A set is composed of characters or ranges; a range looks like
  118.    character hyphen character (as in 0-9 or A-Z).
  119.    [0-9a-zA-Z_] is the set of characters allowed in C identifiers.
  120.    Any other character in the pattern must be matched exactly.
  121.  
  122.    To suppress the special syntactic significance of any of `[]*?!-\',
  123.    and match the character exactly, precede it with a `\'.
  124.  
  125.    If DOT_SPECIAL is nonzero,
  126.    `*' and `?' do not match `.' at the beginning of TEXT.  */
  127. int
  128. glob_match (char *pattern, char *text, int dot_special)
  129. {
  130.   register char *p = pattern, *t = text;
  131.   register char c;
  132.  
  133.   while ((c = *p++) != '\0')
  134.     switch (c)
  135.       {
  136.       case '?':
  137.     if (*t == '\0' || (dot_special && t == text && *t == '.'))
  138.       return 0;
  139.     else
  140.       ++t;
  141.     break;
  142.  
  143.       case '\\':
  144.     if (*p++ != *t++)
  145.       return 0;
  146.     break;
  147.  
  148.       case '*':
  149.     if (dot_special && t == text && *t == '.')
  150.       return 0;
  151.     return glob_match_after_star (p, t);
  152.  
  153.       case '[':
  154.     {
  155.       register char c1 = *t++;
  156.       int invert;
  157.  
  158.       if (!c1)
  159.         return (0);
  160.  
  161.       invert = ((*p == '!') || (*p == '^'));
  162.       if (invert)
  163.         p++;
  164.  
  165.       c = *p++;
  166.       while (1)
  167.         {
  168.           register char cstart = c, cend = c;
  169.  
  170.           if (c == '\\')
  171.         {
  172.           cstart = *p++;
  173.           cend = cstart;
  174.         }
  175.  
  176.           if (c == '\0')
  177.         return 0;
  178.  
  179.           c = *p++;
  180.           if (c == '-' && *p != ']')
  181.         {
  182.           cend = *p++;
  183.           if (cend == '\\')
  184.             cend = *p++;
  185.           if (cend == '\0')
  186.             return 0;
  187.           c = *p++;
  188.         }
  189.           if (c1 >= cstart && c1 <= cend)
  190.         goto match;
  191.           if (c == ']')
  192.         break;
  193.         }
  194.       if (!invert)
  195.         return 0;
  196.       break;
  197.  
  198.     match:
  199.       /* Skip the rest of the [...] construct that already matched.  */
  200.       while (c != ']')
  201.         { 
  202.           if (c == '\0')
  203.         return 0;
  204.           c = *p++;
  205.           if (c == '\0')
  206.         return 0;
  207.           else if (c == '\\')
  208.         ++p;
  209.         }
  210.       if (invert)
  211.         return 0;
  212.       break;
  213.     }
  214.  
  215.       default:
  216.     if (c != *t++)
  217.       return 0;
  218.       }
  219.  
  220.   return *t == '\0';
  221. }
  222.  
  223. /* Like glob_match, but match PATTERN against any final segment of TEXT.  */
  224.  
  225. static int
  226. glob_match_after_star (char *pattern, char *text)
  227. {
  228.   register char *p = pattern, *t = text;
  229.   register char c, c1;
  230.  
  231.   while ((c = *p++) == '?' || c == '*')
  232.     if (c == '?' && *t++ == '\0')
  233.       return 0;
  234.  
  235.   if (c == '\0')
  236.     return 1;
  237.  
  238.   if (c == '\\')
  239.     c1 = *p;
  240.   else
  241.     c1 = c;
  242.  
  243.   while (1)
  244.     {
  245.       if ((c == '[' || *t == c1) && glob_match (p - 1, t, 0))
  246.     return 1;
  247.       if (*t++ == '\0')
  248.     return 0;
  249.     }
  250. }
  251.  
  252. /* Return a vector of names of files in directory DIR
  253.    whose names match glob pattern PAT.
  254.    The names are not in any particular order.
  255.    Wildcards at the beginning of PAT do not match an initial period.
  256.  
  257.    The vector is terminated by an element that is a null pointer.
  258.  
  259.    To free the space allocated, first free the vector's elements,
  260.    then free the vector.
  261.  
  262.    Return 0 if cannot get enough memory to hold the pointer
  263.    and the names.
  264.  
  265.    Return -1 if cannot access directory DIR.
  266.    Look in errno for more information.  */
  267.  
  268. char **
  269. glob_vector (char *pat, char *dir)
  270. {
  271.   struct globval
  272.     {
  273.       struct globval *next;
  274.       char *name;
  275.     };
  276.  
  277.   DIR *d;
  278.   register struct dirent *dp;
  279.   struct globval *lastlink;
  280.   register struct globval *nextlink;
  281.   register char *nextname;
  282.   unsigned int count;
  283.   int lose;
  284.   register char **name_vector = NULL;
  285.   register unsigned int i;
  286. #if defined (OPENDIR_NOT_ROBUST)
  287.   struct stat finfo;
  288.  
  289.   if (stat (dir, &finfo) < 0)
  290.     return ((char **)-1);
  291.  
  292.   if (!S_ISDIR (finfo.st_mode))
  293.     return ((char **)-1);
  294. #endif /* OPENDIR_NOT_ROBUST */
  295.  
  296.   d = opendir (dir);
  297.   if (d == NULL)
  298.     return (char **) -1;
  299.  
  300.   lastlink = 0;
  301.   count = 0;
  302.   lose = 0;
  303.  
  304.   /* Scan the directory, finding all names that match.
  305.      For each name that matches, allocate a struct globval
  306.      on the stack and store the name in it.
  307.      Chain those structs together; lastlink is the front of the chain.  */
  308.   while (1)
  309.     {
  310.       dp = readdir (d);
  311.       if (dp == NULL)
  312.     break;
  313.  
  314.       /* If this directory entry is not to be used, try again. */
  315.       if (!REAL_DIR_ENTRY (dp))
  316.     continue;
  317.  
  318.       /* If a dot must be explicity matched, check to see if they do. */
  319.       if (noglob_dot_filenames && dp->d_name[0] == '.' && pat[0] != '.')
  320.     continue;
  321.  
  322.       if (glob_match (pat, dp->d_name, noglob_dot_filenames))
  323.     {
  324.           int len = NAMLEN(dp);
  325.       nextlink = (struct globval *) alloca (sizeof (struct globval));
  326.       nextlink->next = lastlink;
  327.       nextname = (char *) malloc (len + 1);
  328.       if (nextname == NULL)
  329.         {
  330.           lose = 1;
  331.           break;
  332.         }
  333.       lastlink = nextlink;
  334.       nextlink->name = nextname;
  335.       memcpy (nextname, dp->d_name, len);
  336.       nextname[len] = '\0';
  337.       ++count;
  338.     }
  339.     }
  340.   (void) closedir (d);
  341.  
  342.   if (!lose)
  343.     {
  344.       name_vector = (char **) malloc ((count + 1) * sizeof (char *));
  345.       lose |= name_vector == NULL;
  346.     }
  347.  
  348.   /* Have we run out of memory?     */
  349.   if (lose)
  350.     {
  351.       /* Here free the strings we have got.  */
  352.       while (lastlink)
  353.     {
  354.       free (lastlink->name);
  355.       lastlink = lastlink->next;
  356.     }
  357.       return NULL;
  358.     }
  359.  
  360.   /* Copy the name pointers from the linked list into the vector.  */
  361.   for (i = 0; i < count; ++i)
  362.     {
  363.       name_vector[i] = lastlink->name;
  364.       lastlink = lastlink->next;
  365.     }
  366.  
  367.   name_vector[count] = NULL;
  368.   return name_vector;
  369. }
  370.  
  371. /* Return a new array which is the concatenation
  372.    of each string in ARRAY to DIR. */
  373.  
  374. static char **
  375. glob_dir_to_array (char *dir, char **array)
  376. {
  377.   register unsigned int i, l;
  378.   int add_slash;
  379.   char **result;
  380.  
  381.   l = strlen (dir);
  382.   if (l == 0)
  383.     return array;
  384.  
  385.   add_slash = dir[l - 1] != '/';
  386.  
  387.   i = 0;
  388.   while (array[i] != NULL)
  389.     ++i;
  390.  
  391.   result = (char **) malloc ((i + 1) * sizeof (char *));
  392.   if (result == NULL)
  393.     return NULL;
  394.  
  395.   for (i = 0; array[i] != NULL; i++)
  396.     {
  397.       result[i] = (char *) malloc (l + (add_slash ? 1 : 0)
  398.                    + strlen (array[i]) + 1);
  399.       if (result[i] == NULL)
  400.     return NULL;
  401.       sprintf (result[i], "%s%s%s", dir, add_slash ? "/" : "", array[i]);
  402.     }
  403.   result[i] = NULL;
  404.  
  405.   /* Free the input array.  */
  406.   for (i = 0; array[i] != NULL; i++)
  407.     free (array[i]);
  408.   free ((char *) array);
  409.  
  410.   return result;
  411. }
  412.  
  413. /* Do globbing on PATHNAME.  Return an array of pathnames that match,
  414.    marking the end of the array with a null-pointer as an element.
  415.    If no pathnames match, then the array is empty (first element is null).
  416.    If there isn't enough memory, then return NULL.
  417.    If a file system error occurs, return -1; `errno' has the error code.  */
  418. char **
  419. glob_filename (char *pathname)
  420. {
  421.   char **result;
  422.   unsigned int result_size;
  423.   char *directory_name, *filename;
  424.   unsigned int directory_len;
  425.  
  426.   result = (char **) malloc (sizeof (char *));
  427.   result_size = 1;
  428.   if (result == NULL)
  429.     return NULL;
  430.  
  431.   result[0] = NULL;
  432.  
  433.   /* Find the filename.  */
  434.   filename = strrchr (pathname, '/');
  435.   if (filename == NULL)
  436.     {
  437.       filename = pathname;
  438.       directory_name = "";
  439.       directory_len = 0;
  440.     }
  441.   else
  442.     {
  443.       directory_len = (filename - pathname) + 1;
  444.       directory_name = (char *) alloca (directory_len + 1);
  445.  
  446.       memcpy (directory_name, pathname, directory_len);
  447.       directory_name[directory_len] = '\0';
  448.       ++filename;
  449.     }
  450.  
  451.   /* If directory_name contains globbing characters, then we
  452.      have to expand the previous levels.  Just recurse. */
  453.   if (glob_pattern_p (directory_name))
  454.     {
  455.       char **directories;
  456.       register unsigned int i;
  457.  
  458.       if (directory_name[directory_len - 1] == '/')
  459.     directory_name[directory_len - 1] = '\0';
  460.  
  461.       directories = glob_filename (directory_name);
  462.  
  463.       if (directories == NULL)
  464.     goto memory_error;
  465.       else if (directories == (char **)-1)
  466.     return (char **) -1;
  467.       else if (*directories == NULL)
  468.     {
  469.       free ((char *) directories);
  470.       return (char **) -1;
  471.     }
  472.  
  473.       /* We have successfully globbed the preceding directory name.
  474.      For each name in DIRECTORIES, call glob_vector on it and
  475.      FILENAME.  Concatenate the results together.  */
  476.       for (i = 0; directories[i] != NULL; ++i)
  477.     {
  478.       char **temp_results = glob_vector (filename, directories[i]);
  479.  
  480.       /* Handle error cases. */
  481.       if (temp_results == NULL)
  482.         goto memory_error;
  483.       else if (temp_results == (char **)-1)
  484.         /* This filename is probably not a directory.  Ignore it.  */
  485.         ;
  486.       else
  487.         {
  488.           char **array = glob_dir_to_array (directories[i], temp_results);
  489.           register unsigned int l;
  490.  
  491.           l = 0;
  492.           while (array[l] != NULL)
  493.         ++l;
  494.  
  495.           result =
  496.         (char **)realloc ((char *)result, 
  497.                   (result_size + l) * sizeof (char *));
  498.  
  499.           if (result == NULL)
  500.         goto memory_error;
  501.  
  502.           for (l = 0; array[l] != NULL; ++l)
  503.         result[result_size++ - 1] = array[l];
  504.  
  505.           result[result_size - 1] = NULL;
  506.  
  507.           /* Note that the elements of ARRAY are not freed.  */
  508.           free ((char *) array);
  509.         }
  510.     }
  511.       /* Free the directories.  */
  512.       for (i = 0; directories[i]; i++)
  513.     free (directories[i]);
  514.  
  515.       free ((char *) directories);
  516.  
  517.       return result;
  518.     }
  519.  
  520.   /* If there is only a directory name, return it. */
  521.   if (*filename == '\0')
  522.     {
  523.       result = (char **) realloc ((char *) result, 2 * sizeof (char *));
  524.       if (result == NULL)
  525.     return NULL;
  526.       result[0] = (char *) malloc (directory_len + 1);
  527.       if (result[0] == NULL)
  528.     goto memory_error;
  529.       memcpy (result[0], directory_name, directory_len + 1);
  530.       result[1] = NULL;
  531.       return result;
  532.     }
  533.   else
  534.     {
  535.       /* Otherwise, just return what glob_vector
  536.      returns appended to the directory name. */
  537.       char **temp_results = glob_vector (filename,
  538.                      (directory_len == 0
  539.                       ? "." : directory_name));
  540.  
  541.       if (temp_results == NULL || temp_results == (char **)-1)
  542.     return temp_results;
  543.  
  544.       return (glob_dir_to_array (directory_name, temp_results));
  545.     }
  546.  
  547.   /* We get to memory error if the program has run out of memory, or
  548.      if this is the shell, and we have been interrupted. */
  549.  memory_error:
  550.   if (result != NULL)
  551.     {
  552.       register unsigned int i;
  553.       for (i = 0; result[i] != NULL; ++i)
  554.     free (result[i]);
  555.       free ((char *) result);
  556.     }
  557.   return NULL;
  558. }
  559.  
  560. #ifdef TEST
  561.  
  562. main (int argc, char *argv[])
  563. {
  564.   unsigned int i;
  565.  
  566.   for (i = 1; i < argc; ++i)
  567.     {
  568.       char **value = glob_filename (argv[i]);
  569.       if (value == NULL)
  570.     puts ("Out of memory.");
  571.       else if ((int) value == -1)
  572.     perror (argv[i]);
  573.       else
  574.     for (i = 0; value[i] != NULL; i++)
  575.       puts (value[i]);
  576.     }
  577.  
  578.   exit (0);
  579. }
  580. #endif    /* TEST.  */
  581.