WebSVN – DevTools – Diff – /core_devl/trunk/UTILS/SH/GLOB.C

  * Revision 2.0  1992/04/13  17:39:09  Ian_Stewartson
  * MS-Shell 2.0 Baseline release
+ *
  */
-#include <sys/types.h>			/* MS-DOS type definitions      */
+#include <sys/types.h>                  /* MS-DOS type definitions      */
-#include <sys/stat.h>			/* File status definitions	*/
+#include <sys/stat.h>                   /* File status definitions      */
-#include <stdio.h>			/* Standard I/O delarations     */
+#include <stdio.h>                      /* Standard I/O delarations     */
-#include <stdlib.h>			/* Standard library functions   */
+#include <stdlib.h>                     /* Standard library functions   */
-#include <string.h>			/* String library functions     */
+#include <string.h>                     /* String library functions     */
-#include <limits.h>			/* String library functions     */
+#include <limits.h>                     /* String library functions     */
-#include <dirent.h>			/* Direction I/O functions	*/
+#include <dirent.h>                     /* Direction I/O functions      */
-#include <ctype.h>			/* Character types function	*/
+#include <ctype.h>                      /* Character types function     */
-#include <unistd.h>			/* Other functions		*/
+#include <unistd.h>                     /* Other functions              */
 #ifdef __TURBOC__
-#  include <alloc.h>			/* Malloc functions		*/
+#  include <alloc.h>                    /* Malloc functions             */
-#  include <dir.h>			/* Dos directory functions	*/
+#  include <dir.h>                      /* Dos directory functions      */
 #else
-#  include <malloc.h>			/* Malloc functions		*/
+#  include <malloc.h>                   /* Malloc functions             */
 #endif
 #include <glob.h>
 #if defined (MSDOS) || defined (__OS2__) || defined (__TURBOC__) || defined (WIN32)
 #  if defined (OS2) || defined (__OS2__)
 #    define INCL_DOSDEVICES
 #    define INCL_DOSMISC
-#    include <os2.h>			/* OS2 functions declarations       */
+#    include <os2.h>                    /* OS2 functions declarations       */
 #    if defined (__OS2__)
-#      define DISABLE_HARD_ERRORS	DosError (FERR_DISABLEHARDERR)
+#      define DISABLE_HARD_ERRORS       DosError (FERR_DISABLEHARDERR)
-#      define ENABLE_HARD_ERRORS	DosError (FERR_ENABLEHARDERR)
+#      define ENABLE_HARD_ERRORS        DosError (FERR_ENABLEHARDERR)
 #    else
-#      define DISABLE_HARD_ERRORS	DosError (HARDERROR_DISABLE)
+#      define DISABLE_HARD_ERRORS       DosError (HARDERROR_DISABLE)
-#      define ENABLE_HARD_ERRORS	DosError (HARDERROR_ENABLE)
+#      define ENABLE_HARD_ERRORS        DosError (HARDERROR_ENABLE)
 #    endif
 #  elif defined (WIN32)
 #  include <windows.h>
-#  define DISABLE_HARD_ERRORS	SetErrorMode (0)
+#  define DISABLE_HARD_ERRORS   SetErrorMode (0)
-#  define ENABLE_HARD_ERRORS	SetErrorMode (SEM_FAILCRITICALERRORS | \
+#  define ENABLE_HARD_ERRORS    SetErrorMode (SEM_FAILCRITICALERRORS | \
-					      SEM_NOOPENFILEERRORBOX);
+                                              SEM_NOOPENFILEERRORBOX);
 #  else
-#    include <bios.h>			/* DOS BIOS functions		*/
+#    include <bios.h>                   /* DOS BIOS functions           */
-#    include <dos.h>			/* DOS functions		*/
+#    include <dos.h>                    /* DOS functions                */
 #    define DISABLE_HARD_ERRORS
 #    define ENABLE_HARD_ERRORS
 #  endif
 #endif
 /*
  * OS/2 2.x has these missing
  */
 #ifndef S_IFMT
-#  define	S_IFMT	0xf000	/* type of file				*/
+#  define       S_IFMT  0xf000  /* type of file                         */
 #endif
 #ifndef S_ISDIR
-#  define S_ISDIR(m)	((((m) & S_IFMT) == S_IFDIR))
+#  define S_ISDIR(m)    ((((m) & S_IFMT) == S_IFDIR))
 #endif
 /*
  * Functions
  */
