00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066 #define xfree free
00067 #define xmalloc malloc
00068 #define xrealloc realloc
00069
00070 #ifdef SPARKY
00071 #undef _POSIX_SOURCE
00072 #endif
00073
00074 #include <sys/types.h>
00075 #include <sys/param.h>
00076 #include <sys/stat.h>
00077 #include <dirent.h>
00078 #include <ctype.h>
00079 typedef void * ptr_t;
00080
00081
00082
00083 #if 0
00084 # define Char __Char
00085 # include "sh.h"
00086 # undef Char
00087 # undef QUOTE
00088 # undef TILDE
00089 # undef META
00090 # undef CHAR
00091 # undef ismeta
00092 # undef Strchr
00093 #endif
00094
00095 #include "l_mcw_glob.h"
00096
00097
00098 static int g_sort_dir = 1 ;
00099
00100 #ifndef S_ISDIR
00101 #define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
00102 #endif
00103
00104 #if !defined(S_ISLNK) && defined(S_IFLNK)
00105 #define S_ISLNK(a) (((a) & S_IFMT) == S_IFLNK)
00106 #endif
00107
00108 #if !defined(S_ISLNK) && !defined(lstat)
00109 #define lstat stat
00110 #endif
00111
00112 typedef unsigned short Char;
00113
00114 #undef __P
00115 #define __P(a) a
00116
00117 static int glob1 __P((Char *, glob_t *, int));
00118 static int glob2 __P((Char *, Char *, Char *, glob_t *, int));
00119 static int glob3 __P((Char *, Char *, Char *, Char *,
00120 glob_t *, int));
00121 static int globextend __P((Char *, glob_t *));
00122 static int match __P((Char *, Char *, Char *, int));
00123 #ifndef __clipper__
00124 static int compare __P((const ptr_t, const ptr_t));
00125 #endif
00126 static DIR *Opendir __P((Char *));
00127 #ifdef S_IFLNK
00128 static int Lstat __P((Char *, struct stat *));
00129 #endif
00130 static Char *Strchr __P((Char *, int));
00131 #ifdef DEBUG
00132 static void qprintf __P((Char *));
00133 #endif
00134
00135 #define DOLLAR '$'
00136 #define DOT '.'
00137 #define EOS '\0'
00138 #define LBRACKET '['
00139 #define NOT '!'
00140 #define ALTNOT '^'
00141 #define QUESTION '?'
00142 #define QUOTE '\\'
00143 #define RANGE '-'
00144 #define RBRACKET ']'
00145 #define SEP '/'
00146 #define STAR '*'
00147 #define TILDE '~'
00148 #define UNDERSCORE '_'
00149
00150 #define M_META 0x8000
00151 #define M_PROTECT 0x4000
00152 #define M_MASK 0xffff
00153 #define M_ASCII 0x00ff
00154
00155 #define CHAR(c) ((c)&M_ASCII)
00156 #define META(c) ((c)|M_META)
00157 #define M_ALL META('*')
00158 #define M_END META(']')
00159 #define M_NOT META('!')
00160 #define M_ALTNOT META('^')
00161 #define M_ONE META('?')
00162 #define M_RNG META('-')
00163 #define M_SET META('[')
00164 #define ismeta(c) (((c)&M_META) != 0)
00165
00166 #if defined(SOLARIS_DIRENT_ZERO) && !defined(SOLARIS_DIRENT_PATCH)
00167 # define SOLARIS_DIRENT_PATCH
00168 #endif
00169
00170 #ifdef SOLARIS_DIRENT_PATCH
00171 struct dirent {
00172 ino_t d_ino;
00173 off_t d_off;
00174 unsigned short d_reclen;
00175 char d_name[1];
00176 };
00177 #endif
00178
00179
00180
00181
00182
00183
00184
00185
00186 static DIR *
00187 Opendir(Char *str)
00188 {
00189 char buf[MAXPATHLEN];
00190 register char *dc = buf;
00191
00192 if (!*str)
00193 return (opendir("."));
00194 while ((*dc++ = *str++) != '\0')
00195 continue;
00196 return (opendir(buf));
00197 }
00198
00199 #ifdef S_IFLNK
00200 static int
00201 Lstat(Char *fn, struct stat *sb)
00202 {
00203 char buf[MAXPATHLEN];
00204 register char *dc = buf;
00205
00206 while ((*dc++ = *fn++) != '\0')
00207 continue;
00208 # ifdef NAMEI_BUG
00209 {
00210 int st;
00211
00212 st = lstat(buf, sb);
00213 if (*buf)
00214 dc--;
00215 return (*--dc == '/' && !S_ISDIR(sb->st_mode) ? -1 : st);
00216 }
00217 # else
00218 return (lstat(buf, sb));
00219 # endif
00220 }
00221 #else
00222 #define Lstat Stat
00223 #endif
00224
00225 static int
00226 Stat(Char *fn, struct stat *sb)
00227 {
00228 char buf[MAXPATHLEN];
00229 register char *dc = buf;
00230
00231 while ((*dc++ = *fn++) != '\0')
00232 continue;
00233 #ifdef NAMEI_BUG
00234 {
00235 int st;
00236
00237 st = stat(buf, sb);
00238 if (*buf)
00239 dc--;
00240 return (*--dc == '/' && !S_ISDIR(sb->st_mode) ? -1 : st);
00241 }
00242 #else
00243 return (stat(buf, sb));
00244 #endif
00245 }
00246
00247 static Char *
00248 Strchr(Char *str, int ch)
00249 {
00250 do
00251 if (*str == ch)
00252 return (str);
00253 while (*str++);
00254 return (NULL);
00255 }
00256
00257 #ifdef DEBUG
00258 static void
00259 qprintf(Char *s)
00260 {
00261 Char *p;
00262
00263 for (p = s; *p; p++)
00264 printf("%c", *p & 0xff);
00265 printf("\n");
00266 for (p = s; *p; p++)
00267 printf("%c", *p & M_PROTECT ? '"' : ' ');
00268 printf("\n");
00269 for (p = s; *p; p++)
00270 printf("%c", *p & M_META ? '_' : ' ');
00271 printf("\n");
00272 }
00273 #endif
00274
00275 static int
00276 compare(const ptr_t p, const ptr_t q)
00277 {
00278 #if defined(NLS) && !defined(NOSTRCOLL)
00279
00280 #if 0
00281 errno = 0;
00282 #endif
00283
00284 return (g_sort_dir * strcoll(*(char **) p, *(char **) q));
00285 #else
00286 return (g_sort_dir * strcmp(*(char **) p, *(char **) q));
00287 #endif
00288 }
00289
00290
00291
00292
00293
00294
00295
00296
00297 int
00298 glob(const char *pattern, int flags, int(*errfunc)(char *,int), glob_t *pglob)
00299 {
00300 int err, oldpathc;
00301 Char *bufnext, *bufend, *compilebuf, m_not;
00302 const unsigned char *compilepat, *patnext;
00303 int c, nnot;
00304 Char patbuf[MAXPATHLEN + 1], *qpatnext;
00305 int no_match;
00306
00307 patnext = (unsigned char *) pattern;
00308 if (!(flags & GLOB_APPEND)) {
00309 pglob->gl_pathc = 0;
00310 pglob->gl_pathv = NULL;
00311 if (!(flags & GLOB_DOOFFS))
00312 pglob->gl_offs = 0;
00313 }
00314 pglob->gl_flags = flags & ~GLOB_MAGCHAR;
00315 pglob->gl_errfunc = errfunc;
00316 oldpathc = pglob->gl_pathc;
00317 pglob->gl_matchc = 0;
00318
00319 if (pglob->gl_flags & GLOB_ALTNOT) {
00320 nnot = ALTNOT;
00321 m_not = M_ALTNOT;
00322 }
00323 else {
00324 nnot = NOT;
00325 m_not = M_NOT;
00326 }
00327
00328 bufnext = patbuf;
00329 bufend = bufnext + MAXPATHLEN;
00330 compilebuf = bufnext;
00331 compilepat = patnext;
00332
00333 no_match = *patnext == nnot;
00334 if (no_match)
00335 patnext++;
00336
00337 if (flags & GLOB_QUOTE) {
00338
00339 while (bufnext < bufend && (c = *patnext++) != EOS)
00340 if (c == QUOTE) {
00341 if ((c = *patnext++) == EOS) {
00342 c = QUOTE;
00343 --patnext;
00344 }
00345 *bufnext++ = (Char) (c | M_PROTECT);
00346 }
00347 else
00348 *bufnext++ = (Char) c;
00349 }
00350 else
00351 while (bufnext < bufend && (c = *patnext++) != EOS)
00352 *bufnext++ = (Char) c;
00353 *bufnext = EOS;
00354
00355 bufnext = patbuf;
00356 qpatnext = patbuf;
00357
00358 while ((c = *qpatnext++) != EOS) {
00359 switch (c) {
00360 case LBRACKET:
00361 c = *qpatnext;
00362 if (c == nnot)
00363 ++qpatnext;
00364 if (*qpatnext == EOS ||
00365 Strchr(qpatnext + 1, RBRACKET) == NULL) {
00366 *bufnext++ = LBRACKET;
00367 if (c == nnot)
00368 --qpatnext;
00369 break;
00370 }
00371 pglob->gl_flags |= GLOB_MAGCHAR;
00372 *bufnext++ = M_SET;
00373 if (c == nnot)
00374 *bufnext++ = m_not;
00375 c = *qpatnext++;
00376 do {
00377 *bufnext++ = CHAR(c);
00378 if (*qpatnext == RANGE &&
00379 (c = qpatnext[1]) != RBRACKET) {
00380 *bufnext++ = M_RNG;
00381 *bufnext++ = CHAR(c);
00382 qpatnext += 2;
00383 }
00384 } while ((c = *qpatnext++) != RBRACKET);
00385 *bufnext++ = M_END;
00386 break;
00387 case QUESTION:
00388 pglob->gl_flags |= GLOB_MAGCHAR;
00389 *bufnext++ = M_ONE;
00390 break;
00391 case STAR:
00392 pglob->gl_flags |= GLOB_MAGCHAR;
00393
00394
00395
00396 if (bufnext == patbuf || bufnext[-1] != M_ALL)
00397 *bufnext++ = M_ALL;
00398 break;
00399 default:
00400 *bufnext++ = CHAR(c);
00401 break;
00402 }
00403 }
00404 *bufnext = EOS;
00405 #ifdef DEBUG
00406 qprintf(patbuf);
00407 #endif
00408
00409 if ((err = glob1(patbuf, pglob, no_match)) != 0)
00410 return (err);
00411
00412
00413
00414
00415
00416
00417
00418 if (pglob->gl_pathc == oldpathc &&
00419 ((flags & GLOB_NOCHECK) ||
00420 ((flags & GLOB_NOMAGIC) && !(pglob->gl_flags & GLOB_MAGCHAR)))) {
00421 if (!(flags & GLOB_QUOTE)) {
00422 Char *dp = compilebuf;
00423 const unsigned char *sp = compilepat;
00424
00425 while ((*dp++ = *sp++) != '\0')
00426 continue;
00427 }
00428 else {
00429
00430
00431
00432
00433 while (*compilepat != EOS) {
00434 if (*compilepat == QUOTE) {
00435 if (*++compilepat == EOS)
00436 --compilepat;
00437 }
00438 *compilebuf++ = (unsigned char) *compilepat++;
00439 }
00440 *compilebuf = EOS;
00441 }
00442 return (globextend(patbuf, pglob));
00443 }
00444 else if (!(flags & GLOB_NOSORT))
00445 qsort((char *) (pglob->gl_pathv + pglob->gl_offs + oldpathc),
00446 pglob->gl_pathc - oldpathc, sizeof(char *),
00447 (int (*) __P((const void *, const void *))) compare);
00448 return (0);
00449 }
00450
00451 static int
00452 glob1(Char *pattern, glob_t *pglob, int no_match)
00453 {
00454 Char pathbuf[MAXPATHLEN + 1];
00455
00456
00457
00458
00459 if (*pattern == EOS)
00460 return (0);
00461 return (glob2(pathbuf, pathbuf, pattern, pglob, no_match));
00462 }
00463
00464
00465
00466
00467
00468
00469 static int
00470 glob2( Char *pathbuf,Char *pathend, Char *pattern, glob_t *pglob, int no_match)
00471 {
00472 struct stat sbuf;
00473 int anymeta;
00474 Char *p, *q;
00475
00476
00477
00478
00479
00480 anymeta = 0;
00481 for (;;) {
00482 if (*pattern == EOS) {
00483 *pathend = EOS;
00484
00485 if (Lstat(pathbuf, &sbuf))
00486 return (0);
00487
00488 if (((pglob->gl_flags & GLOB_MARK) &&
00489 pathend[-1] != SEP) &&
00490 (S_ISDIR(sbuf.st_mode)
00491 #ifdef S_IFLNK
00492 || (S_ISLNK(sbuf.st_mode) &&
00493 (Stat(pathbuf, &sbuf) == 0) &&
00494 S_ISDIR(sbuf.st_mode))
00495 #endif
00496 )) {
00497 *pathend++ = SEP;
00498 *pathend = EOS;
00499 }
00500 ++pglob->gl_matchc;
00501 return (globextend(pathbuf, pglob));
00502 }
00503
00504
00505 q = pathend;
00506 p = pattern;
00507 while (*p != EOS && *p != SEP) {
00508 if (ismeta(*p))
00509 anymeta = 1;
00510 *q++ = *p++;
00511 }
00512
00513 if (!anymeta) {
00514 pathend = q;
00515 pattern = p;
00516 while (*pattern == SEP)
00517 *pathend++ = *pattern++;
00518 }
00519 else
00520 return (glob3(pathbuf, pathend, pattern, p, pglob, no_match));
00521 }
00522
00523 }
00524
00525
00526 static int
00527 glob3(Char *pathbuf, Char *pathend, Char *pattern, Char *restpattern, glob_t *pglob, int no_match)
00528 {
00529 #if 0
00530 extern int errno;
00531 #endif
00532 DIR *dirp;
00533 struct dirent *dp;
00534 int err;
00535 Char m_not = (pglob->gl_flags & GLOB_ALTNOT) ? M_ALTNOT : M_NOT;
00536 char cpathbuf[MAXPATHLEN], *ptr;
00537 #ifdef SOLARIS_DIRENT_PATCH
00538
00539 char dname[255];
00540 int ii;
00541 #endif
00542
00543 *pathend = EOS;
00544
00545 #if 0
00546 errno = 0;
00547 #endif
00548
00549 if (!(dirp = Opendir(pathbuf))) {
00550
00551 for (ptr = cpathbuf; (*ptr++ = (char) *pathbuf++) != EOS;)
00552 continue;
00553 #if 0
00554 if ((pglob->gl_errfunc && (*pglob->gl_errfunc) (cpathbuf, errno)) ||
00555 (pglob->gl_flags & GLOB_ERR))
00556 #else
00557 if ( (pglob->gl_flags & GLOB_ERR))
00558 #endif
00559 return (GLOB_ABEND);
00560 else
00561 return (0);
00562 }
00563
00564 err = 0;
00565
00566
00567 while ((dp = readdir(dirp)) != NULL) {
00568 register unsigned char *sc;
00569 register Char *dc;
00570
00571 #ifdef SOLARIS_DIRENT_PATCH
00572
00573
00574
00575
00576 #ifndef SOLARIS_DIRENT_ZERO
00577 for (ii = -2 ; dp->d_name[ii] != '\0' ; ++ii) {
00578 dname[ii+2] = dp->d_name[ii];
00579 }
00580 dname[ii+2] = '\0';
00581 #else
00582 strcpy(dname, dp->d_name);
00583 #endif
00584
00585
00586
00587
00588
00589
00590 if (dname[0] == DOT && *pattern != DOT)
00591 continue;
00592 for (sc = (unsigned char *) dname, dc = pathend;
00593 #else
00594 if (dp->d_name[0] == DOT && *pattern != DOT)
00595 continue;
00596 for (sc = (unsigned char *) dp->d_name, dc = pathend;
00597 #endif
00598 (*dc++ = *sc++) != '\0';)
00599 continue;
00600 if (match(pathend, pattern, restpattern, (int) m_not) == no_match) {
00601 *pathend = EOS;
00602 continue;
00603 }
00604 err = glob2(pathbuf, --dc, restpattern, pglob, no_match);
00605 if (err)
00606 break;
00607 }
00608
00609 (void) closedir(dirp);
00610 return (err);
00611 }
00612
00613
00614
00615
00616
00617
00618
00619
00620
00621
00622
00623
00624
00625
00626
00627
00628 static int
00629 globextend(Char *path, glob_t *pglob)
00630 {
00631 register char **pathv;
00632 register int i;
00633 unsigned int newsize;
00634 char *copy;
00635 Char *p;
00636
00637 newsize = sizeof(*pathv) * (2 + pglob->gl_pathc + pglob->gl_offs);
00638 pathv = (char **) (pglob->gl_pathv ?
00639 xrealloc((ptr_t) pglob->gl_pathv, (size_t) newsize) :
00640 xmalloc((size_t) newsize));
00641 if (pathv == NULL)
00642 return (GLOB_NOSPACE);
00643
00644 if (pglob->gl_pathv == NULL && pglob->gl_offs > 0) {
00645
00646 pathv += pglob->gl_offs;
00647 for (i = pglob->gl_offs; --i >= 0;)
00648 *--pathv = NULL;
00649 }
00650 pglob->gl_pathv = pathv;
00651
00652 for (p = path; *p++;)
00653 continue;
00654 if ((copy = (char *) xmalloc((size_t) (p - path))) != NULL) {
00655 register char *dc = copy;
00656 register Char *sc = path;
00657
00658 while ((*dc++ = *sc++) != '\0')
00659 continue;
00660 pathv[pglob->gl_offs + pglob->gl_pathc++] = copy;
00661 }
00662 pathv[pglob->gl_offs + pglob->gl_pathc] = NULL;
00663 return ((copy == NULL) ? GLOB_NOSPACE : 0);
00664 }
00665
00666
00667
00668
00669
00670
00671 static int
00672 match(Char *name, Char *pat, Char *patend, int m_not)
00673 {
00674 int ok, negate_range;
00675 Char c, k;
00676
00677 while (pat < patend) {
00678 c = *pat++;
00679 switch (c & M_MASK) {
00680 case M_ALL:
00681 if (pat == patend)
00682 return (1);
00683 do
00684 if (match(name, pat, patend, m_not))
00685 return (1);
00686 while (*name++ != EOS);
00687 return (0);
00688 case M_ONE:
00689 if (*name++ == EOS)
00690 return (0);
00691 break;
00692 case M_SET:
00693 ok = 0;
00694 if ((k = *name++) == EOS)
00695 return (0);
00696 if ((negate_range = ((*pat & M_MASK) == m_not)) != 0)
00697 ++pat;
00698 while (((c = *pat++) & M_MASK) != M_END) {
00699 if ((*pat & M_MASK) == M_RNG) {
00700 if (c <= k && k <= pat[1])
00701 ok = 1;
00702 pat += 2;
00703 }
00704 else if (c == k)
00705 ok = 1;
00706 }
00707 if (ok == negate_range)
00708 return (0);
00709 break;
00710 default:
00711 k = *name++;
00712 if (k != c)
00713 return (0);
00714 break;
00715 }
00716 }
00717 return (*name == EOS);
00718 }
00719
00720
00721 void
00722 globfree(glob_t *pglob)
00723 {
00724 register int i;
00725 register char **pp;
00726
00727 if (pglob->gl_pathv != NULL) {
00728 pp = pglob->gl_pathv + pglob->gl_offs;
00729 for (i = pglob->gl_pathc; i--; ++pp)
00730 if (*pp)
00731 xfree((ptr_t) *pp), *pp = NULL;
00732 xfree((ptr_t) pglob->gl_pathv), pglob->gl_pathv = NULL;
00733 }
00734 }
00735
00736
00737
00738
00739
00740
00741
00742
00743 int rglob_set_sort_dir( int dir )
00744 {
00745 if ( dir == 1 ) g_sort_dir = 1;
00746 else if ( dir == -1 ) g_sort_dir = -1;
00747 else return 1;
00748
00749 return 0;
00750 }
00751
00752
00753 static int warn = 0 ;
00754 void MCW_warn_expand( int www ){ warn = www; return; }
00755
00756
00757
00758
00759
00760
00761
00762
00763
00764
00765 void MCW_file_expand( int nin , char ** fin , int * nout , char *** fout )
00766 {
00767 glob_t gl ;
00768 int ii , gnum, gold , ilen ;
00769 char ** gout ;
00770 char * fn ;
00771 char prefix[4] , fpre[128] , fname[256] ;
00772 int b1,b2,b3,b4,b5 , ib,ig , lpre=0 ;
00773
00774 if( nin <= 0 ){ *nout = 0 ; return ; }
00775
00776 gnum = 0 ;
00777 gout = NULL ;
00778
00779 for( ii=0 ; ii < nin ; ii++ ){
00780 fn = fin[ii] ;
00781
00782 ig = 0 ;
00783
00784
00785
00786 if( strlen(fn) > 9 && fn[0] == '3' && fn[1] == 'D' ){
00787 ib = 0 ;
00788 prefix[ib++] = '3' ;
00789 prefix[ib++] = 'D' ;
00790 if( fn[2] == ':' ){ prefix[ib++] = '\0' ; }
00791 else { prefix[ib++] = fn[2] ; prefix[ib++] = '\0' ; }
00792
00793 ig = sscanf( fn+ib , "%d:%d:%d:%d:%d:%s" ,
00794 &b1,&b2,&b3,&b4,&b5 , fname ) ;
00795
00796
00797
00798 if( ig == 6 ){
00799 sprintf(fpre , "%s:%d:%d:%d:%d:%d:" , prefix,b1,b2,b3,b4,b5) ;
00800 lpre = strlen(fpre) ;
00801 } else {
00802 ig = 0 ;
00803 }
00804 }
00805
00806 if( strlen(fn) > 9 && fn[0] == '3' && fn[1] == 'A' && fn[3] == ':' ){
00807 ib = 0 ;
00808 prefix[ib++] = '3' ;
00809 prefix[ib++] = 'A' ;
00810 prefix[ib++] = fn[2] ;
00811 prefix[ib++] = '\0' ;
00812
00813 ig = sscanf( fn+ib , "%d:%d:%d:%s" ,
00814 &b1,&b2,&b3, fname ) ;
00815
00816
00817
00818 if( ig == 4 ){
00819 sprintf(fpre , "%s:%d:%d:%d:" , prefix,b1,b2,b3) ;
00820 lpre = strlen(fpre) ;
00821 } else {
00822 ig = 0 ;
00823 }
00824 }
00825
00826 if( ig > 0 ) (void) glob( fname , 0 , NULL , &gl ) ;
00827 else (void) glob( fn , 0 , NULL , &gl ) ;
00828
00829
00830
00831 if( gl.gl_pathc > 0 ){
00832
00833
00834 gold = gnum ;
00835 gnum += gl.gl_pathc ;
00836 if( gout == NULL ) gout = (char **) malloc ( sizeof(char *)*gnum);
00837 else gout = (char **) realloc(gout, sizeof(char *)*gnum);
00838
00839 for( ib=0 ; ib < gl.gl_pathc ; ib++ ){
00840 ilen = strlen( gl.gl_pathv[ib] ) + 1 ;
00841 if( ig > 0 ) ilen += lpre ;
00842
00843 gout[ib+gold] = (char *) malloc( sizeof(char) * ilen ) ;
00844
00845 if( ig > 0 ){
00846 strcpy( gout[ib+gold] , fpre ) ;
00847 strcat( gout[ib+gold] , gl.gl_pathv[ib] ) ;
00848 }
00849 else {
00850 strcpy( gout[ib+gold] , gl.gl_pathv[ib] ) ;
00851 }
00852 }
00853
00854 } else if( ig == 6 && strcmp(fname,"ALLZERO") == 0 ){
00855
00856 gold = gnum ; gnum++ ;
00857 if( gout == NULL ) gout = (char **) malloc ( sizeof(char *)*gnum);
00858 else gout = (char **) realloc(gout, sizeof(char *)*gnum);
00859
00860 ilen = lpre + strlen(fname) + 1 ;
00861 gout[gold] = (char *) malloc( sizeof(char) * ilen ) ;
00862 strcpy( gout[gold] , fpre ) ;
00863 strcat( gout[gold] , fname ) ;
00864
00865 } else {
00866
00867 if( warn )
00868 fprintf(stderr,"** Can't find file %s\n", (ig>0) ? fname : fn ) ;
00869 }
00870
00871 globfree( &gl ) ;
00872 }
00873
00874 *nout = gnum ; *fout = gout ; return ;
00875 }
00876
00877
00878
00879
00880
00881
00882
00883
00884
00885
00886
00887
00888
00889
00890
00891 void MCW_wildcards( char *fnam , int *nout , char ***fout )
00892 {
00893 char **fin=NULL, *fcop ;
00894 int ii , nin , lf , ls ;
00895
00896 if( fnam == NULL || *fnam == '\0' ){ *nout = 0 ; return ; }
00897 fcop = strdup(fnam) ; lf = strlen(fcop) ;
00898 ls = 1 ;
00899 for( nin=ii=0 ; ii < lf ; ii++ ){
00900 if( isspace(fcop[ii]) ){
00901 ls = 1 ;
00902 fcop[ii] = '\0' ;
00903
00904 } else {
00905
00906 if( ls ){
00907 fin = (char **) realloc( fin , sizeof(char *)*(nin+1) ) ;
00908 fin[nin++] = fcop+ii ;
00909 }
00910 ls = 0 ;
00911 }
00912 }
00913
00914 if( nin == 0 ){ *nout = 0 ; free(fcop) ; return ; }
00915
00916 MCW_file_expand( nin , fin , nout , fout ) ;
00917 free(fin) ; free(fcop) ; return ;
00918 }
00919
00920
00921
00922 void MCW_free_expand( int gnum , char ** gout )
00923 {
00924 int ii ;
00925
00926 if( gout == NULL ) return ;
00927
00928 for( ii=0 ; ii < gnum ; ii++ ) free( gout[ii] ) ;
00929 free( gout ) ;
00930 return ;
00931 }