This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
add File::BSDGlob as File::Glob and load it at compile-time
authorGurusamy Sarathy <gsar@cpan.org>
Tue, 12 Oct 1999 16:53:31 +0000 (16:53 +0000)
committerGurusamy Sarathy <gsar@cpan.org>
Tue, 12 Oct 1999 16:53:31 +0000 (16:53 +0000)
if perl was built with -DPERL_INTERNAL_GLOB

TODO: we currently get a compile-time failure if File/Glob.pm
can't be found; such failure needs to be made to emit a warning
and use the csh implementation instead

p4raw-id: //depot/perl@4356

16 files changed:
MANIFEST
ext/File/Glob/Changes [new file with mode: 0644]
ext/File/Glob/Glob.pm [new file with mode: 0644]
ext/File/Glob/Glob.xs [new file with mode: 0644]
ext/File/Glob/Makefile.PL [new file with mode: 0644]
ext/File/Glob/TODO [new file with mode: 0644]
ext/File/Glob/bsd_glob.c [new file with mode: 0644]
ext/File/Glob/bsd_glob.h [new file with mode: 0644]
op.c
t/lib/glob-basic.t [new file with mode: 0755]
t/lib/glob-global.t [new file with mode: 0755]
t/lib/glob-taint.t [new file with mode: 0755]
t/op/glob.t
t/op/readdir.t
t/op/taint.t
t/pragma/overload.t

index dd81a70..05281ea 100644 (file)
--- a/MANIFEST
+++ b/MANIFEST
@@ -247,6 +247,13 @@ ext/Errno/Makefile.PL              Errno extension makefile writer
 ext/Fcntl/Fcntl.pm             Fcntl extension Perl module
 ext/Fcntl/Fcntl.xs             Fcntl extension external subroutines
 ext/Fcntl/Makefile.PL          Fcntl extension makefile writer
+ext/File/Glob/Changes          File::Glob extension changelog
+ext/File/Glob/Glob.pm          File::Glob extension module
+ext/File/Glob/Glob.xs          File::Glob extension external subroutines
+ext/File/Glob/Makefile.PL      File::Glob extension makefile writer
+ext/File/Glob/TODO             File::Glob extension todo list
+ext/File/Glob/bsd_glob.c       File::Glob extension run time code
+ext/File/Glob/bsd_glob.h       File::Glob extension header file
 ext/GDBM_File/GDBM_File.pm     GDBM extension Perl module
 ext/GDBM_File/GDBM_File.xs     GDBM extension external subroutines
 ext/GDBM_File/Makefile.PL      GDBM extension makefile writer
@@ -1187,6 +1194,9 @@ t/lib/filespec.t  See if File::Spec works
 t/lib/findbin.t                See if FindBin works
 t/lib/gdbm.t           See if GDBM_File works
 t/lib/getopt.t         See if Getopt::Std and Getopt::Long work
+t/lib/glob-basic.t     See if File::Glob works
+t/lib/glob-global.t    See if File::Glob works
+t/lib/glob-taint.t     See if File::Glob works
 t/lib/gol-basic.t      See if Getopt::Long works
 t/lib/gol-compat.t     See if Getopt::Long works
 t/lib/gol-linkage.t    See if Getopt::Long works