-static int	_GP_SortCompare		_PROTO ((char **, char **));
+static int      _GP_SortCompare         _PROTO ((char **, char **));
-static int	_GP_ExpandField		_PROTO ((char *, char *, glob_t *));
+static int      _GP_ExpandField         _PROTO ((char *, char *, glob_t *));
-static int	_GP_ExpandMetaCharacters _PROTO ((char *, glob_t *));
+static int      _GP_ExpandMetaCharacters _PROTO ((char *, glob_t *));
-static int	_GP_AddArgument		_PROTO ((char *, glob_t *));
+static int      _GP_AddArgument         _PROTO ((char *, glob_t *));
-static bool	_GP_MatchPattern	_PROTO ((char *, char *));
+static bool     _GP_MatchPattern        _PROTO ((char *, char *));
-static bool	_GP_access		_PROTO ((char *, int));
+static bool     _GP_access              _PROTO ((char *, int));
-static bool	_GP_stat		_PROTO ((char *, struct stat *));
+static bool     _GP_stat                _PROTO ((char *, struct stat *));
-static char	*_GP_MetaChars = "?*[\\";
+static char     *_GP_MetaChars = "?*[\\";
-static char	*_GP_NullString = "";
+static char     *_GP_NullString = "";
 #if defined (MSDOS) || defined (__OS2__) || defined (__TURBOC__) || defined (WIN32)
-static	int	_GP_GetNumberofFloppyDrives (void);
+static  int     _GP_GetNumberofFloppyDrives (void);
 #  if defined (OS2) || defined (__OS2__) || defined (__TURBOC__) || defined (WIN32)
-static void	 _dos_setdrive (unsigned int, unsigned int *);
+static void      _dos_setdrive (unsigned int, unsigned int *);
-static void	 _dos_getdrive (unsigned int *);
+static void      _dos_getdrive (unsigned int *);
 #  endif
-static char	*_GP_CheckForMultipleDrives	_PROTO ((char *));
+static char     *_GP_CheckForMultipleDrives     _PROTO ((char *));
 #endif
 /*
  * There appears to be no alloca in TurboC
  */
 #if defined(__TURBOC__) || defined(WIN32)
-#  define alloca(x)		malloc (x)
+#  define alloca(x)             malloc (x)
-#  define alloca_free(x)	free (x)
+#  define alloca_free(x)        free (x)
 #else
 #  define alloca_free(x)
 #endif
 /*
  * Free up space
  */
-void	globfree (gp)
+void    globfree (gp)
-glob_t	*gp;
+glob_t  *gp;
+{
-    int		i = (gp->gl_flags & GLOB_DOOFFS) ? gp->gl_offs : 0;
+    int         i = (gp->gl_flags & GLOB_DOOFFS) ? gp->gl_offs : 0;
     while (i < gp->gl_pathc)
-	free (gp->gl_pathv[i++]);
+        free (gp->gl_pathv[i++]);
     free (gp->gl_pathv);
+}
 /* Main search function */
-int	glob (Pattern, flags, ErrorFunction, gp)
+int     glob (Pattern, flags, ErrorFunction, gp)
-char	*Pattern;
+char    *Pattern;
-int	flags;
+int     flags;
-int	(*ErrorFunction) _PROTO ((char *, int));
+int     (*ErrorFunction) _PROTO ((char *, int));
-glob_t	*gp;
+glob_t  *gp;
 {
-    int		ReturnValue;
+    int         ReturnValue;
-    char	*PatternCopy;
+    char        *PatternCopy;
-    char	*cp;
+    char        *cp;
 /* If no append mode - initialise */
     if (!(flags & GLOB_APPEND))
+    {
-	gp->gl_pathc = 0;
+        gp->gl_pathc = 0;
-	gp->gl_pathv = (char **)NULL;
+        gp->gl_pathv = (char **)NULL;
+    }
     gp->gl_flags = flags;
     gp->gl_ef = ErrorFunction;
     if ((PatternCopy = alloca (strlen (Pattern) + 1)) == (char *)NULL)
-	return GLOB_NOSPACE;
+        return GLOB_NOSPACE;
 /* Expand and kill environment */
     if (ReturnValue = _GP_ExpandMetaCharacters (strcpy (PatternCopy, Pattern),
-						gp))
+                                                gp))
+    {
-	alloca_free (PatternCopy);
+        alloca_free (PatternCopy);
-	return ReturnValue;
+        return ReturnValue;
+    }
 /* Check for no finds.  If add value, strip out \ from the string */
     if ((gp->gl_pathc == 0) && (flags & GLOB_NOCHECK))
