/***********************************************************************
* *
* This software is part of the ast package *
* Copyright (c) 1985-2012 AT&T Intellectual Property *
* and is licensed under the *
* Eclipse Public License, Version 1.0 *
* by AT&T Intellectual Property *
* *
* A copy of the License is available at *
* (with md5 checksum b35adb5213ca9657e911e9befb180842) *
* *
* Information and Software Systems Research *
* AT&T Research *
* Florham Park NJ *
* *
* Glenn Fowler <gsf@research.att.com> *
* David Korn <dgk@research.att.com> *
* Phong Vo <kpv@research.att.com> *
* *
***********************************************************************/
#pragma prototyped
/*
* D. G. Korn
* G. S. Fowler
* AT&T Research
*
* match shell file patterns -- derived from Bourne and Korn shell gmatch()
*
* sh pattern egrep RE description
* ---------- -------- -----------
* * .* 0 or more chars
* ? . any single char
* [.] [.] char class
* [!.] [^.] negated char class
* [[:.:]] [[:.:]] ctype class
* [[=.=]] [[=.=]] equivalence class
* [[...]] [[...]] collation element
* *(.) (.)* 0 or more of
* +(.) (.)+ 1 or more of
* ?(.) (.)? 0 or 1 of
* (.) (.) 1 of
* @(.) (.) 1 of
* a|b a|b a or b
* \# () subgroup back reference [1-9]
* a&b a and b
* !(.) none of
*
* \ used to escape metacharacters
*
* *, ?, (, |, &, ), [, \ must be \'d outside of [...]
* only ] must be \'d inside [...]
*
* BUG: unbalanced ) terminates top level pattern
*/
#include <ast.h>
#include <ctype.h>
#include <hashkey.h>
#ifndef isblank
#endif
#ifndef isgraph
#endif
typedef struct
{
char* next_s;
short groups;
} Group_t;
typedef struct
{
char* last_s;
char* next_p;
} Match_t;
#define mbgetchar(p) (*p++)
#ifndef isxdigit
#endif
/*
* gobble chars up to <sub> or ) keeping track of (...) and [...]
* sub must be one of { '|', '&', 0 }
* 0 returned if s runs out
*/
static char*
{
register int p = 0;
register char* b = 0;
int c = 0;
int n;
for (;;)
switch (mbgetchar(s))
{
case '\\':
if (mbgetchar(s))
break;
/*FALLTHROUGH*/
case 0:
return 0;
case '[':
if (!b)
{
if (*s == '!' || *s == '^')
mbgetchar(s);
b = s;
}
else if (*s == '.' || *s == '=' || *s == ':')
c = *s;
break;
case ']':
if (b)
{
if (*(s - 2) == c)
c = 0;
else if (b != (s - 1))
b = 0;
}
break;
case '(':
if (!b)
{
p++;
n = (*g)++;
if (clear)
{
if (!sub)
n++;
if (n < MAXGROUP)
}
}
break;
case ')':
if (!b && p-- <= 0)
return sub ? 0 : s;
break;
case '|':
if (!b && !p && sub == '|')
return s;
break;
}
}
/*
* match a single pattern
* e is the end (0) of the substring in s
* r marks the start of a repeated subgroup pattern
*/
static int
{
register int pc;
register int sc;
register int n;
register int icase;
char* olds;
char* oldp;
do
{
olds = s;
oldp = p;
{
case '(':
case '*':
case '?':
case '+':
case '@':
case '!':
{
char* subp;
int oldg;
s = olds;
oldg = g;
n = ++g;
return 0;
{
return 1;
{
return 0;
}
}
{
p = oldp;
sc = n - 1;
}
else
sc = g;
do
{
{
if (n < MAXGROUP)
{
}
{
{
}
return 1;
}
}
} while (s < e && mbgetchar(s));
return 0;
}
else if (pc == '*')
{
/*
* several stars are the same as one
*/
while (*p == '*' && *(p + 1) != '(')
p++;
oldp = p;
{
case '@':
case '!':
case '+':
n = *p == '(';
break;
case '(':
case '[':
case '?':
case '*':
n = 1;
break;
case 0:
case '|':
case '&':
case ')':
if (!pc && (!mp->best.next_s || (flags & STR_MAXIMAL) && mp->current.next_s > mp->best.next_s || !(flags & STR_MAXIMAL) && mp->current.next_s < mp->best.next_s))
return 1;
case '\\':
return 0;
{
n = pc - '0';
}
/*FALLTHROUGH*/
default:
n = 0;
break;
}
p = oldp;
for (;;)
{
return 1;
if (!sc)
return 0;
olds = s;
}
}
return 0;
break;
case 0:
if (!(flags & STR_MAXIMAL))
sc = 0;
/*FALLTHROUGH*/
case '|':
case '&':
case ')':
if (!sc)
{
}
if (!pc && (!mp->best.next_s || (flags & STR_MAXIMAL) && olds > mp->best.next_s || !(flags & STR_MAXIMAL) && olds < mp->best.next_s))
{
}
return !sc;
case '[':
{
/*UNDENT...*/
int invert;
int x;
int ok = 0;
char* range;
if (!sc)
return 0;
range = 0;
n = 0;
p++;
for (;;)
{
oldp = p;
return 0;
{
x = 0;
n = mbgetchar(p);
oldp = p;
for (;;)
{
return 0;
if (pc == n && *p == ']')
break;
x++;
}
mbgetchar(p);
if (ok)
/*NOP*/;
else if (n == ':')
{
{
ok = 1;
break;
ok = 1;
break;
ok = 1;
break;
ok = 1;
break;
ok = 1;
break;
ok = 1;
break;
ok = 1;
break;
ok = 1;
break;
ok = 1;
break;
ok = 1;
break;
ok = 1;
break;
ok = 1;
break;
}
}
else if (range)
goto getrange;
else if (*p == '-' && *(p + 1) != ']')
{
mbgetchar(p);
}
else if (isalpha(*oldp) && isalpha(*olds) && tolower(*oldp) == tolower(*olds) || sc == mbgetchar(oldp))
ok = 1;
n = 1;
}
else if (pc == ']' && n)
{
break;
return 0;
}
return 0;
else if (ok)
/*NOP*/;
else if (range)
{
x = tolower(x);
ok = 1;
if (*p == '-' && *(p + 1) != ']')
{
mbgetchar(p);
}
else
range = 0;
n = 1;
}
else if (*p == '-' && *(p + 1) != ']')
{
mbgetchar(p);
n = 1;
}
else
{
ok = 1;
n = pc;
}
}
/*...INDENT*/
}
break;
case '\\':
return 0;
{
n = pc - '0';
{
return 0;
s = olds;
break;
}
}
/*FALLTHROUGH*/
default:
return 0;
break;
}
} while (sc);
return 0;
}
/*
* match any pattern in a group
* | and & subgroups are parsed here
*/
static int
{
register char* a;
do
{
return 1;
return 0;
}
/*
* subgroup match
* 0 returned if no match
* otherwise number of subgroups matched returned
* match group begin offsets are even elements of sub
* match group end offsets are odd elements of sub
* the matched string is from s+sub[0] up to but not
* including s+sub[1]
*/
int
{
register int i;
register char* s;
char* e;
s = (char*)b;
for (;;)
{
{
if (!i)
break;
}
return 0;
s++;
}
return 0;
if (!sub)
return 1;
s = (char*)b;
for (i = 0; i < n; i++)
{
}
return n;
}
/*
* compare the string s with the shell pattern p
* returns 1 for match 0 otherwise
*/
int
strmatch(const char* s, const char* p)
{
}