diff --git a/ext/File/Glob/Changes b/ext/File/Glob/Changes
new file mode 100644 (file)
index 0000000..7b8ef7d
--- /dev/null
@@ -0,0 +1,38 @@
+Revision history for Perl extension File::Glob
+
+0.00  Tue Dec 17 10:51:33 1996
+       - original version; created by h2xs 1.16
+
+0.90  Tue Dec 17 13:58:32 MST 1996
+       - implemented first pass access to glob(3),
+         but it's clumsy and it looks like it leaks
+         memory.
+
+0.91  Thu Sep  4 08:43:55 CDT 1997
+       - included CORE/config.h portability macros
+       - s/glob/bsd_glob/ to avoid calling and including the
+         system's glob stuff
+       - added GLOB_DEBUG for (surprise!) glob debugging
+       - tainted all filenames returned from &Glob::BSD::glob
+
+0.92  Tue Sep 30 08:31:57 CDT 1997
+       - only use lstat if HAS_LSTAT is defined
+       - renamed the glob flags to GLOB_*
+       - added GLOB_CSH convenience macro for csh(1) globbing
+       These changes thanks to Hans Mulder <hansm@icgned.nl>
+       - fixed an incompatibility with csh(1) globbing where a
+         pattern like {A*,b,c} wouldn't expand properly
+       - various compatibility changes
+       - fixed and added tests
+
+0.93  Wed Jul  1 10:39:47 CDT 1998
+       - renamed module to File::BSDGlob
+       - enabled 'globally' import directive to override the core
+         glob
+       - added Sarathy's tests for File::DosGlob
+0.99  Tue Oct 12 06:42:02 PDT 1999
+       - renamed module to File::Glob for incorporation into the
+         Perl source distribution
+       - ansified prototypes
+       - s/struct stat/Stat_t/
+       - split on spaces to make <*.c *.h> work (for compatibility)
diff --git a/ext/File/Glob/Glob.pm b/ext/File/Glob/Glob.pm
new file mode 100644 (file)
index 0000000..a4531a1
--- /dev/null
@@ -0,0 +1,310 @@
+package File::Glob;
+
+use strict;
+use Carp;
+use vars qw($VERSION @ISA @EXPORT_OK @EXPORT_FAIL %EXPORT_TAGS $AUTOLOAD);
+
+require Exporter;
+require DynaLoader;
+require AutoLoader;
+
+@ISA = qw(Exporter DynaLoader AutoLoader);
+
+@EXPORT_OK   = qw(
+    globally
+    csh_glob
+    glob
+    GLOB_ABEND
+    GLOB_ALTDIRFUNC
+    GLOB_BRACE
+    GLOB_ERR
+    GLOB_ERROR
+    GLOB_MARK
+    GLOB_NOCHECK
+    GLOB_NOMAGIC
+    GLOB_NOSORT
+    GLOB_NOSPACE
+    GLOB_QUOTE
+    GLOB_TILDE
+);
+
+@EXPORT_FAIL = ( 'globally' );
+
+%EXPORT_TAGS = (
+    'glob' => [ qw(
+        GLOB_ABEND
+        GLOB_ALTDIRFUNC
+        GLOB_BRACE
+        GLOB_ERR
+        GLOB_ERROR
+        GLOB_MARK
+        GLOB_NOCHECK
+        GLOB_NOMAGIC
+        GLOB_NOSORT
+        GLOB_NOSPACE
+        GLOB_QUOTE
+        GLOB_TILDE
+        glob
+    ) ],
+);
+
+$VERSION = '0.99';
+
+sub export_fail {
+    shift;
+
+    if ($_[0] eq 'globally') {
+        local $^W;
+        *CORE::GLOBAL::glob = \&File::Glob::csh_glob;
+        shift;
+    }
+
+    @_;
+}
+
+sub AUTOLOAD {
+    # This AUTOLOAD is used to 'autoload' constants from the constant()
+    # XS function.  If a constant is not found then control is passed
+    # to the AUTOLOAD in AutoLoader.
+
+    my $constname;
+    ($constname = $AUTOLOAD) =~ s/.*:://;
+    my $val = constant($constname, @_ ? $_[0] : 0);
+    if ($! != 0) {
+       if ($! =~ /Invalid/) {
+           $AutoLoader::AUTOLOAD = $AUTOLOAD;
+           goto &AutoLoader::AUTOLOAD;
+       }
+       else {
+               croak "Your vendor has not defined File::Glob macro $constname";
+       }
+    }
+    eval "sub $AUTOLOAD { $val }";
+    goto &$AUTOLOAD;
+}
+
+bootstrap File::Glob $VERSION;
+
+# Preloaded methods go here.
+
+sub GLOB_ERROR {
+    return constant('GLOB_ERROR', 0);
+}
+
+sub GLOB_CSH () { GLOB_BRACE() | GLOB_NOMAGIC() | GLOB_QUOTE() | GLOB_TILDE() }
+
+# Autoload methods go after =cut, and are processed by the autosplit program.
+
+sub glob {
+    return doglob(@_);
+}
+
+## borrowed heavily from gsar's File::DosGlob
+my %iter;
+my %entries;
+
+sub csh_glob {
+    my $pat = shift;
+    my $cxix = shift;
+    my @pat;
+
+    # glob without args defaults to $_
+    $pat = $_ unless defined $pat;
+
+    # extract patterns
+    if ($pat =~ /\s/) {
+        # XXX this is needed for compatibility with the csh
+       # implementation in Perl.  Need to support a flag
+       # to disable this behavior.
+       require Text::ParseWords;
+       @pat = Text::ParseWords::parse_line('\s+',0,$pat);
+    }
+
+    # assume global context if not provided one
+    $cxix = '_G_' unless defined $cxix;
+    $iter{$cxix} = 0 unless exists $iter{$cxix};
+
+    # if we're just beginning, do it all first
+    if ($iter{$cxix} == 0) {
+       if (@pat) {
+           $entries{$cxix} = [ map { doglob($_, GLOB_CSH) } @pat ];
+       }
+       else {
+           $entries{$cxix} = [ doglob($pat, GLOB_CSH) ];
+       }
+    }
+
+    # chuck it all out, quick or slow
+    if (wantarray) {
+        delete $iter{$cxix};
+        return @{delete $entries{$cxix}};
+    }
+    else {
+        if ($iter{$cxix} = scalar @{$entries{$cxix}}) {
+            return shift @{$entries{$cxix}};
+        }
+        else {
+            # return undef for EOL
+            delete $iter{$cxix};
+            delete $entries{$cxix};
+            return undef;
+        }
+    }
+}
+
+1;
+__END__
+
+=head1 NAME
+
+File::Glob - Perl extension for BSD glob routine
+
+=head1 SYNOPSIS
+
+  use File::Glob ':glob';
+  @list = glob('*.[ch]');
+  $homedir = glob('~gnat', GLOB_TILDE | GLOB_ERR);
+  if (GLOB_ERROR) {
+    # an error occurred reading $homedir
+  }
+
+  ## override the core glob (even with -T)
+  use File::Glob 'globally';
+  my @sources = <*.{c,h,y}>
+
+=head1 DESCRIPTION
+
+File::Glob implements the FreeBSD glob(3) routine, which is a superset
+of the POSIX glob() (described in IEEE Std 1003.2 "POSIX.2").  The
+glob() routine takes a mandatory C<pattern> argument, and an optional
+C<flags> argument, and returns a list of filenames matching the
+pattern, with interpretation of the pattern modified by the C<flags>
+variable.  The POSIX defined flags are:
+
+=over 4
+
+=item C<GLOB_ERR>
+
+Force glob() to return an error when it encounters a directory it
+cannot open or read.  Ordinarily glob() continues to find matches.
+
+=item C<GLOB_MARK>
+
+Each pathname that is a directory that matches the pattern has a slash
+appended.
+
+=item C<GLOB_NOCHECK>
+
+If the pattern does not match any pathname, then glob() returns a list
+consisting of only the pattern.  If C<GLOB_QUOTE> is set, its effect
+is present in the pattern returned.
+
+=item C<GLOB_NOSORT>
+
+By default, the pathnames are sorted in ascending ASCII order; this
+flag prevents that sorting (speeding up glob()).
+
+=back
+
+The FreeBSD extensions to the POSIX standard are the following flags:
+
+=over 4
+
+=item C<GLOB_BRACE>
+
+Pre-process the string to expand C<{pat,pat,...} strings like csh(1).
+The pattern '{}' is left unexpanded for historical reasons (and csh(1)
+does the same thing to ease typing of find(1) patterns).
+
+=item C<GLOB_NOMAGIC>
+
+Same as C<GLOB_NOCHECK> but it only returns the pattern if it does not
+contain any of the special characters "*", "?" or "[".  C<NOMAGIC> is
+provided to simplify implementing the historic csh(1) globbing
+behaviour and should probably not be used anywhere else.
+
+=item C<GLOB_QUOTE>
+
+Use the backslash ('\') character for quoting: every occurrence of a
+backslash followed by a character in the pattern is replaced by that
+character, avoiding any special interpretation of the character.
+
+=item C<GLOB_TILDE>
+
+Expand patterns that start with '~' to user name home directories.
+
+=item C<GLOB_CSH>
+
+For convenience, C<GLOB_CSH> is a synonym for
+C<GLOB_BRACE | GLOB_NOMAGIC | GLOB_QUOTE | GLOB_TILDE>.
+
+=back
+
+The POSIX provided C<GLOB_APPEND>, C<GLOB_DOOFFS>, and the FreeBSD
+extensions C<GLOB_ALTDIRFUNC>, and C<GLOB_MAGCHAR> flags have not been
+implemented in the Perl version because they involve more complex
+interaction with the underlying C structures.
+
+=head1 DIAGNOSTICS
+
+glob() returns a list of matching paths, possibly zero length.  If an
+error occurred, &File::Glob::GLOB_ERROR will be non-zero and C<$!> will be
+set.  &File::Glob::GLOB_ERROR is guaranteed to be zero if no error occurred,
+or one of the following values otherwise:
+
+=over 4
+
+=item C<GLOB_NOSPACE>
+
+An attempt to allocate memory failed.
+
+=item C<GLOB_ABEND>
+
+The glob was stopped because an error was encountered.
+
+=back
+
+In the case where glob() has found some matching paths, but is
+interrupted by an error, glob() will return a list of filenames B<and>
+set &File::Glob::ERROR.
+
+Note that glob() deviates from POSIX and FreeBSD glob(3) behaviour by
+not considering C<ENOENT> and C<ENOTDIR> as errors - glob() will
+continue processing despite those errors, unless the C<GLOB_ERR> flag is
+set.
+
+Be aware that all filenames returned from File::Glob are tainted.
+
+=head1 NOTES
+
+=over 4
+
+=item *
+
+If you want to use multiple patterns, e.g. C<glob "a* b*">, you should
+probably throw them in a set as in C<glob "{a*,b*}>.  This is because
+the argument to glob isn't subjected to parsing by the C shell.  Remember
+that you can use a backslash to escape things.
+
+=item *
+
+Win32 users should use the real slash.  If you really want to use
+backslashes, consider using Sarathy's File::DosGlob, which comes with
+the standard Perl distribution.
+
+=head1 AUTHOR
+
+The Perl interface was written by Nathan Torkington (gnat@frii.com),
+and is released under the artistic license.  Further modifications were
+made by Greg Bacon E<lt>gbacon@cs.uah.eduE<gt> and Gurusamy Sarathy
+E<lt>gsar@activestate.comE<gt>.  The C glob code has the
+following copyright:
+
+  Copyright (c) 1989, 1993 The Regents of the University of California.
+  All rights reserved.  This code is derived from software contributed
+  to Berkeley by Guido van Rossum.
+
+For redistribution of the C glob code, read the copyright notice in
+the file bsd_glob.c, which is part of the File::Glob source distribution.
+
+=cut
diff --git a/ext/File/Glob/Glob.xs b/ext/File/Glob/Glob.xs
new file mode 100644 (file)
index 0000000..98e366c
--- /dev/null
@@ -0,0 +1,203 @@
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+
+#include "bsd_glob.h"
+
+static int GLOB_ERROR = 0;
+
+static int
+not_here(char *s)
+{
+    croak("%s not implemented on this architecture", s);
+    return -1;
+}
+
+
+static double
+constant(char *name, int arg)
+{
+    errno = 0;
+    if (strlen(name) <= 5)
+        goto not_there;
+    switch (*(name+5)) {
+    case 'A':
+       if (strEQ(name, "GLOB_ABEND"))
+#ifdef GLOB_ABEND
+           return GLOB_ABEND;
+#else
+           goto not_there;
+#endif
+       if (strEQ(name, "GLOB_ALTDIRFUNC"))
+#ifdef GLOB_ALTDIRFUNC
+           return GLOB_ALTDIRFUNC;
+#else
+           goto not_there;
+#endif
+       break;
+    case 'B':
+       if (strEQ(name, "GLOB_BRACE"))
+#ifdef GLOB_BRACE
+           return GLOB_BRACE;
+#else
+           goto not_there;
+#endif
+       break;
+    case 'C':
+       break;
+    case 'D':
+       break;
+    case 'E':
+       if (strEQ(name, "GLOB_ERR"))
+#ifdef GLOB_ERR
+           return GLOB_ERR;
+#else
+           goto not_there;
+#endif
+        if (strEQ(name, "GLOB_ERROR"))
+            return GLOB_ERROR;
+        break;
+    case 'F':
+       break;
+    case 'G':
+        break;
+    case 'H':
+       break;
+    case 'I':
+       break;
+    case 'J':
+       break;
+    case 'K':
+       break;
+    case 'L':
+       break;
+    case 'M':
+       if (strEQ(name, "GLOB_MARK"))
+#ifdef GLOB_MARK
+           return GLOB_MARK;
+#else
+           goto not_there;
+#endif
+       break;
+    case 'N':
+       if (strEQ(name, "GLOB_NOCHECK"))
+#ifdef GLOB_NOCHECK
+           return GLOB_NOCHECK;
+#else
+           goto not_there;
+#endif
+       if (strEQ(name, "GLOB_NOMAGIC"))
+#ifdef GLOB_NOMAGIC
+           return GLOB_NOMAGIC;
+#else
+           goto not_there;
+#endif
+       if (strEQ(name, "GLOB_NOSORT"))
+#ifdef GLOB_NOSORT
+           return GLOB_NOSORT;
+#else
+           goto not_there;
+#endif
+       if (strEQ(name, "GLOB_NOSPACE"))
+#ifdef GLOB_NOSPACE
+           return GLOB_NOSPACE;
+#else
+           goto not_there;
+#endif
+       break;
+    case 'O':
+       break;
+    case 'P':
+       break;
+    case 'Q':
+       if (strEQ(name, "GLOB_QUOTE"))
+#ifdef GLOB_QUOTE
+           return GLOB_QUOTE;
+#else
+           goto not_there;
+#endif
+       break;
+    case 'R':
+       break;
+    case 'S':
+       break;
+    case 'T':
+       if (strEQ(name, "GLOB_TILDE"))
+#ifdef GLOB_TILDE
+           return GLOB_TILDE;
+#else
+           goto not_there;
+#endif
+       break;
+    case 'U':
+       break;
+    case 'V':
+       break;
+    case 'W':
+       break;
+    case 'X':
+       break;
+    case 'Y':
+       break;
+    case 'Z':
+       break;
+    }
+    errno = EINVAL;
+    return 0;
+
+not_there:
+    errno = ENOENT;
+    return 0;
+}
+
+#ifdef WIN32
+#define errfunc                NULL
+#else
+int
+errfunc(const char *foo, int bar) {
+  return !(bar == ENOENT || bar == ENOTDIR);
+}
+#endif
+
+MODULE = File::Glob            PACKAGE = File::Glob
+
+void
+doglob(pattern,...)
+    char *pattern
+PROTOTYPE:
+PREINIT:
+    glob_t pglob;
+    int i;
+    int retval;
+    int flags = 0;
+    SV *tmp;
+PPCODE:
+    {
+       /* allow for optional flags argument */
+       if (items > 1) {
+           flags = (int) SvIV(ST(1));
+       }
+
+       /* call glob */
+       retval = bsd_glob(pattern, flags, errfunc, &pglob);
+       GLOB_ERROR = retval;
+
+       /* return any matches found */
+       EXTEND(sp, pglob.gl_pathc);
+       for (i = 0; i < pglob.gl_pathc; i++) {
+           /* printf("# bsd_glob: %s\n", pglob.gl_pathv[i]); */
+           tmp = sv_2mortal(newSVpvn(pglob.gl_pathv[i],
+                                     strlen(pglob.gl_pathv[i])));
+           TAINT;
+           SvTAINT(tmp);
+           PUSHs(tmp);
+       }
+
+       bsd_globfree(&pglob);
+    }
+
+double
+constant(name,arg)
+    char *name
+    int   arg
+PROTOTYPE:
diff --git a/ext/File/Glob/Makefile.PL b/ext/File/Glob/Makefile.PL
new file mode 100644 (file)
index 0000000..c82988f
--- /dev/null
@@ -0,0 +1,11 @@
+use ExtUtils::MakeMaker;
+WriteMakefile(
+    NAME               => 'File::Glob',
+    VERSION_FROM       => 'Glob.pm',
+    MAN3PODS           => {},     # Pods will be built by installman.
+    OBJECT             => 'bsd_glob$(OBJ_EXT) Glob$(OBJ_EXT)',
+
+## uncomment for glob debugging (will cause make test to fail)
+#   DEFINE             => '-DGLOB_DEBUG',
+#   OPTIMIZE           => '-g',
+);
diff --git a/ext/File/Glob/TODO b/ext/File/Glob/TODO
new file mode 100644 (file)
index 0000000..ef2547f
--- /dev/null
@@ -0,0 +1,21 @@
+Some issues left to take care of:
+
+  o sane ~ handling on non-Unix platforms
+
+     Currently on non-Unix, when the glob code encounters a tilde glob
+     (.e.g ~user/foo or ~/.cshrc), it simply returns that pattern
+     without doing any expansion (meaning perl will weed it out since a
+     file of that name isn't likely to exist).
+
+     Please, if you have strong feelings about how tilde expansion
+     should be done on your favorite non-Unix platform(s), submit a
+     patch.
+
+  o path separator handling
+
+     Guido's code contains the assumption that the path separator is one
+     character (byte, probably) in length.  Win32 doesn't object to the
+     true slash as a separator.  I imagine MacPerl could change the SEP
+     cpp #define to ":".  I have no idea what it is for VMS.  Again, if
+     you have ideas and especially patches, please feel free to share
+     them.
diff --git a/ext/File/Glob/bsd_glob.c b/ext/File/Glob/bsd_glob.c
new file mode 100644 (file)
index 0000000..38ace47
--- /dev/null
@@ -0,0 +1,856 @@
+/*
+ * Copyright (c) 1989, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Guido van Rossum.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Clause 3 above should be considered "deleted in its entirety".
+ * For the actual notice of withdrawal, see:
+ *    ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)glob.c     8.3 (Berkeley) 10/13/93";
+#endif /* LIBC_SCCS and not lint */
+
+/*
+ * glob(3) -- a superset of the one defined in POSIX 1003.2.
+ *
+ * The [!...] convention to negate a range is supported (SysV, Posix, ksh).
+ *
+ * Optional extra services, controlled by flags not defined by POSIX:
+ *
+ * GLOB_QUOTE:
+ *     Escaping convention: \ inhibits any special meaning the following
+ *     character might have (except \ at end of string is retained).
+ * GLOB_MAGCHAR:
+ *     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:
+ *     Number of matches in the current invocation of glob.
+ */
+
+#include <EXTERN.h>
+#include <perl.h>
+#include "bsd_glob.h"
+#ifdef I_PWD
+#      include <pwd.h>
+#else
+#ifdef HAS_PASSWD
+       struct passwd *getpwnam(char *);
+       struct passwd *getpwuid(Uid_t);
+#endif
+#endif
+
+#ifndef MAXPATHLEN
+#  ifdef PATH_MAX
+#    define    MAXPATHLEN      PATH_MAX
+#  else
+#    define    MAXPATHLEN      1024
+#  endif
+#endif
+
+#define        DOLLAR          '$'
+#define        DOT             '.'
+#define        EOS             '\0'
+#define        LBRACKET        '['
+#define        NOT             '!'
+#define        QUESTION        '?'
+#define        QUOTE           '\\'
+#define        RANGE           '-'
+#define        RBRACKET        ']'
+#define        SEP             '/'
+#define        STAR            '*'
+#define        TILDE           '~'
+#define        UNDERSCORE      '_'
+#define        LBRACE          '{'
+#define        RBRACE          '}'
+#define        SLASH           '/'
+#define        COMMA           ','
+
+#ifndef GLOB_DEBUG
+
+#define        M_QUOTE         0x8000
+#define        M_PROTECT       0x4000
+#define        M_MASK          0xffff
+#define        M_ASCII         0x00ff
+
+typedef U16 Char;
+
+#else
+
+#define        M_QUOTE         0x80
+#define        M_PROTECT       0x40
+#define        M_MASK          0xff
+#define        M_ASCII         0x7f
+
+typedef U8 Char;
+
+#endif /* !GLOB_DEBUG */
+
+
+#define        CHAR(c)         ((Char)((c)&M_ASCII))
+#define        META(c)         ((Char)((c)|M_QUOTE))
+#define        M_ALL           META('*')
+#define        M_END           META(']')
+#define        M_NOT           META('!')
+#define        M_ONE           META('?')
+#define        M_RNG           META('-')
+#define        M_SET           META('[')
+#define        ismeta(c)       (((c)&M_QUOTE) != 0)
+
+
+static int      compare(const void *, const void *);
+static void     g_Ctoc(const Char *, char *);
+static int      g_lstat(Char *, Stat_t *, glob_t *);
+static DIR     *g_opendir(Char *, glob_t *);
+static Char    *g_strchr(Char *, int);
+#ifdef notdef
+static Char    *g_strcat(Char *, const Char *);
+#endif
+static int      g_stat(Char *, Stat_t *, glob_t *);
+static int      glob0(const Char *, glob_t *);
+static int      glob1(Char *, glob_t *);
+static int      glob2(Char *, Char *, Char *, glob_t *);
+static int      glob3(Char *, Char *, Char *, Char *, glob_t *);
+static int      globextend(const Char *, glob_t *);
+static const Char *     globtilde(const Char *, Char *, glob_t *);
+static int      globexp1(const Char *, glob_t *);
+static int      globexp2(const Char *, const Char *, glob_t *, int *);
+static int      match(Char *, Char *, Char *);
+#ifdef GLOB_DEBUG
+static void     qprintf(const char *, Char *);
+#endif /* GLOB_DEBUG */
+
+int
+bsd_glob(const char *pattern, int flags,
+        int (*errfunc)(const char *, int), glob_t *pglob)
+{
+       const U8 *patnext;
+       int c;
+       Char *bufnext, *bufend, patbuf[MAXPATHLEN+1];
+
+       patnext = (U8 *) pattern;
+       if (!(flags & GLOB_APPEND)) {
+               pglob->gl_pathc = 0;
+               pglob->gl_pathv = NULL;
+               if (!(flags & GLOB_DOOFFS))
+                       pglob->gl_offs = 0;
+       }
+       pglob->gl_flags = flags & ~GLOB_MAGCHAR;
+       pglob->gl_errfunc = errfunc;
+       pglob->gl_matchc = 0;
+
+       bufnext = patbuf;
+       bufend = bufnext + MAXPATHLEN;
+       if (flags & GLOB_QUOTE) {
+               /* Protect the quoted characters. */
+               while (bufnext < bufend && (c = *patnext++) != EOS)
+                       if (c == QUOTE) {
+                               if ((c = *patnext++) == EOS) {
+                                       c = QUOTE;
+                                       --patnext;
+                               }
+                               *bufnext++ = c | M_PROTECT;
+                       }
+                       else
+                               *bufnext++ = c;
+       }
+       else
+           while (bufnext < bufend && (c = *patnext++) != EOS)
+                   *bufnext++ = c;
+       *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(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(const Char *ptr, const Char *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 GLOB_DEBUG
+                               qprintf("globexp2:", patbuf);
+#endif /* GLOB_DEBUG */
+                               *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(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) {
+#ifdef HAS_PASSWD
+                       if ((pwd = getpwuid(getuid())) == NULL)
+                               return pattern;
+                       else
+                               h = pwd->pw_dir;
+#else
+                        return pattern;
+#endif
+               }
+       }
+       else {
+               /*
+                * Expand a ~user
+                */
+#ifdef HAS_PASSWD
+               if ((pwd = getpwnam((char*) patbuf)) == NULL)
+                       return pattern;
+               else
+                       h = pwd->pw_dir;
+#else
+                return pattern;
+#endif
+       }
+
+       /* 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(const Char *pattern, glob_t *pglob)
+{
+       const Char *qpat, *qpatnext;
+       int c, err, oldflags, oldpathc;
+       Char *bufnext, patbuf[MAXPATHLEN+1];
+
+       qpat = globtilde(pattern, patbuf, pglob);
+       qpatnext = qpat;
+       oldflags = pglob->gl_flags;
+       oldpathc = pglob->gl_pathc;
+       bufnext = patbuf;
+
+       /* We don't need to check for buffer overflow any more. */
+       while ((c = *qpatnext++) != EOS) {
+               switch (c) {
+               case LBRACKET:
+                       c = *qpatnext;
+                       if (c == NOT)
+                               ++qpatnext;
+                       if (*qpatnext == EOS ||
+                           g_strchr((Char *) qpatnext+1, RBRACKET) == NULL) {
+                               *bufnext++ = LBRACKET;
+                               if (c == NOT)
+                                       --qpatnext;
+                               break;
+                       }
+                       *bufnext++ = M_SET;
+                       if (c == NOT)
+                               *bufnext++ = M_NOT;
+                       c = *qpatnext++;
+                       do {
+                               *bufnext++ = CHAR(c);
+                               if (*qpatnext == RANGE &&
+                                   (c = qpatnext[1]) != RBRACKET) {
+                                       *bufnext++ = M_RNG;
+                                       *bufnext++ = CHAR(c);
+                                       qpatnext += 2;
+                               }
+                       } while ((c = *qpatnext++) != RBRACKET);
+                       pglob->gl_flags |= GLOB_MAGCHAR;
+                       *bufnext++ = M_END;
+                       break;
+               case QUESTION:
+                       pglob->gl_flags |= GLOB_MAGCHAR;
+                       *bufnext++ = M_ONE;
+                       break;
+               case STAR:
+                       pglob->gl_flags |= GLOB_MAGCHAR;
+                       /* collapse adjacent stars to one,
+                        * to avoid exponential behavior
+                        */
+                       if (bufnext == patbuf || bufnext[-1] != M_ALL)
+                           *bufnext++ = M_ALL;
+                       break;
+               default:
+                       *bufnext++ = CHAR(c);
+                       break;
+               }
+       }
+       *bufnext = EOS;
+#ifdef GLOB_DEBUG
+       qprintf("glob0:", patbuf);
+#endif /* GLOB_DEBUG */
+
+       if ((err = glob1(patbuf, pglob)) != 0) {
+               pglob->gl_flags = oldflags;
+               return(err);
+       }
+
+       /*
+        * If there was no match we are going to append the pattern
+        * if GLOB_NOCHECK was specified or if GLOB_NOMAGIC was specified
+        * and the pattern did not contain any magic characters
+        * GLOB_NOMAGIC is there just for compatibility with csh.
+        */
+       if (pglob->gl_pathc == oldpathc &&
+           ((pglob->gl_flags & GLOB_NOCHECK) ||
+             ((pglob->gl_flags & GLOB_NOMAGIC) &&
+              !(pglob->gl_flags & GLOB_MAGCHAR))))
+       {
+#ifdef GLOB_DEBUG
+               printf("calling globextend from glob0\n");
+#endif /* GLOB_DEBUG */
+               pglob->gl_flags = oldflags;
+               return(globextend(qpat, pglob));
+        }
+       else if (!(pglob->gl_flags & GLOB_NOSORT))
+               qsort(pglob->gl_pathv + pglob->gl_offs + oldpathc,
+                   pglob->gl_pathc - oldpathc, sizeof(char *), compare);
+       pglob->gl_flags = oldflags;
+       return(0);
+}
+
+static int
+compare(const void *p, const void *q)
+{
+       return(strcmp(*(char **)p, *(char **)q));
+}
+
+static int
+glob1(Char *pattern, glob_t *pglob)
+{
+       Char pathbuf[MAXPATHLEN+1];
+
+       /* A null pathname is invalid -- POSIX 1003.1 sect. 2.4. */
+       if (*pattern == EOS)
+               return(0);
+       return(glob2(pathbuf, pathbuf, pattern, pglob));
+}
+
+/*
+ * The functions glob2 and glob3 are mutually recursive; there is one level
+ * of recursion for each segment in the pattern that contains one or more
+ * meta characters.
+ */
+static int
+glob2(Char *pathbuf, Char *pathend, Char *pattern, glob_t *pglob)
+{
+       Stat_t sb;
+       Char *p, *q;
+       int anymeta;
+
+       /*
+        * Loop over pattern segments until end of pattern or until
+        * segment with meta character found.
+        */
+       for (anymeta = 0;;) {
+               if (*pattern == EOS) {          /* End of pattern? */
+                       *pathend = EOS;
+
+#ifdef HAS_LSTAT
+                       if (g_lstat(pathbuf, &sb, pglob))
+                               return(0);
+#endif /* HAS_LSTAT */
+
+                       if (((pglob->gl_flags & GLOB_MARK) &&
+                           pathend[-1] != SEP) && (S_ISDIR(sb.st_mode)
+                           || (S_ISLNK(sb.st_mode) &&
+                           (g_stat(pathbuf, &sb, pglob) == 0) &&
+                           S_ISDIR(sb.st_mode)))) {
+                               *pathend++ = SEP;
+                               *pathend = EOS;
+                       }
+                       ++pglob->gl_matchc;
+#ifdef GLOB_DEBUG
+                        printf("calling globextend from glob2\n");
+#endif /* GLOB_DEBUG */
+                       return(globextend(pathbuf, pglob));
+               }
+
+               /* Find end of next segment, copy tentatively to pathend. */
+               q = pathend;
+               p = pattern;
+               while (*p != EOS && *p != SEP) {
+                       if (ismeta(*p))
+                               anymeta = 1;
+                       *q++ = *p++;
+               }
+
+               if (!anymeta) {         /* No expansion, do next segment. */
+                       pathend = q;
+                       pattern = p;
+                       while (*pattern == SEP)
+                               *pathend++ = *pattern++;
+               } else                  /* Need expansion, recurse. */
+                       return(glob3(pathbuf, pathend, pattern, p, pglob));
+       }
+       /* NOTREACHED */
+}
+
+static int
+glob3(Char *pathbuf, Char *pathend, Char *pattern,
+      Char *restpattern, glob_t *pglob)
+{
+       register Direntry_t *dp;
+       DIR *dirp;
+       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.
+        */
+       Direntry_t *(*readdirfunc)();
+
+       *pathend = EOS;
+       errno = 0;
+
+       if ((dirp = g_opendir(pathbuf, pglob)) == NULL) {
+               /* TODO: don't call for ENOENT or ENOTDIR? */
+               if (pglob->gl_errfunc) {
+                       g_Ctoc(pathbuf, buf);
+                       if (pglob->gl_errfunc(buf, errno) ||
+                           (pglob->gl_flags & GLOB_ERR))
+                               return (GLOB_ABEND);
+               }
+               return(0);
+       }
+
+       err = 0;
+
+       /* Search directory for matching names. */
+       if (pglob->gl_flags & GLOB_ALTDIRFUNC)
+               readdirfunc = pglob->gl_readdir;
+       else
+               readdirfunc = readdir;
+       while ((dp = (*readdirfunc)(dirp))) {
+               register U8 *sc;
+               register Char *dc;
+
+               /* Initial DOT must be matched literally. */
+               if (dp->d_name[0] == DOT && *pattern != DOT)
+                       continue;
+               for (sc = (U8 *) dp->d_name, dc = pathend;
+                    (*dc++ = *sc++) != EOS;)
+                       continue;
+               if (!match(pathend, pattern, restpattern)) {
+                       *pathend = EOS;
+                       continue;
+               }
+               err = glob2(pathbuf, --dc, restpattern, pglob);
+               if (err)
+                       break;
+       }
+
+       if (pglob->gl_flags & GLOB_ALTDIRFUNC)
+               (*pglob->gl_closedir)(dirp);
+       else
+               closedir(dirp);
+       return(err);
+}
+
+
+/*
+ * Extend the gl_pathv member of a glob_t structure to accomodate a new item,
+ * add the new item, and update gl_pathc.
+ *
+ * This assumes the BSD realloc, which only copies the block when its size
+ * crosses a power-of-two boundary; for v7 realloc, this would cause quadratic
+ * behavior.
+ *
+ * Return 0 if new item added, error code if memory couldn't be allocated.
+ *
+ * Invariant of the glob_t structure:
+ *     Either gl_pathc is zero and gl_pathv is NULL; or gl_pathc > 0 and
+ *     gl_pathv points to (gl_offs + gl_pathc + 1) items.
+ */
+static int
+globextend(const Char *path, glob_t *pglob)
+{
+       register char **pathv;
+       register int i;
+       Size_t newsize;
+       char *copy;
+       const Char *p;
+
+#ifdef GLOB_DEBUG
+       printf("Adding ");
+        for (p = path; *p; p++)
+                (void)printf("%c", CHAR(*p));
+        printf("\n");
+#endif GLOB_DEBUG
+
+       newsize = sizeof(*pathv) * (2 + pglob->gl_pathc + pglob->gl_offs);
+       pathv = pglob->gl_pathv ?
+                   realloc((char *)pglob->gl_pathv, newsize) :
+                   malloc(newsize);
+       if (pathv == NULL)
+               return(GLOB_NOSPACE);
+
+       if (pglob->gl_pathv == NULL && pglob->gl_offs > 0) {
+               /* first time around -- clear initial gl_offs items */
+               pathv += pglob->gl_offs;
+               for (i = pglob->gl_offs; --i >= 0; )
+                       *--pathv = NULL;
+       }
+       pglob->gl_pathv = pathv;
+
+       for (p = path; *p++;)
+               continue;
+       if ((copy = malloc(p - path)) != NULL) {
+               g_Ctoc(path, copy);
+               pathv[pglob->gl_offs + pglob->gl_pathc++] = copy;
+       }
+       pathv[pglob->gl_offs + pglob->gl_pathc] = NULL;
+       return(copy == NULL ? GLOB_NOSPACE : 0);
+}
+
+
+/*
+ * pattern matching function for filenames.  Each occurrence of the *
+ * pattern causes a recursion level.
+ */
+static int
+match(register Char *name, register Char *pat, register Char *patend)
+{
+       int ok, negate_range;
+       Char c, k;
+
+       while (pat < patend) {
+               c = *pat++;
+               switch (c & M_MASK) {
+               case M_ALL:
+                       if (pat == patend)
+                               return(1);
+                       do
+                           if (match(name, pat, patend))
+                                   return(1);
+                       while (*name++ != EOS);
+                       return(0);
+               case M_ONE:
+                       if (*name++ == EOS)
+                               return(0);
+                       break;
+               case M_SET:
+                       ok = 0;
+                       if ((k = *name++) == EOS)
+                               return(0);
+                       if ((negate_range = ((*pat & M_MASK) == M_NOT)) != EOS)
+                               ++pat;
+                       while (((c = *pat++) & M_MASK) != M_END)
+                               if ((*pat & M_MASK) == M_RNG) {
+                                       if (c <= k && k <= pat[1])
+                                               ok = 1;
+                                       pat += 2;
+                               } else if (c == k)
+                                       ok = 1;
+                       if (ok == negate_range)
+                               return(0);
+                       break;
+               default:
+                       if (*name++ != c)
+                               return(0);
+                       break;
+               }
+       }
+       return(*name == EOS);
+}
+
+/* Free allocated data belonging to a glob_t structure. */
+void
+bsd_globfree(glob_t *pglob)
+{
+       register int i;
+       register char **pp;
+
+       if (pglob->gl_pathv != NULL) {
+               pp = pglob->gl_pathv + pglob->gl_offs;
+               for (i = pglob->gl_pathc; i--; ++pp)
+                       if (*pp)
+                               free(*pp);
+               free(pglob->gl_pathv);
+       }
+}
+
+static DIR *
+g_opendir(register Char *str, glob_t *pglob)
+{
+       char buf[MAXPATHLEN];
+
+       if (!*str)
+               strcpy(buf, ".");
+       else
+               g_Ctoc(str, buf);
+
+       if (pglob->gl_flags & GLOB_ALTDIRFUNC)
+               return((*pglob->gl_opendir)(buf));
+
+       return(opendir(buf));
+}
+
+#ifdef HAS_LSTAT
+static int
+g_lstat(register Char *fn, Stat_t *sb, glob_t *pglob)
+{
+       char buf[MAXPATHLEN];
+
+       g_Ctoc(fn, buf);
+       if (pglob->gl_flags & GLOB_ALTDIRFUNC)
+               return((*pglob->gl_lstat)(buf, sb));
+       return(lstat(buf, sb));
+}
+#endif /* HAS_LSTAT */
+
+static int
+g_stat(register Char *fn, Stat_t *sb, glob_t *pglob)
+{
+       char buf[MAXPATHLEN];
+
+       g_Ctoc(fn, buf);
+       if (pglob->gl_flags & GLOB_ALTDIRFUNC)
+               return((*pglob->gl_stat)(buf, sb));
+       return(stat(buf, sb));
+}
+
+static Char *
+g_strchr(Char *str, int ch)
+{
+       do {
+               if (*str == ch)
+                       return (str);
+       } while (*str++);
+       return (NULL);
+}
+
+#ifdef notdef
+static Char *
+g_strcat(Char *dst, const Char *src)
+{
+       Char *sdst = dst;
+
+       while (*dst++)
+               continue;
+       --dst;
+       while((*dst++ = *src++) != EOS)
+           continue;
+
+       return (sdst);
+}
+#endif
+
+static void
+g_Ctoc(register const Char *str, char *buf)
+{
+       register char *dc;
+
+       for (dc = buf; (*dc++ = *str++) != EOS;)
+               continue;
+}
+
+#ifdef GLOB_DEBUG
+static void
+qprintf(const char *str, register Char *s)
+{
+       register Char *p;
+
+       (void)printf("%s:\n", str);
+       for (p = s; *p; p++)
+               (void)printf("%c", CHAR(*p));
+       (void)printf("\n");
+       for (p = s; *p; p++)
+               (void)printf("%c", *p & M_PROTECT ? '"' : ' ');
+       (void)printf("\n");
+       for (p = s; *p; p++)
+               (void)printf("%c", ismeta(*p) ? '_' : ' ');
+       (void)printf("\n");
+}
+#endif /* GLOB_DEBUG */
diff --git a/ext/File/Glob/bsd_glob.h b/ext/File/Glob/bsd_glob.h
new file mode 100644 (file)
index 0000000..625adfd
--- /dev/null
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 1989, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Guido van Rossum.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     @(#)glob.h      8.1 (Berkeley) 6/2/93
+ */
+
+/*
+ * Clause 3 above should be considered "deleted in its entirety".
+ * For the actual notice of withdrawal, see:
+ *    ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change
+ */
+
+#ifndef _BSD_GLOB_H_
+#define        _BSD_GLOB_H_
+
+/* #include <sys/cdefs.h> */
+
+typedef struct {
+       int gl_pathc;           /* Count of total paths so far. */
+       int gl_matchc;          /* Count of paths matching pattern. */
+       int gl_offs;            /* Reserved at beginning of gl_pathv. */
+       int gl_flags;           /* Copy of flags parameter to glob. */
+       char **gl_pathv;        /* List of paths matching pattern. */
+                               /* Copy of errfunc parameter to glob. */
+       int (*gl_errfunc)(const char *, int);
+
+       /*
+        * Alternate filesystem access methods for glob; replacement
+        * versions of closedir(3), readdir(3), opendir(3), stat(2)
+        * and lstat(2).
+        */
+       void (*gl_closedir)(void *);
+       Direntry_t *(*gl_readdir)(void *);
+       void *(*gl_opendir)(const char *);
+       int (*gl_lstat)(const char *, Stat_t *);
+       int (*gl_stat)(const char *, Stat_t *);
+} glob_t;
+
+#define        GLOB_APPEND     0x0001  /* Append to output from previous call. */
+#define        GLOB_DOOFFS     0x0002  /* Use gl_offs. */
+#define        GLOB_ERR        0x0004  /* Return on error. */
+#define        GLOB_MARK       0x0008  /* Append / to matching directories. */
+#define        GLOB_NOCHECK    0x0010  /* Return pattern itself if nothing matches. */
+#define        GLOB_NOSORT     0x0020  /* Don't sort. */
+
+#define        GLOB_ALTDIRFUNC 0x0040  /* Use alternately specified directory funcs. */
+#define        GLOB_BRACE      0x0080  /* Expand braces ala csh. */
+#define        GLOB_MAGCHAR    0x0100  /* Pattern had globbing characters. */
+#define        GLOB_NOMAGIC    0x0200  /* GLOB_NOCHECK without magic chars (csh). */
+#define        GLOB_QUOTE      0x0400  /* Quote special chars with \. */
+#define        GLOB_TILDE      0x0800  /* Expand tilde names from the passwd file. */
+
+#define        GLOB_NOSPACE    (-1)    /* Malloc call failed. */
+#define        GLOB_ABEND      (-2)    /* Unignored error. */
+
+int    bsd_glob(const char *, int, int (*)(const char *, int), glob_t *);
+void   bsd_globfree(glob_t *);
+
+#endif /* !_BSD_GLOB_H_ */
diff --git a/op.c b/op.c
index c59940d..f849a9e 100644 (file)
--- a/op.c
+++ b/op.c
@@ -3351,14 +3351,20 @@ S_new_logop(pTHX_ I32 type, I32 flags, OP** firstp, OP** otherp)
            if (k2 && k2->op_type == OP_READLINE
                  && (k2->op_flags & OPf_STACKED)
                  && ((k1->op_flags & OPf_WANT) == OPf_WANT_SCALAR)) 
+           {
                warnop = k2->op_type;
+           }
            break;
 
        case OP_SASSIGN:
            if (k1->op_type == OP_READDIR
                  || k1->op_type == OP_GLOB
+                 || (k1->op_type == OP_NULL && k1->op_targ == OP_GLOB)
                  || k1->op_type == OP_EACH)
-               warnop = k1->op_type;
+           {
+               warnop = ((k1->op_type == OP_NULL)
+                         ? k1->op_targ : k1->op_type);
+           }
            break;
        }
        if (warnop) {
@@ -3530,6 +3536,7 @@ Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP *expr, OP *block)
              case OP_SASSIGN:
                if (k1->op_type == OP_READDIR
                      || k1->op_type == OP_GLOB
+                     || (k1->op_type == OP_NULL && k1->op_targ == OP_NULL)
                      || k1->op_type == OP_EACH)
                    expr = newUNOP(OP_DEFINED, 0, expr);
                break;
@@ -3583,6 +3590,7 @@ Perl_newWHILEOP(pTHX_ I32 flags, I32 debuggable, LOOP *loop, I32 whileline, OP *
          case OP_SASSIGN:
            if (k1->op_type == OP_READDIR
                  || k1->op_type == OP_GLOB
+                 || (k1->op_type == OP_NULL && k1->op_targ == OP_GLOB)
                  || k1->op_type == OP_EACH)
                expr = newUNOP(OP_DEFINED, 0, expr);
            break;
@@ -5173,6 +5181,19 @@ Perl_ck_glob(pTHX_ OP *o)
     if (!((gv = gv_fetchpv("glob", FALSE, SVt_PVCV)) && GvIMPORTED_CV(gv)))
        gv = gv_fetchpv("CORE::GLOBAL::glob", FALSE, SVt_PVCV);
 
+#if 1 /*def PERL_INTERNAL_GLOB */
+    /* XXX this can be tightened up and made more failsafe. */
+    if (!gv) {
+       OP *modname = newSVOP(OP_CONST, 0, newSVpvn("File::Glob", 10));
+       modname->op_private |= OPpCONST_BARE;
+       ENTER;
+       utilize(1, start_subparse(FALSE, 0), Nullop, modname,
+               newSVOP(OP_CONST, 0, newSVpvn("globally", 8)));
+       gv = gv_fetchpv("CORE::GLOBAL::glob", FALSE, SVt_PVCV);
+       LEAVE;
+    }
+#endif /* PERL_INTERNAL_GLOB */
+
     if (gv && GvIMPORTED_CV(gv)) {
        append_elem(OP_GLOB, o,
                    newSVOP(OP_CONST, 0, newSViv(PL_glob_index++)));
diff --git a/t/lib/glob-basic.t b/t/lib/glob-basic.t
new file mode 100755 (executable)
index 0000000..5189db4
--- /dev/null
@@ -0,0 +1,103 @@
+#!./perl
+
+BEGIN {
+    chdir 't' if -d 't';
+    unshift @INC, '../lib';
+
+    print "1..9\n";
+}
+END {
+    print "not ok 1\n" unless $loaded;
+}
+use File::Glob ':glob';
+$loaded = 1;
+print "ok 1\n";
+
+sub array {
+    return '(', join(", ", map {defined $_ ? "\"$_\"" : "undef"} @a), ")\n";
+}
+
+# look for the contents of the current directory
+$ENV{PATH} = "/bin";
+delete @ENV{BASH_ENV, CDPATH, ENV, IFS};
+@correct = ();
+if (opendir(D, ".")) {
+   @correct = grep { !/^\.\.?$/ } sort readdir(D);
+   closedir D;
+}
+@a = File::Glob::glob("*", 0);
+@a = sort @a;
+if ("@a" ne "@correct" || GLOB_ERROR) {
+    print "# |@a| ne |@correct|\nnot ";
+}
+print "ok 2\n";
+
+# look up the user's home directory
+# should return a list with one item, and not set ERROR
+if ($^O ne 'MSWin32') {
+    ($name, $home) = (getpwuid($>))[0,7];
+    @a = File::Glob::glob("~$name", GLOB_TILDE);
+    if (scalar(@a) != 1 || $a[0] ne $home || GLOB_ERROR) {
+       print "not ";
+    }
+}
+print "ok 3\n";
+
+# check backslashing
+# should return a list with one item, and not set ERROR
+@a = File::Glob::glob('TEST', GLOB_QUOTE);
+if (scalar @a != 1 || $a[0] ne 'TEST' || GLOB_ERROR) {
+    local $/ = "][";
+    print "# [@a]\n";
+    print "not ";
+}
+print "ok 4\n";
+
+# check nonexistent checks
+# should return an empty list
+# XXX since errfunc is NULL on win32, this test is not valid there
+@a = File::Glob::glob("asdfasdf", 0);
+if ($^O ne 'MSWin32' and scalar @a != 0) {
+    print "# |@a|\nnot ";
+}
+print "ok 5\n";
+
+# check bad protections
+# should return an empty list, and set ERROR
+$dir = "PtEeRsLt.dir";
+mkdir $dir, 0;
+@a = File::Glob::glob("$dir/*", GLOB_ERR);
+#print "\@a = ", array(@a);
+rmdir $dir;
+if (scalar(@a) != 0 || ($^O ne 'MSWin32' && GLOB_ERROR == 0)) {
+    print "not ";
+}
+print "ok 6\n";
+
+# check for csh style globbing
+@a = File::Glob::glob('{a,b}', GLOB_BRACE | GLOB_NOMAGIC);
+unless (@a == 2 and $a[0] eq 'a' and $a[1] eq 'b') {
+    print "not ";
+}
+print "ok 7\n";
+
+@a = File::Glob::glob(
+    '{TES*,doesntexist*,a,b}',
+    GLOB_BRACE | GLOB_NOMAGIC
+);
+unless (@a == 3
+        and $a[0] eq 'TEST'
+        and $a[1] eq 'a'
+        and $a[2] eq 'b')
+{
+    print "not ";
+}
+print "ok 8\n";
+
+# "~" should expand to $ENV{HOME}
+$ENV{HOME} = "sweet home";
+@a = File::Glob::glob('~', GLOB_TILDE | GLOB_NOMAGIC);
+unless (@a == 1 and $a[0] eq $ENV{HOME}) {
+    print "not ";
+}
+print "ok 9\n";
diff --git a/t/lib/glob-global.t b/t/lib/glob-global.t
new file mode 100755 (executable)
index 0000000..7da741e
--- /dev/null
@@ -0,0 +1,106 @@
+#!./perl
+
+BEGIN {
+    chdir 't' if -d 't';
+    unshift @INC, '../lib';
+
+    print "1..10\n";
+}
+END {
+    print "not ok 1\n" unless $loaded;
+}
+
+BEGIN {
+    *CORE::GLOBAL::glob = sub { "Just another Perl hacker," };
+}
+
+BEGIN {
+    if ("Just another Perl hacker," ne (<*>)[0]) {
+        die <<EOMessage;
+Your version of perl ($]) doesn't seem to allow extensions to override
+the core glob operator.
+EOMessage
+    }
+}
+
+use File::Glob 'globally';
+$loaded = 1;
+print "ok 1\n";
+
+$_ = "lib/*.t";
+my @r = glob;
+print "not " if $_ ne 'lib/*.t';
+print "ok 2\n";
+
+# we should have at least basic.t, global.t, taint.t
+print "# |@r|\nnot " if @r < 3;
+print "ok 3\n";
+
+# check if <*/*> works
+@r = <*/*.t>;
+# at least t/global.t t/basic.t, t/taint.t
+print "not " if @r < 3;
+print "ok 4\n";
+my $r = scalar @r;
+
+# check if scalar context works
+@r = ();
+while (defined($_ = <*/*.t>)) {
+    #print "# $_\n";
+    push @r, $_;
+}
+print "not " if @r != $r;
+print "ok 5\n";
+
+# check if array context works
+@r = ();
+for (<*/*.t>) {
+    #print "# $_\n";
+    push @r, $_;
+}
+print "not " if @r != $r;
+print "ok 6\n";
+
+# test if implicit assign to $_ in while() works
+@r = ();
+while (<*/*.t>) {
+    #print "# $_\n";
+    push @r, $_;
+}
+print "not " if @r != $r;
+print "ok 7\n";
+
+# test if explicit glob() gets assign magic too
+my @s = ();
+while (glob '*/*.t') {
+    #print "# $_\n";
+    push @s, $_;
+}
+print "not " if "@r" ne "@s";
+print "ok 8\n";
+
+# how about in a different package, like?
+package Foo;
+use File::Glob 'globally';
+@s = ();
+while (glob '*/*.t') {
+    #print "# $_\n";
+    push @s, $_;
+}
+print "not " if "@r" ne "@s";
+print "ok 9\n";
+
+# test if different glob ops maintain independent contexts
+@s = ();
+my $i = 0;
+while (<*/*.t>) {
+    #print "# $_ <";
+    push @s, $_;
+    while (<bas*/*.t>) {
+        #print " $_";
+        $i++;
+    }
+    #print " >\n";
+}
+print "not " if "@r" ne "@s" or not $i;
+print "ok 10\n";
diff --git a/t/lib/glob-taint.t b/t/lib/glob-taint.t
new file mode 100755 (executable)
index 0000000..1b9c053
--- /dev/null
@@ -0,0 +1,21 @@
+#!./perl -T
+
+BEGIN {
+    chdir 't' if -d 't';
+    unshift @INC, '../lib';
+    print "1..2\n";
+}
+END {
+    print "not ok 1\n" unless $loaded;
+}
+use File::Glob;
+$loaded = 1;
+print "ok 1\n";
+
+# all filenames should be tainted
+@a = File::Glob::glob("*");
+eval { $a = join("",@a), kill 0; 1 };
+unless ($@ =~ /Insecure dependency/) {
+    print "not ";
+}
+print "ok 2\n";
index 253e4a3..4c27445 100755 (executable)
@@ -1,6 +1,9 @@
 #!./perl
 
-# $RCSfile: glob.t,v $$Revision: 4.1 $$Date: 92/08/07 18:27:55 $
+BEGIN {
+    chdir 't' if -d 't';
+    unshift @INC, '../lib';
+}
 
 print "1..6\n";
 
index aea9768..d101c2f 100755 (executable)
@@ -1,5 +1,10 @@
 #!./perl
 
+BEGIN {
+    chdir 't' if -d 't';
+    unshift @INC, '../lib';
+}
+
 eval 'opendir(NOSUCH, "no/such/directory");';
 if ($@) { print "1..0\n"; exit; }
 
index fdd1c79..6a9537b 100755 (executable)
@@ -254,7 +254,8 @@ print "1..149\n";
 
 # Globs should be forbidden, except under VMS,
 #   which doesn't spawn an external program.
-if ($Is_VMS) {
+if (1  # built-in glob
+    or $Is_VMS) {
     for (35..36) { print "ok $_\n"; }
 }
 else {
index ff8d805..f673dce 100755 (executable)
@@ -712,7 +712,14 @@ test($c, "bareword");      # 135
   sub new { my ($p, $v) = @_; bless \$v, $p }
   sub iter { my ($x) = @_; return undef if $$x < 0; return $$x--; }
 }
-{
+
+# XXX iterator overload not intended to work with CORE::GLOBAL?
+if (defined &CORE::GLOBAL::glob) {
+  test '1', '1';       # 175
+  test '1', '1';       # 176
+  test '1', '1';       # 177
+}
+else {
   my $iter = iterator->new(5);
   my $acc = '';
   my $out;