+    {
-	cp = strcpy (PatternCopy, Pattern);
+        cp = strcpy (PatternCopy, Pattern);
-	while ((cp = strpbrk (cp, "?*[")) != (char *)NULL)
+        while ((cp = strpbrk (cp, "?*[")) != (char *)NULL)
-	{
+        {
-	    if ((cp == PatternCopy) || (*(cp - 1) != '\\'))
+            if ((cp == PatternCopy) || (*(cp - 1) != '\\'))
-		cp++;
+                cp++;
-	    else
+            else
-		memmove (cp - 1, cp, strlen (cp) + 1);
+                memmove (cp - 1, cp, strlen (cp) + 1);
-	}
+        }
-	if (ReturnValue = _GP_AddArgument (PatternCopy, gp))
+        if (ReturnValue = _GP_AddArgument (PatternCopy, gp))
-	{
+        {
-	    alloca_free (PatternCopy);
+            alloca_free (PatternCopy);
-	    return ReturnValue;
+            return ReturnValue;
-	}
+        }
+    }
 /* Terminate string */
     if ((gp->gl_pathc != 0) &&
-	(ReturnValue = _GP_AddArgument ((char *)NULL, gp)))
+        (ReturnValue = _GP_AddArgument ((char *)NULL, gp)))
+    {
-	alloca_free (PatternCopy);
+        alloca_free (PatternCopy);
-	return ReturnValue;
+        return ReturnValue;
+    }
 /* Get the sort length */
     ReturnValue = (gp->gl_flags & GLOB_DOOFFS) ? gp->gl_offs : 0;
     if ((!(flags & GLOB_NOSORT)) && (gp->gl_pathc > 1))
-	qsort (&gp->gl_pathv[ReturnValue], gp->gl_pathc, sizeof (char *),
+        qsort (&gp->gl_pathv[ReturnValue], gp->gl_pathc, sizeof (char *),
-	       (int (*) (const void *, const void *)) _GP_SortCompare);
+               (int (*) (const void *, const void *)) _GP_SortCompare);
     alloca_free (PatternCopy);
     return 0;
+}
 /* Compare function for sort */
-static int	_GP_SortCompare (a1, a2)
+static int      _GP_SortCompare (a1, a2)
-char		**a1, **a2;
+char            **a1, **a2;
+{
     return strcmp (*a1, *a2);
+}
 /* Expand a field if it has metacharacters in it */
