1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
/*
* Copyright 1994 Christopher Seiwald. All rights reserved.
*
* This file is part of Jam - see jam.c for Copyright information.
*/
/*
* glob.c - match a string against a simple pattern
*
* Understands the following patterns:
*
* * any number of characters
* ? any single character
* [a-z] any single character in the range a-z
* [^a-z] any single character not in the range a-z
* \x match x
*
* External functions:
*
* glob() - match a string against a simple pattern
*
* Internal functions:
*
* globchars() - build a bitlist to check for character group match
*/
# include "jam.h"
# define CHECK_BIT( tab, bit ) ( tab[ (bit)/8 ] & (1<<( (bit)%8 )) )
# define BITLISTSIZE 16 /* bytes used for [chars] in compiled expr */
static void globchars( const char * s, const char * e, char * b );
/*
* glob() - match a string against a simple pattern.
*/
int glob( const char * c, const char * s )
{
char bitlist[ BITLISTSIZE ];
const char * here;
for ( ; ; )
switch ( *c++ )
{
case '\0':
return *s ? -1 : 0;
case '?':
if ( !*s++ )
return 1;
break;
case '[':
/* Scan for matching ]. */
here = c;
do if ( !*c++ ) return 1;
while ( ( here == c ) || ( *c != ']' ) );
++c;
/* Build character class bitlist. */
globchars( here, c, bitlist );
if ( !CHECK_BIT( bitlist, *(const unsigned char *)s ) )
return 1;
++s;
break;
case '*':
here = s;
while ( *s )
++s;
/* Try to match the rest of the pattern in a recursive */
/* call. If the match fails we'll back up chars, retrying. */
while ( s != here )
{
int r;
/* A fast path for the last token in a pattern. */
r = *c ? glob( c, s ) : *s ? -1 : 0;
if ( !r )
return 0;
if ( r < 0 )
return 1;
--s;
}
break;
case '\\':
/* Force literal match of next char. */
if ( !*c || ( *s++ != *c++ ) )
return 1;
break;
default:
if ( *s++ != c[ -1 ] )
return 1;
break;
}
}
/*
* globchars() - build a bitlist to check for character group match.
*/
static void globchars( const char * s, const char * e, char * b )
{
int neg = 0;
memset( b, '\0', BITLISTSIZE );
if ( *s == '^' )
{
++neg;
++s;
}
while ( s < e )
{
int c;
if ( ( s + 2 < e ) && ( s[1] == '-' ) )
{
for ( c = s[0]; c <= s[2]; ++c )
b[ c/8 ] |= ( 1 << ( c % 8 ) );
s += 3;
}
else
{
c = *s++;
b[ c/8 ] |= ( 1 << ( c % 8 ) );
}
}
if ( neg )
{
int i;
for ( i = 0; i < BITLISTSIZE; ++i )
b[ i ] ^= 0377;
}
/* Do not include \0 in either $[chars] or $[^chars]. */
b[0] &= 0376;
}
|