-static int	_GP_ExpandField (CurrentDirectoryPattern, AppendString, gp)
+static int      _GP_ExpandField (CurrentDirectoryPattern, AppendString, gp)
-char		*CurrentDirectoryPattern;	/* Prefix field		*/
+char            *CurrentDirectoryPattern;       /* Prefix field         */
-char		*AppendString;			/* Postfix field    	*/
+char            *AppendString;                  /* Postfix field        */
-glob_t		*gp;
+glob_t          *gp;
 {
-    int 		i;
+    int                 i;
-    int			ReturnValue = 0;	/* Return Value		*/
+    int                 ReturnValue = 0;        /* Return Value         */
-    char		*FullFileName;		/* Search file name	*/
+    char                *FullFileName;          /* Search file name     */
-    char		*FileNameStart;
+    char                *FileNameStart;
-    char		*MatchString;		/* Match string		*/
+    char                *MatchString;           /* Match string         */
-    DIR			*DirHandler;
+    DIR                 *DirHandler;
-    struct dirent	*CurrentDirectoryEntry;
+    struct dirent       *CurrentDirectoryEntry;
 #if defined (MSDOS) || defined (__OS2__) || defined (__TURBOC__) || defined (WIN32)
-    unsigned int	CurrentDrive;		/* Current drive	*/
+    unsigned int        CurrentDrive;           /* Current drive        */
-    unsigned int	MaxDrives;		/* Max drive		*/
+    unsigned int        MaxDrives;              /* Max drive            */
-    unsigned int	SelectedDrive;		/* Selected drive	*/
+    unsigned int        SelectedDrive;          /* Selected drive       */
-    unsigned int	x_drive, y_drive;	/* Dummies		*/
+    unsigned int        x_drive, y_drive;       /* Dummies              */
-    char		*DriveCharacter;	/* Multi-drive flag	*/
+    char                *DriveCharacter;        /* Multi-drive flag     */
-    char		SDriveString[2];
+    char                SDriveString[2];
 /* Convert file name to lower case */
 #  if defined (OS2) || defined (__OS2__) || (WIN32)
     if (!IsHPFSFileSystem (CurrentDirectoryPattern))
-	strlwr (CurrentDirectoryPattern);
+        strlwr (CurrentDirectoryPattern);
 #  else
     strlwr (CurrentDirectoryPattern);
 #  endif
 /* Search all drives ? */
     if ((DriveCharacter = _GP_CheckForMultipleDrives (CurrentDirectoryPattern))
-		!= (char *)NULL)
+                != (char *)NULL)
+    {
-	_dos_getdrive (&CurrentDrive);	/* Get number of drives		*/
+        _dos_getdrive (&CurrentDrive);  /* Get number of drives         */
-	_dos_setdrive (CurrentDrive, &MaxDrives);
+        _dos_setdrive (CurrentDrive, &MaxDrives);
-	SDriveString[1] = 0;
+        SDriveString[1] = 0;
-	for (SelectedDrive = 1; SelectedDrive <= MaxDrives; ++SelectedDrive)
+        for (SelectedDrive = 1; SelectedDrive <= MaxDrives; ++SelectedDrive)
-	{
+        {
-	    _dos_setdrive (SelectedDrive, &x_drive);
+            _dos_setdrive (SelectedDrive, &x_drive);
-	    _dos_getdrive (&y_drive);
+            _dos_getdrive (&y_drive);
-	    _dos_setdrive (CurrentDrive, &x_drive);
+            _dos_setdrive (CurrentDrive, &x_drive);
 /* Check to see if the second diskette drive is really there */
-	    if ((_GP_GetNumberofFloppyDrives () < 2) && (SelectedDrive == 2))
+            if ((_GP_GetNumberofFloppyDrives () < 2) && (SelectedDrive == 2))
-		continue;
+                continue;
 /* If the drive exists and is in our list - process it */
-	    *DriveCharacter = 0;
+            *DriveCharacter = 0;
-	    *SDriveString = (char)(SelectedDrive + 'a' - 1);
+            *SDriveString = (char)(SelectedDrive + 'a' - 1);
-	    strlwr (CurrentDirectoryPattern);
+            strlwr (CurrentDirectoryPattern);
-	    if ((y_drive == SelectedDrive) &&
-		_GP_MatchPattern (SDriveString, CurrentDirectoryPattern))
-	    {
-		if ((FullFileName = alloca (strlen (DriveCharacter) + 3))
-				== (char *)NULL)
-		    return GLOB_NOSPACE;
-		*DriveCharacter = ':';
-		*FullFileName = *SDriveString;
-		strcpy (FullFileName + 1, DriveCharacter);
-		i = _GP_ExpandField (FullFileName, AppendString, gp);
-		alloca_free (FullFileName);
-		if (i)
-		    return i;
-	    }
+            if ((y_drive == SelectedDrive) &&
+                _GP_MatchPattern (SDriveString, CurrentDirectoryPattern))
+            {
+                if ((FullFileName = alloca (strlen (DriveCharacter) + 3))
+                                == (char *)NULL)
+                    return GLOB_NOSPACE;
-	    *DriveCharacter = ':';
+                *DriveCharacter = ':';
+                *FullFileName = *SDriveString;
+                strcpy (FullFileName + 1, DriveCharacter);
+                i = _GP_ExpandField (FullFileName, AppendString, gp);
+                alloca_free (FullFileName);
-	}
+                if (i)
+                    return i;
+            }
+            *DriveCharacter = ':';
+        }
-	return 0;
+        return 0;
+    }
 #endif
 /* Get the path length */
     MatchString = strrchr (CurrentDirectoryPattern, '/');
 #if defined (MSDOS) || defined (__OS2__) || defined (__TURBOC__) || defined (WIN32)
     if ((MatchString == (char *)NULL) &&
-	(*(CurrentDirectoryPattern + 1) == ':'))
+        (*(CurrentDirectoryPattern + 1) == ':'))
-	MatchString = CurrentDirectoryPattern + 1;
+        MatchString = CurrentDirectoryPattern + 1;
 #endif
 /* Set up file name for search */
     if ((MatchString == (char *)NULL) || (*MatchString == ':'))
+    {
-	if ((FullFileName = alloca (NAME_MAX + 7 +
+        if ((FullFileName = alloca (NAME_MAX + 7 +
-				    strlen (AppendString))) == (char *)NULL)
+                                    strlen (AppendString))) == (char *)NULL)
-	    return GLOB_NOSPACE;
+            return GLOB_NOSPACE;
-	if (MatchString != (char *)NULL)
+        if (MatchString != (char *)NULL)
-	    *(strcpy (FullFileName, "x:.")) = *CurrentDirectoryPattern;
+            *(strcpy (FullFileName, "x:.")) = *CurrentDirectoryPattern;
-	else
+        else
-	    strcpy (FullFileName, ".");
+            strcpy (FullFileName, ".");
-	FileNameStart = FullFileName +
+        FileNameStart = FullFileName +
-			(int)((MatchString != (char *)NULL) ? 2 : 0);
+                        (int)((MatchString != (char *)NULL) ? 2 : 0);
+    }
 /* Case of /<directory>/... */
     else if ((FullFileName = alloca (NAME_MAX + 4 + strlen (AppendString) +
-			    (i = (int)(MatchString - CurrentDirectoryPattern))))
+                            (i = (int)(MatchString - CurrentDirectoryPattern))))
-			== (char *)NULL)
+                        == (char *)NULL)
-	    return GLOB_NOSPACE;
+            return GLOB_NOSPACE;
     else
+    {
-	strncpy (FullFileName, CurrentDirectoryPattern, i);
+        strncpy (FullFileName, CurrentDirectoryPattern, i);
-	*((FileNameStart = FullFileName + i)) = 0;
+        *((FileNameStart = FullFileName + i)) = 0;
-	strcpy (FileNameStart++, "/");
+        strcpy (FileNameStart++, "/");
+    }
     MatchString = (MatchString == (char *)NULL) ? CurrentDirectoryPattern
-						: MatchString + 1;
+                                                : MatchString + 1;
 /* Search for file names */
     if ((DirHandler = opendir (FullFileName)) == (DIR *)NULL)
+    {
-	i = 0;
+        i = 0;
-	if (((gp->gl_ef != NULL) && (*gp->gl_ef)(FullFileName, errno)) ||
+        if (((gp->gl_ef != NULL) && (*gp->gl_ef)(FullFileName, errno)) ||
-	    (gp->gl_flags & GLOB_ERR))
+            (gp->gl_flags & GLOB_ERR))
-	    i = GLOB_ABEND;
+            i = GLOB_ABEND;
-	alloca_free (FullFileName);
+        alloca_free (FullFileName);
-	return i;
+        return i;
+    }
 /* Are there any matches */
     while ((CurrentDirectoryEntry = readdir (DirHandler)) !=
-	    (struct dirent *)NULL)
+            (struct dirent *)NULL)
+    {
-	if ((*CurrentDirectoryEntry->d_name == '.') && (*MatchString != '.'))
+        if ((*CurrentDirectoryEntry->d_name == '.') && (*MatchString != '.'))
-	    continue;
+            continue;
 /* Check for match */
-	if (_GP_MatchPattern (CurrentDirectoryEntry->d_name, MatchString))
+        if (_GP_MatchPattern (CurrentDirectoryEntry->d_name, MatchString))
-	{
+        {
-	    strcpy (FileNameStart, CurrentDirectoryEntry->d_name);
+            strcpy (FileNameStart, CurrentDirectoryEntry->d_name);
 /* If the postfix is not null, this must be a directory */
-	    if (strlen (AppendString))
+            if (strlen (AppendString))
-	    {
+            {
-		struct stat		statb;
+                struct stat             statb;
-		char			*p;
+                char                    *p;
 /* If not a directory - go to the next file */
-		if (!_GP_stat (FullFileName, &statb) ||
+                if (!_GP_stat (FullFileName, &statb) ||
-		    !S_ISDIR (statb.st_mode & S_IFMT))
+                    !S_ISDIR (statb.st_mode & S_IFMT))
-		    continue;
+                    continue;
 /* Are there any metacharacters in the postfix? */
-		if ((p = strpbrk (AppendString, _GP_MetaChars)) == (char *)NULL)
+                if ((p = strpbrk (AppendString, _GP_MetaChars)) == (char *)NULL)
-		{
+                {
 /* No - build the file name and check it exists */
-		    strcat (strcat (FileNameStart, "/"), AppendString);
+                    strcat (strcat (FileNameStart, "/"), AppendString);
-		    if (_GP_access (FullFileName, F_OK) &&
+                    if (_GP_access (FullFileName, F_OK) &&
-			(ReturnValue = _GP_AddArgument (FullFileName, gp)))
+                        (ReturnValue = _GP_AddArgument (FullFileName, gp)))
-			break;
+                        break;
-		}
+                }
 /* Yes - build the filename upto the start of the meta characters */
-		else
+                else
-		{
+                {
-		    if ((p = strchr (p, '/')) != (char *)NULL)
+                    if ((p = strchr (p, '/')) != (char *)NULL)
-			*(p++) = 0;
+                        *(p++) = 0;
-		    else
+                    else
-			p = _GP_NullString;
+                        p = _GP_NullString;
 /* Build the new directory name and check it out */
-		    strcat (strcat (FileNameStart, "/"), AppendString);
+                    strcat (strcat (FileNameStart, "/"), AppendString);
-		    ReturnValue = _GP_ExpandField (FullFileName, p, gp);
+                    ReturnValue = _GP_ExpandField (FullFileName, p, gp);
-		    if (p != _GP_NullString)
+                    if (p != _GP_NullString)
-		       *(--p) = '/';
+                       *(--p) = '/';
 /* Check for errors */
-		    if (ReturnValue)
+                    if (ReturnValue)
-			break;
+                        break;
-		}
+                }
-	    }
+            }
 /* Process this file.  If error - terminate */
-	    else if (_GP_access (FullFileName, F_OK) &&
+            else if (_GP_access (FullFileName, F_OK) &&
-		     (ReturnValue = _GP_AddArgument (FullFileName, gp)))
+                     (ReturnValue = _GP_AddArgument (FullFileName, gp)))
-		break;
+                break;
-	}
+        }
+    }
     closedir (DirHandler);
     alloca_free (FullFileName);
     return ReturnValue;
 /* Find the location of meta-characters.  If no meta, add the argument and
  * return.  If meta characters, expand directory containing meta characters.
  */
-static int	_GP_ExpandMetaCharacters (file, gp)
+static int      _GP_ExpandMetaCharacters (file, gp)
-char		*file;
+char            *file;
-glob_t		*gp;
+glob_t          *gp;
+{
-    char	*p;
+    char        *p;
-    int		ReturnValue;
+    int         ReturnValue;
 /* No metas - add to string */
     if ((p = strpbrk (file, _GP_MetaChars)) == (char *)NULL)
+    {
-	if (!_GP_access (file, F_OK))
+        if (!_GP_access (file, F_OK))
-	    return 0;
+            return 0;
-	return _GP_AddArgument (file, gp);
+        return _GP_AddArgument (file, gp);
+    }
 /* Ok - metas, find the end of the start of the directory */
     else if ((p = strchr (p, '/')) != (char *)NULL)
-	*(p++) = 0;
+        *(p++) = 0;
     else
-	p = _GP_NullString;
+        p = _GP_NullString;
 /* Continue recusive match */
     ReturnValue = _GP_ExpandField (file, p, gp);
 /* Add an argument to the stack - file is assumed to be a array big enough
  * for the file name + 2
  */
-static int	_GP_AddArgument (file, gp)
+static int      _GP_AddArgument (file, gp)
-char		*file;
+char            *file;
-glob_t		*gp;
+glob_t          *gp;
 {
-    int		Offset;
+    int         Offset;
-    char	**p1;
+    char        **p1;
-    struct stat	FileStatus;
+    struct stat FileStatus;
     Offset = gp->gl_pathc + ((gp->gl_flags & GLOB_DOOFFS) ? gp->gl_offs : 0);
     p1  = gp->gl_pathv;
 /* Malloc space if necessary */
     if (gp->gl_pathc == 0)
-	p1 = (char **)calloc (sizeof (char *), (50 + Offset));
+        p1 = (char **)calloc (sizeof (char *), (50 + Offset));
     else if ((gp->gl_pathc % 50) == 0)
-	p1 = (char **)realloc (p1, (Offset + 50) * (sizeof (char *)));
+        p1 = (char **)localRealloc (p1, (Offset + 50) * (sizeof (char *)));
     if (p1 == (char **)NULL)
-	return GLOB_NOSPACE;
+        return GLOB_NOSPACE;
 /* OK got space */
     gp->gl_pathv = p1;
 /* End of list ? */
     if (file == (char *)NULL)
-	p1[Offset] = (char *)NULL;
+        p1[Offset] = (char *)NULL;
     else
+    {
-	if ((gp->gl_flags & GLOB_MARK) && (file[strlen (file) - 1] != '/') &&
+        if ((gp->gl_flags & GLOB_MARK) && (file[strlen (file) - 1] != '/') &&
-	    _GP_stat (file, &FileStatus) && (S_ISDIR (FileStatus.st_mode)))
+            _GP_stat (file, &FileStatus) && (S_ISDIR (FileStatus.st_mode)))
-	    strcat (file, "/");
+            strcat (file, "/");
-	if ((p1[Offset] = strdup (file)) == (char *)NULL)
+        if ((p1[Offset] = strdup (file)) == (char *)NULL)
-	    return GLOB_NOSPACE;
+            return GLOB_NOSPACE;
-	strcpy (p1[Offset], file);
+        strcpy (p1[Offset], file);
 /* Increment counter */
-	++(gp->gl_pathc);
+        ++(gp->gl_pathc);
+    }
     return 0;
+}
 /* Check for multi_drive prefix */
 #if defined (MSDOS) || defined (__OS2__) || defined (__TURBOC__) || defined (WIN32)
-static char	*_GP_CheckForMultipleDrives (prefix)
+static char     *_GP_CheckForMultipleDrives (prefix)
-char		*prefix;
+char            *prefix;
+{
     if (strlen (prefix) < 2)
-	return (char *)NULL;
+        return (char *)NULL;
     if (((*prefix == '*') || (*prefix == '?')) && (prefix[1] == ':'))
-	return prefix + 1;
+        return prefix + 1;
     if (*prefix != '[')
-	return (char *)NULL;
+        return (char *)NULL;
     while (*prefix && (*prefix != ']'))
+    {
-	if ((*prefix == '\\') && (*(prefix + 1)))
+        if ((*prefix == '\\') && (*(prefix + 1)))
-	    ++prefix;
+            ++prefix;
-	++prefix;
+        ++prefix;
+    }
     return (*prefix && (*(prefix + 1) == ':')) ? prefix + 1 : (char *)NULL;
+}
 /*
  * Some Turboc Functions to emulate MSC functions
  */
 #  if defined (__TURBOC__)
-static void	 _dos_getdrive (cdp)
+static void      _dos_getdrive (cdp)
-unsigned int	*cdp;
+unsigned int    *cdp;
+{
     *cdp = (unsigned int)getdisk () + 1;
+}
-static void	 _dos_setdrive (cdr, ndp)
+static void      _dos_setdrive (cdr, ndp)
-unsigned int	cdr;
+unsigned int    cdr;
-unsigned int	*ndp;
+unsigned int    *ndp;
+{
    *ndp = (unsigned int)setdisk (cdr - 1);
+}
 #  endif
 /*
  * Some OS/2 functions to emulate the DOS functions
  */
 #  if defined (OS2) || defined (__OS2__)
-static void	 _dos_getdrive (cdp)
+static void      _dos_getdrive (cdp)
-unsigned int	*cdp;
+unsigned int    *cdp;
+{
-    USHORT	cdr;
+    USHORT      cdr;
-    ULONG	ndr;
+    ULONG       ndr;
     DosQCurDisk((PUSHORT)&cdr, (PULONG) &ndr);
     *cdp = (unsigned int)cdr;
+}
-static void	 _dos_setdrive (cdr, ndp)
+static void      _dos_setdrive (cdr, ndp)
-unsigned int	cdr;
+unsigned int    cdr;
-unsigned int	*ndp;
+unsigned int    *ndp;
 {
-    ULONG		ulDrives;
+    ULONG               ulDrives;
-    USHORT		usDisk;
+    USHORT              usDisk;
-    int			i;
+    int                 i;
     DosSelectDisk ((USHORT)cdr);
 /* Get the current disk and check that to see the number of drives */
     DosQCurDisk (&usDisk, &ulDrives);        /* gets current drive        */
     for (i = 25; (!(ulDrives & (1L << i))) && (i >= 0); --i)
-	continue;
+        continue;
     *ndp = i + 1;
+}
 #  elif defined (WIN32)
-static void	 _dos_getdrive (cdp)
+static void      _dos_getdrive (cdp)
-unsigned int	*cdp;
+unsigned int    *cdp;
+{
-    char	szCurDir [MAX_PATH];
+    char        szCurDir [MAX_PATH];
     GetCurrentDirectory (MAX_PATH, szCurDir);
     *cdp = (unsigned int)(szCurDir[0] - 'A' + 1);
+}
-static void	 _dos_setdrive (cdr, ndp)
+static void      _dos_setdrive (cdr, ndp)
-unsigned int	cdr;
+unsigned int    cdr;
-unsigned int	*ndp;
+unsigned int    *ndp;
 {
-    char		szNewDrive[3];
+    char                szNewDrive[3];
-    DWORD		dwLogicalDrives;
+    DWORD               dwLogicalDrives;
-    unsigned int	i;
+    unsigned int        i;
     szNewDrive[0] = cdr + 'A' - 1;
     szNewDrive[1] = ':';
     szNewDrive[2] = 0;
     *ndp = 0;
     if (!SetCurrentDirectory (szNewDrive))
-	return;
+        return;
     dwLogicalDrives = GetLogicalDrives ();
     for (i = 25; (!(dwLogicalDrives & (1L << i))) && i >= 0; --i)
-	continue;
+        continue;
     *ndp = i + 1;
+}
 #  endif
 /* Return the number of floppy disks */
 #  if defined (OS2) || defined (__OS2__)
-static	int	_GP_GetNumberofFloppyDrives ()
+static  int     _GP_GetNumberofFloppyDrives ()
+{
-    BYTE	nflop = 1;
+    BYTE        nflop = 1;
     DosDevConfig (&nflop, DEVINFO_FLOPPY, 0);
     return nflop;
+}
 #  elif defined (WIN32)
-static	int	_GP_GetNumberofFloppyDrives ()
+static  int     _GP_GetNumberofFloppyDrives ()
+{
-    char	szNewDrive[4];
+    char        szNewDrive[4];
-    DWORD	dwLogicalDrives = GetLogicalDrives();
+    DWORD       dwLogicalDrives = GetLogicalDrives();
-    int		LastTest = 0;
+    int         LastTest = 0;
-    int		i;
+    int         i;
     strcpy (szNewDrive, "x:\\");
 /* Look at each drive until we find a non-floppy which exists */
     for (i = 0; i < 25; i++)
+    {
-	if (dwLogicalDrives & (1L << i))
+        if (dwLogicalDrives & (1L << i))
-	{
+        {
-	    szNewDrive[0] = i + 'A';
+            szNewDrive[0] = i + 'A';
-	    if (GetDriveType (szNewDrive) != DRIVE_REMOVABLE)
+            if (GetDriveType (szNewDrive) != DRIVE_REMOVABLE)
-		break;
+                break;
-	    LastTest = i + 1;
+            LastTest = i + 1;
-	}
+        }
+    }
     return LastTest;
+}
 #  elif defined (__TURBOC__)
-static	int	_GP_GetNumberofFloppyDrives ()
+static  int     _GP_GetNumberofFloppyDrives ()
+{
     return ((biosequip () & 0x00c0) >> 6) + 1;
+}
 #  else
-static	int	_GP_GetNumberofFloppyDrives ()
+static  int     _GP_GetNumberofFloppyDrives ()
+{
     return ((_bios_equiplist () & 0x00c0) >> 6) + 1;
+}
 #  endif
 #endif
 /*
  * Pattern Matching function
  */
-static bool	_GP_MatchPattern (string, pattern)
+static bool     _GP_MatchPattern (string, pattern)
-char		*string;		/* String to match                  */
+char            *string;                /* String to match                  */
-char		*pattern;		/* Pattern to match against         */
+char            *pattern;               /* Pattern to match against         */
+{
-    register int	cur_s;		/* Current string character         */
+    register int        cur_s;          /* Current string character         */
-    register int	cur_p;		/* Current pattern character        */
+    register int        cur_p;          /* Current pattern character        */
 /* Match string */
     while (cur_p = *(pattern++))
+    {
-	cur_s = *(string++);		/* Load current string character    */
+        cur_s = *(string++);            /* Load current string character    */
-        switch (cur_p)			/* Switch on pattern character      */
+        switch (cur_p)                  /* Switch on pattern character      */
+        {
-            case '[':			/* Match class of characters        */
+            case '[':                   /* Match class of characters        */
+            {
                 while(1)
+                {
                     if (!(cur_p = *(pattern++)))
-			return 0;
+                        return 0;
                     if (cur_p == ']')
-			return FALSE;
+                        return FALSE;
                     if (cur_s != cur_p)
+                    {
                         if (*pattern == '-')
+                        {
+                {
                     if (*(pattern++) == ']')
                         break;
+                }
-		break;
+                break;
+            }
-            case '?':			/* Match any character              */
+            case '?':                   /* Match any character              */
+            {
                 if (!cur_s)
-		    return FALSE;
+                    return FALSE;
                 break;
+            }
-            case '*':			/* Match any number of any character*/
+            case '*':                   /* Match any number of any character*/
+            {
                 string--;
                 do
+                {
                     if (_GP_MatchPattern (string, pattern))
-			return TRUE;
+                        return TRUE;
+                }
                 while (*(string++));
-		return FALSE;
+                return FALSE;
+            }
-            case '\\':			/* Next character is non-meta       */
+            case '\\':                  /* Next character is non-meta       */
+            {
                 if (!(cur_p = *(pattern++)))
-		    return FALSE;
+                    return FALSE;
+            }
-            default:			/* Match against current pattern    */
+            default:                    /* Match against current pattern    */
+            {
                 if (cur_p != cur_s)
-		    return FALSE;
+                    return FALSE;
                 break;
+            }
+        }
+    }
  * Local Stat function to do some additional checks
  */
 static bool _GP_stat (char *FileName, struct stat *Status)
+{
-    int		rc;
+    int         rc;
     DISABLE_HARD_ERRORS;
     rc = stat (FileName, Status);
     ENABLE_HARD_ERRORS;
  * Local access function to do some additional checks
  */
 static bool _GP_access (char *FileName, int mode)
+{
-    int		rc;
+    int         rc;
     DISABLE_HARD_ERRORS;
     rc = access (FileName, mode);
     ENABLE_HARD_ERRORS;
  */
 #ifdef TEST
 int main (int argc, char **argv)
+{
-    int		i;
+    int         i;
     for (i = 0; i < argc; i++)
-	printf ("Arg %d = <%s>\n", i, argv[i]);
+        printf ("Arg %d = <%s>\n", i, argv[i]);
     return 0;
+}
 #endif

Subversion Repositories DevTools

(root)/core_devl/trunk/UTILS/SH/GLOB.C – Rev 227 → 5659