/*
****************************************************************
* Verifica se o nome do arquivo satisfaz um dos padrões *
****************************************************************
*/
int
pattern_accept (const char *file_nm)
{
const char **pp;
/*
* Agora testa os padrões de inclusão
*/
if ((pp = inc_pat)[0] != NOSTR)
{
for (/* vazio */; /* vazio */; pp++)
{
if (*pp == NOSTR)
return (0);
if (patmatch (file_nm, *pp))
break;
}
}
/*
* Finalmente testa os padrões de exclusão
*/
if ((pp = exc_pat)[0] != NOSTR)
{
for (/* vazio */; *pp != NOSTR; pp++)
{
if (patmatch (file_nm, *pp))
return (0);
}
}
return (1);
} /* end pattern_accept */
/* * Patmatch() code courtesy of Thomas Moore ([email protected]) * returns: * 1 on a match * 0 on a mismatch * -1 on a syntax error in the pattern */ int patmatch(char *buf, char *pat) { int match = 1, m, n; while(*pat && match) { switch(*pat) { case '[': pat++; if(*pat != '^') { n = 1; match = 0; } else { pat++; n = 0; } while(*pat != ']'){ if(*pat == '\\') pat++; if(!*pat /* || *pat == '/' */ ) return -1; if(pat[1] == '-'){ m = *pat; pat += 2; if(*pat == '\\' && *pat) pat++; if(*buf >= m && *buf <= *pat) match = n; if(!*pat) pat--; } else if(*buf == *pat) match = n; pat++; } buf++; break; case '*': pat++; if(!*pat) return 1; while(*buf && !(match = patmatch(buf++,pat))); return match; case '?': if(!*buf) return 0; buf++; break; case '\\': if(*pat) pat++; default: match = (*buf++ == *pat); break; } pat++; if(match<1) return match; } if(!*buf) return match; return 0; }
int main ( int argc, char *argv[] )
{
int n, m;
srand((unsigned int)time(NULL));
if (argc >= 3) {
n = atoi(argv[1]); m = atoi(argv[2]);
} else {
printf("for convinence enter n>50 n = "); scanf("%d", &n);
printf("for convinence enter m>5 m = "); scanf("%d", &m);
}
printf("\n*** String matching\n"); strmatch(n,m);
printf("\n*** Pattern matching\n"); patmatch(n,m);
exit(0);
}
int32_t
casematch(union node* pattern, const_cstring_t val)
{
struct stackmark smark;
int32_t result;
cstring_t p;
setstackmark(&smark);
argbackq = pattern->narg.backquote;
STARTSTACKSTR(expdest);
ifslastp = NULL;
argstr(pattern->narg.text, EXP_TILDE | EXP_CASE);
STPUTC('\0', expdest);
p = grabstackstr(expdest);
result = patmatch(p, val, 0);
popstackmark(&smark);
return result;
}
int
casematch(union node *pattern, const char *val)
{
struct stackmark smark;
int result;
char *p;
setstackmark(&smark);
argbackq = pattern->narg.backquote;
STARTSTACKSTR(expdest);
argstr(pattern->narg.text, EXP_TILDE | EXP_CASE, NULL);
STPUTC('\0', expdest);
p = grabstackstr(expdest);
result = patmatch(p, val);
popstackmark(&smark);
return result;
}
int
casematch(shinstance *psh, union node *pattern, char *val)
{
struct stackmark smark;
int result;
char *p;
setstackmark(psh, &smark);
psh->argbackq = pattern->narg.backquote;
STARTSTACKSTR(psh, psh->expdest);
psh->ifslastp = NULL;
argstr(psh, pattern->narg.text, EXP_TILDE | EXP_CASE);
STPUTC(psh, '\0', psh->expdest);
p = grabstackstr(psh, psh->expdest);
result = patmatch(psh, p, val, 0);
popstackmark(psh, &smark);
return result;
}
static int look_ahead(struct grep_opt *opt,
unsigned long *left_p,
unsigned *lno_p,
char **bol_p)
{
unsigned lno = *lno_p;
char *bol = *bol_p;
struct grep_pat *p;
char *sp, *last_bol;
regoff_t earliest = -1;
for (p = opt->pattern_list; p; p = p->next) {
int hit;
regmatch_t m;
hit = patmatch(p, bol, bol + *left_p, &m, 0);
if (!hit || m.rm_so < 0 || m.rm_eo < 0)
continue;
if (earliest < 0 || m.rm_so < earliest)
earliest = m.rm_so;
}
if (earliest < 0) {
*bol_p = bol + *left_p;
*left_p = 0;
return 1;
}
for (sp = bol + earliest; bol < sp && sp[-1] != '\n'; sp--)
; /* find the beginning of the line */
last_bol = sp;
for (sp = bol; sp < last_bol; sp++) {
if (*sp == '\n')
lno++;
}
*left_p -= last_bol - bol;
*bol_p = last_bol;
*lno_p = lno;
return 0;
}
static int
subevalvar(char *p, char *str, int strloc, int subtype, int startloc,
int varflags, int quotes)
{
char *startp;
char *loc = NULL;
char *q;
int c = 0;
struct nodelist *saveargbackq = argbackq;
int amount;
argstr(p, (subtype == VSTRIMLEFT || subtype == VSTRIMLEFTMAX ||
subtype == VSTRIMRIGHT || subtype == VSTRIMRIGHTMAX ?
EXP_CASE : 0) | EXP_TILDE);
STACKSTRNUL(expdest);
argbackq = saveargbackq;
startp = stackblock() + startloc;
if (str == NULL)
str = stackblock() + strloc;
switch (subtype) {
case VSASSIGN:
setvar(str, startp, 0);
amount = startp - expdest;
STADJUST(amount, expdest);
varflags &= ~VSNUL;
return 1;
case VSQUESTION:
if (*p != CTLENDVAR) {
outfmt(out2, "%s\n", startp);
error((char *)NULL);
}
error("%.*s: parameter %snot set", (int)(p - str - 1),
str, (varflags & VSNUL) ? "null or " : "");
return 0;
case VSTRIMLEFT:
for (loc = startp; loc < str; loc++) {
c = *loc;
*loc = '\0';
if (patmatch(str, startp, quotes)) {
*loc = c;
recordleft(str, loc, startp);
return 1;
}
*loc = c;
if (quotes && *loc == CTLESC)
loc++;
}
return 0;
case VSTRIMLEFTMAX:
for (loc = str - 1; loc >= startp;) {
c = *loc;
*loc = '\0';
if (patmatch(str, startp, quotes)) {
*loc = c;
recordleft(str, loc, startp);
return 1;
}
*loc = c;
loc--;
if (quotes && loc > startp && *(loc - 1) == CTLESC) {
for (q = startp; q < loc; q++)
if (*q == CTLESC)
q++;
if (q > loc)
loc--;
}
}
return 0;
case VSTRIMRIGHT:
for (loc = str - 1; loc >= startp;) {
if (patmatch(str, loc, quotes)) {
amount = loc - expdest;
STADJUST(amount, expdest);
return 1;
}
loc--;
if (quotes && loc > startp && *(loc - 1) == CTLESC) {
for (q = startp; q < loc; q++)
if (*q == CTLESC)
q++;
if (q > loc)
loc--;
}
}
return 0;
case VSTRIMRIGHTMAX:
for (loc = startp; loc < str - 1; loc++) {
if (patmatch(str, loc, quotes)) {
amount = loc - expdest;
STADJUST(amount, expdest);
return 1;
}
if (quotes && *loc == CTLESC)
loc++;
}
return 0;
default:
abort();
}
}
static void
expmeta(char *enddir, char *name)
{
const char *p;
const char *q;
const char *start;
char *endname;
int metaflag;
struct stat statb;
DIR *dirp;
struct dirent *dp;
int atend;
int matchdot;
int esc;
int namlen;
metaflag = 0;
start = name;
for (p = name; esc = 0, *p; p += esc + 1) {
if (*p == '*' || *p == '?')
metaflag = 1;
else if (*p == '[') {
q = p + 1;
if (*q == '!' || *q == '^')
q++;
for (;;) {
while (*q == CTLQUOTEMARK)
q++;
if (*q == CTLESC)
q++;
if (*q == '/' || *q == '\0')
break;
if (*++q == ']') {
metaflag = 1;
break;
}
}
} else if (*p == '\0')
break;
else if (*p == CTLQUOTEMARK)
continue;
else {
if (*p == CTLESC)
esc++;
if (p[esc] == '/') {
if (metaflag)
break;
start = p + esc + 1;
}
}
}
if (metaflag == 0) { /* we've reached the end of the file name */
if (enddir != expdir)
metaflag++;
for (p = name ; ; p++) {
if (*p == CTLQUOTEMARK)
continue;
if (*p == CTLESC)
p++;
*enddir++ = *p;
if (*p == '\0')
break;
if (enddir == expdir_end)
return;
}
if (metaflag == 0 || lstat(expdir, &statb) >= 0)
addfname(expdir);
return;
}
endname = name + (p - name);
if (start != name) {
p = name;
while (p < start) {
while (*p == CTLQUOTEMARK)
p++;
if (*p == CTLESC)
p++;
*enddir++ = *p++;
if (enddir == expdir_end)
return;
}
}
if (enddir == expdir) {
p = ".";
} else if (enddir == expdir + 1 && *expdir == '/') {
p = "/";
} else {
p = expdir;
enddir[-1] = '\0';
}
if ((dirp = opendir(p)) == NULL)
return;
if (enddir != expdir)
enddir[-1] = '/';
if (*endname == 0) {
atend = 1;
} else {
atend = 0;
*endname = '\0';
endname += esc + 1;
}
matchdot = 0;
p = start;
while (*p == CTLQUOTEMARK)
p++;
if (*p == CTLESC)
p++;
if (*p == '.')
matchdot++;
while (! int_pending() && (dp = readdir(dirp)) != NULL) {
if (dp->d_name[0] == '.' && ! matchdot)
continue;
if (patmatch(start, dp->d_name, 0)) {
namlen = dp->d_namlen;
if (enddir + namlen + 1 > expdir_end)
continue;
memcpy(enddir, dp->d_name, namlen + 1);
if (atend)
addfname(expdir);
else {
if (dp->d_type != DT_UNKNOWN &&
dp->d_type != DT_DIR &&
dp->d_type != DT_LNK)
continue;
if (enddir + namlen + 2 > expdir_end)
continue;
enddir[namlen] = '/';
enddir[namlen + 1] = '\0';
expmeta(enddir + namlen + 1, endname);
}
}
}
closedir(dirp);
if (! atend)
endname[-esc - 1] = esc ? CTLESC : '/';
}
static int match_one_pattern(struct grep_pat *p, char *bol, char *eol,
enum grep_context ctx,
regmatch_t *pmatch, int eflags)
{
int hit = 0;
int saved_ch = 0;
const char *start = bol;
if ((p->token != GREP_PATTERN) &&
((p->token == GREP_PATTERN_HEAD) != (ctx == GREP_CONTEXT_HEAD)))
return 0;
if (p->token == GREP_PATTERN_HEAD) {
const char *field;
size_t len;
assert(p->field < ARRAY_SIZE(header_field));
field = header_field[p->field].field;
len = header_field[p->field].len;
if (strncmp(bol, field, len))
return 0;
bol += len;
switch (p->field) {
case GREP_HEADER_AUTHOR:
case GREP_HEADER_COMMITTER:
saved_ch = strip_timestamp(bol, &eol);
break;
default:
break;
}
}
again:
hit = patmatch(p, bol, eol, pmatch, eflags);
if (hit && p->word_regexp) {
if ((pmatch[0].rm_so < 0) ||
(eol - bol) < pmatch[0].rm_so ||
(pmatch[0].rm_eo < 0) ||
(eol - bol) < pmatch[0].rm_eo)
die("regexp returned nonsense");
/* Match beginning must be either beginning of the
* line, or at word boundary (i.e. the last char must
* not be a word char). Similarly, match end must be
* either end of the line, or at word boundary
* (i.e. the next char must not be a word char).
*/
if ( ((pmatch[0].rm_so == 0) ||
!word_char(bol[pmatch[0].rm_so-1])) &&
((pmatch[0].rm_eo == (eol-bol)) ||
!word_char(bol[pmatch[0].rm_eo])) )
;
else
hit = 0;
/* Words consist of at least one character. */
if (pmatch->rm_so == pmatch->rm_eo)
hit = 0;
if (!hit && pmatch[0].rm_so + bol + 1 < eol) {
/* There could be more than one match on the
* line, and the first match might not be
* strict word match. But later ones could be!
* Forward to the next possible start, i.e. the
* next position following a non-word char.
*/
bol = pmatch[0].rm_so + bol + 1;
while (word_char(bol[-1]) && bol < eol)
bol++;
eflags |= REG_NOTBOL;
if (bol < eol)
goto again;
}
}
if (p->token == GREP_PATTERN_HEAD && saved_ch)
*eol = saved_ch;
if (hit) {
pmatch[0].rm_so += bol - start;
pmatch[0].rm_eo += bol - start;
}
return hit;
}
STATIC int
subevalvar(shinstance *psh, char *p, char *str, int strloc, int subtype, int startloc, int varflags)
{
char *startp;
char *loc = NULL;
char *q;
int c = 0;
int saveherefd = psh->herefd;
struct nodelist *saveargbackq = psh->argbackq;
int amount;
psh->herefd = -1;
argstr(psh, p, 0);
STACKSTRNUL(psh, psh->expdest);
psh->herefd = saveherefd;
psh->argbackq = saveargbackq;
startp = stackblock(psh) + startloc;
if (str == NULL)
str = stackblock(psh) + strloc;
switch (subtype) {
case VSASSIGN:
setvar(psh, str, startp, 0);
amount = (int)(startp - psh->expdest);
STADJUST(psh, amount, psh->expdest);
varflags &= ~VSNUL;
if (c != 0)
*loc = c;
return 1;
case VSQUESTION:
if (*p != CTLENDVAR) {
outfmt(&psh->errout, "%s\n", startp);
error(psh, (char *)NULL);
}
error(psh, "%.*s: parameter %snot set", p - str - 1,
str, (varflags & VSNUL) ? "null or "
: nullstr);
/* NOTREACHED */
case VSTRIMLEFT:
for (loc = startp; loc < str; loc++) {
c = *loc;
*loc = '\0';
if (patmatch(psh, str, startp, varflags & VSQUOTE))
goto recordleft;
*loc = c;
if ((varflags & VSQUOTE) && *loc == CTLESC)
loc++;
}
return 0;
case VSTRIMLEFTMAX:
for (loc = str - 1; loc >= startp;) {
c = *loc;
*loc = '\0';
if (patmatch(psh, str, startp, varflags & VSQUOTE))
goto recordleft;
*loc = c;
loc--;
if ((varflags & VSQUOTE) && loc > startp &&
*(loc - 1) == CTLESC) {
for (q = startp; q < loc; q++)
if (*q == CTLESC)
q++;
if (q > loc)
loc--;
}
}
return 0;
case VSTRIMRIGHT:
for (loc = str - 1; loc >= startp;) {
if (patmatch(psh, str, loc, varflags & VSQUOTE))
goto recordright;
loc--;
if ((varflags & VSQUOTE) && loc > startp &&
*(loc - 1) == CTLESC) {
for (q = startp; q < loc; q++)
if (*q == CTLESC)
q++;
if (q > loc)
loc--;
}
}
return 0;
case VSTRIMRIGHTMAX:
for (loc = startp; loc < str - 1; loc++) {
if (patmatch(psh, str, loc, varflags & VSQUOTE))
goto recordright;
if ((varflags & VSQUOTE) && *loc == CTLESC)
loc++;
}
return 0;
default:
sh_abort(psh);
}
recordleft:
*loc = c;
amount = (int)(((str - 1) - (loc - startp)) - psh->expdest);
STADJUST(psh, amount, psh->expdest);
while (loc != str - 1)
*startp++ = *loc++;
return 1;
recordright:
amount = (int)(loc - psh->expdest);
STADJUST(psh, amount, psh->expdest);
STPUTC(psh, '\0', psh->expdest);
STADJUST(psh, -1, psh->expdest);
return 1;
}
STATIC void
expmeta(shinstance *psh, char *enddir, char *name)
{
char *p;
const char *cp;
char *q;
char *start;
char *endname;
int metaflag;
struct stat statb;
shdir *dirp;
shdirent *dp;
int atend;
int matchdot;
metaflag = 0;
start = name;
for (p = name ; ; p++) {
if (*p == '*' || *p == '?')
metaflag = 1;
else if (*p == '[') {
q = p + 1;
if (*q == '!')
q++;
for (;;) {
while (*q == CTLQUOTEMARK)
q++;
if (*q == CTLESC)
q++;
if (*q == '/' || *q == '\0')
break;
if (*++q == ']') {
metaflag = 1;
break;
}
}
} else if (*p == '!' && p[1] == '!' && (p == name || p[-1] == '/')) {
metaflag = 1;
} else if (*p == '\0')
break;
else if (*p == CTLQUOTEMARK)
continue;
else if (*p == CTLESC)
p++;
if (*p == '/') {
if (metaflag)
break;
start = p + 1;
}
}
if (metaflag == 0) { /* we've reached the end of the file name */
if (enddir != psh->expdir)
metaflag++;
for (p = name ; ; p++) {
if (*p == CTLQUOTEMARK)
continue;
if (*p == CTLESC)
p++;
*enddir++ = *p;
if (*p == '\0')
break;
}
if (metaflag == 0 || shfile_lstat(&psh->fdtab, psh->expdir, &statb) >= 0)
addfname(psh, psh->expdir);
TRACE2((psh, "expandarg: return #1 (metaflag=%d)\n", metaflag));
return;
}
endname = p;
if (start != name) {
p = name;
while (p < start) {
while (*p == CTLQUOTEMARK)
p++;
if (*p == CTLESC)
p++;
*enddir++ = *p++;
}
}
if (enddir == psh->expdir) {
cp = ".";
} else if (enddir == psh->expdir + 1 && *psh->expdir == '/') {
cp = "/";
} else {
cp = psh->expdir;
enddir[-1] = '\0';
}
if ((dirp = shfile_opendir(&psh->fdtab, cp)) == NULL) {
TRACE2((psh, "expandarg: return #2 (shfile_opendir(,%s) failed)\n", cp));
return;
}
if (enddir != psh->expdir)
enddir[-1] = '/';
if (*endname == 0) {
atend = 1;
} else {
atend = 0;
*endname++ = '\0';
}
matchdot = 0;
p = start;
while (*p == CTLQUOTEMARK)
p++;
if (*p == CTLESC)
p++;
if (*p == '.')
matchdot++;
while (! int_pending() && (dp = shfile_readdir(dirp)) != NULL) {
if (dp->name[0] == '.' && ! matchdot)
continue;
if (patmatch(psh, start, dp->name, 0)) {
if (atend) {
scopy(dp->name, enddir);
addfname(psh, psh->expdir);
} else {
for (p = enddir, cp = dp->name;
(*p++ = *cp++) != '\0';)
continue;
p[-1] = '/';
expmeta(psh, p, endname);
}
}
}
shfile_closedir(dirp);
if (! atend)
endname[-1] = '/';
}
/*******************************************************************************
Handle all the built-in string functions (PATMATCH INDEXSTR STRLEN SUBSTR
LOOKUP)
*******************************************************************************/
int
strfunc(Exprnode *exprptr)
{
Exprnode result1, result2, result3;
char *chptr;
int len, newlen;
/* all functions have a first argument */
result1 = *(exprptr->leftptr); evalexpr(&result1);
switch (exprptr->arg.strfnc.functyp) {
case PATMATCH:
result2 = *(exprptr->rightptr); evalexpr(&result2);
if ((result1.typ != STRING) || (result2.typ != STRING))
fatalerrlin("patmatch: both arguments must be strings");
exprptr->arg.ival = patmatch(&result1, &result2);
exprptr->typ = INTEGER;
break;
case STRLEN:
if (result1.typ != STRING)
fatalerrlin("strlen: argument must be a string");
exprptr->arg.ival = strlen(result1.arg.sval);
exprptr->typ = INTEGER;
break;
case INDEXSTR:
result2 = *(exprptr->rightptr); evalexpr(&result2);
if ((result1.typ != STRING) || (result2.typ != STRING))
fatalerrlin("indexstr: both arguments must be strings");
if ((chptr=strstr(result2.arg.sval, result1.arg.sval)) == NULL) {
exprptr->arg.ival = 0;
} else {
exprptr->arg.ival = chptr - result2.arg.sval + 1;
}
exprptr->typ = INTEGER;
break;
case SUBSTR:
if (result1.typ != STRING)
fatalerrlin("substr: first argument must be a string");
result2 = *(exprptr->rightptr); evalexpr(&result2);
result3 = *(exprptr->arg.strfnc.expr3ptr); evalexpr(&result3);
if (result2.typ != INTEGER || result3.typ != INTEGER)
fatalerrlin("substr: 2nd and 3rd arguments must be integers");
len = strlen(result1.arg.sval);
if (result2.arg.ival < 1 || result2.arg.ival > len) {
fprintf(stderr, "substr: bad index %d", result2.arg.ival);
fatalerrlin("");
}
if (result3.arg.ival < 1) {
fprintf(stderr, "substr: bad length %d", result3.arg.ival);
fatalerrlin("");
}
newlen = MIN(len-result2.arg.ival+1, result3.arg.ival);
chptr = (char*)malloc((size_t)(newlen+1));
strncpy(chptr, result1.arg.sval+result2.arg.ival-1, newlen);
*(chptr+newlen) = '\0';
exprptr->arg.sval = chptr;
exprptr->typ = STRING;
break;
case LOOKUP:
if (result1.typ != STRING)
fatalerrlin("lookup: first argument must be a string");
/* second argument */
result2 = *(exprptr->rightptr); evalexpr(&result2);
if (result2.typ != STRING)
fatalerrlin("lookup: second argument must be a string");
/* optional 3rd arg */
if (exprptr->arg.strfnc.expr3ptr == NULL) {
result3.arg.ival = 2;
} else {
result3 = *(exprptr->arg.strfnc.expr3ptr);
evalexpr(&result3);
if (result3.typ != INTEGER)
fatalerrlin("lookup: third argument must be an integer");
}
exprptr->arg.sval = dolookup(result1.arg.sval, result2.arg.sval,
result3.arg.ival);
exprptr->typ = STRING;
break;
default: fatalerror("strfunc: hit default");
break;
}
}
STATIC int
subevalvar(char *p, char *str, int strloc, int subtype, int startloc, int varflags)
{
char *startp;
char *loc = NULL;
char *q;
int c = 0;
int saveherefd = herefd;
struct nodelist *saveargbackq = argbackq;
int amount, how;
herefd = -1;
switch (subtype) {
case VSTRIMLEFT:
case VSTRIMLEFTMAX:
case VSTRIMRIGHT:
case VSTRIMRIGHTMAX:
how = (varflags & VSQUOTE) ? 0 : EXP_CASE;
break;
default:
how = 0;
break;
}
argstr(p, how);
STACKSTRNUL(expdest);
herefd = saveherefd;
argbackq = saveargbackq;
startp = stackblock() + startloc;
if (str == NULL)
str = stackblock() + strloc;
switch (subtype) {
case VSASSIGN:
setvar(str, startp, 0);
amount = startp - expdest;
STADJUST(amount, expdest);
varflags &= ~VSNUL;
return 1;
case VSQUESTION:
if (*p != CTLENDVAR) {
outfmt(&errout, "%s\n", startp);
error(NULL);
}
error("%.*s: parameter %snot set",
(int)(p - str - 1),
str, (varflags & VSNUL) ? "null or "
: nullstr);
/* NOTREACHED */
case VSTRIMLEFT:
for (loc = startp; loc < str; loc++) {
c = *loc;
*loc = '\0';
if (patmatch(str, startp, varflags & VSQUOTE))
goto recordleft;
*loc = c;
if ((varflags & VSQUOTE) && *loc == CTLESC)
loc++;
}
return 0;
case VSTRIMLEFTMAX:
for (loc = str - 1; loc >= startp;) {
c = *loc;
*loc = '\0';
if (patmatch(str, startp, varflags & VSQUOTE))
goto recordleft;
*loc = c;
loc--;
if ((varflags & VSQUOTE) && loc > startp &&
*(loc - 1) == CTLESC) {
for (q = startp; q < loc; q++)
if (*q == CTLESC)
q++;
if (q > loc)
loc--;
}
}
return 0;
case VSTRIMRIGHT:
for (loc = str - 1; loc >= startp;) {
if (patmatch(str, loc, varflags & VSQUOTE))
goto recordright;
loc--;
if ((varflags & VSQUOTE) && loc > startp &&
*(loc - 1) == CTLESC) {
for (q = startp; q < loc; q++)
if (*q == CTLESC)
q++;
if (q > loc)
loc--;
}
}
return 0;
case VSTRIMRIGHTMAX:
for (loc = startp; loc < str - 1; loc++) {
if (patmatch(str, loc, varflags & VSQUOTE))
goto recordright;
if ((varflags & VSQUOTE) && *loc == CTLESC)
loc++;
}
return 0;
default:
abort();
}
recordleft:
*loc = c;
amount = ((str - 1) - (loc - startp)) - expdest;
STADJUST(amount, expdest);
while (loc != str - 1)
*startp++ = *loc++;
return 1;
recordright:
amount = loc - expdest;
STADJUST(amount, expdest);
STPUTC('\0', expdest);
STADJUST(-1, expdest);
return 1;
}
STATIC void
expmeta(char *enddir, char *name)
{
char *p;
const char *cp;
char *q;
char *start;
char *endname;
int metaflag;
struct stat statb;
DIR *dirp;
struct dirent *dp;
int atend;
int matchdot;
metaflag = 0;
start = name;
for (p = name ; ; p++) {
if (*p == '*' || *p == '?')
metaflag = 1;
else if (*p == '[') {
q = p + 1;
if (*q == '!')
q++;
for (;;) {
while (*q == CTLQUOTEMARK)
q++;
if (*q == CTLESC)
q++;
if (*q == '/' || *q == '\0')
break;
if (*++q == ']') {
metaflag = 1;
break;
}
}
} else if (*p == '!' && p[1] == '!' && (p == name || p[-1] == '/')) {
metaflag = 1;
} else if (*p == '\0')
break;
else if (*p == CTLQUOTEMARK)
continue;
else if (*p == CTLESC)
p++;
if (*p == '/') {
if (metaflag)
break;
start = p + 1;
}
}
if (metaflag == 0) { /* we've reached the end of the file name */
if (enddir != expdir)
metaflag++;
for (p = name ; ; p++) {
if (*p == CTLQUOTEMARK)
continue;
if (*p == CTLESC)
p++;
*enddir++ = *p;
if (*p == '\0')
break;
}
if (metaflag == 0 || lstat(expdir, &statb) >= 0)
addfname(expdir);
return;
}
endname = p;
if (start != name) {
p = name;
while (p < start) {
while (*p == CTLQUOTEMARK)
p++;
if (*p == CTLESC)
p++;
*enddir++ = *p++;
}
}
if (enddir == expdir) {
cp = ".";
} else if (enddir == expdir + 1 && *expdir == '/') {
cp = "/";
} else {
cp = expdir;
enddir[-1] = '\0';
}
if ((dirp = opendir(cp)) == NULL)
return;
if (enddir != expdir)
enddir[-1] = '/';
if (*endname == 0) {
atend = 1;
} else {
atend = 0;
*endname++ = '\0';
}
matchdot = 0;
p = start;
while (*p == CTLQUOTEMARK)
p++;
if (*p == CTLESC)
p++;
if (*p == '.')
matchdot++;
while (! int_pending() && (dp = readdir(dirp)) != NULL) {
if (dp->d_name[0] == '.' && ! matchdot)
continue;
if (patmatch(start, dp->d_name, 0)) {
if (atend) {
scopy(dp->d_name, enddir);
addfname(expdir);
} else {
for (p = enddir, cp = dp->d_name;
(*p++ = *cp++) != '\0';)
continue;
p[-1] = '/';
expmeta(p, endname);
}
}
}
closedir(dirp);
if (! atend)
endname[-1] = '/';
}
static int32_t
subevalvar(cstring_t p, cstring_t str, size_t strloc, uint32_t subtype, size_t startloc,
uint32_t varflags, uint32_t quotes)
{
cstring_t startp;
cstring_t loc = NULL;
cstring_t q;
char32_t c = 0;
struct nodelist* saveargbackq = argbackq;
size_t amount;
argstr(p, (subtype == VSTRIMLEFT || subtype == VSTRIMLEFTMAX ||
subtype == VSTRIMRIGHT || subtype == VSTRIMRIGHTMAX ?
EXP_CASE : 0) | EXP_TILDE);
STACKSTRNUL(expdest);
argbackq = saveargbackq;
startp = stackblock() + startloc;
if (str == NULL)
str = stackblock() + strloc;
switch (subtype)
{
case VSASSIGN:
setvar(str, startp, 0);
amount = startp - expdest;
STADJUST(amount, expdest);
varflags &= ~VSNUL;
return 1;
case VSQUESTION:
if (*p != CTLENDVAR)
{
outfmt(out2, "%s\n", startp);
sherror((cstring_t)NULL);
}
sherror("%.*s: parameter %snot set", (int32_t)(p - str - 1),
str, (varflags & VSNUL) ? "null or "
: nullstr);
NOTREACHED;
case VSTRIMLEFT:
for (loc = startp; loc < str; loc++)
{
c = *loc;
*loc = '\0';
if (patmatch(str, startp, quotes))
{
*loc = (cchar_t)c;
goto recordleft;
}
*loc = (cchar_t)c;
if (quotes && *loc == CTLESC)
loc++;
}
return 0;
case VSTRIMLEFTMAX:
for (loc = str - 1; loc >= startp;)
{
c = *loc;
*loc = '\0';
if (patmatch(str, startp, quotes))
{
*loc = (cchar_t)c;
goto recordleft;
}
*loc = (cchar_t)c;
loc--;
if (quotes && loc > startp && *(loc - 1) == CTLESC)
{
for (q = startp; q < loc; q++)
if (*q == CTLESC)
q++;
if (q > loc)
loc--;
}
}
return 0;
case VSTRIMRIGHT:
for (loc = str - 1; loc >= startp;)
{
if (patmatch(str, loc, quotes))
{
amount = loc - expdest;
STADJUST(amount, expdest);
return 1;
}
loc--;
if (quotes && loc > startp && *(loc - 1) == CTLESC)
{
for (q = startp; q < loc; q++)
if (*q == CTLESC)
q++;
if (q > loc)
loc--;
}
}
return 0;
case VSTRIMRIGHTMAX:
for (loc = startp; loc < str - 1; loc++)
{
if (patmatch(str, loc, quotes))
{
amount = loc - expdest;
STADJUST(amount, expdest);
return 1;
}
if (quotes && *loc == CTLESC)
loc++;
}
return 0;
default:
abort();
}
recordleft:
amount = ((str - 1) - (loc - startp)) - expdest;
STADJUST(amount, expdest);
while (loc != str - 1)
*startp++ = *loc++;
return 1;
}
static void
subevalvar_trim(char *p, int strloc, int subtype, int startloc)
{
char *startp;
char *loc = NULL;
char *str;
int c = 0;
struct nodelist *saveargbackq = argbackq;
int amount;
argstr(p, EXP_CASE | EXP_TILDE, NULL);
STACKSTRNUL(expdest);
argbackq = saveargbackq;
startp = stackblock() + startloc;
str = stackblock() + strloc;
switch (subtype) {
case VSTRIMLEFT:
for (loc = startp; loc < str; loc++) {
c = *loc;
*loc = '\0';
if (patmatch(str, startp)) {
*loc = c;
recordleft(str, loc, startp);
return;
}
*loc = c;
}
break;
case VSTRIMLEFTMAX:
for (loc = str - 1; loc >= startp;) {
c = *loc;
*loc = '\0';
if (patmatch(str, startp)) {
*loc = c;
recordleft(str, loc, startp);
return;
}
*loc = c;
loc--;
}
break;
case VSTRIMRIGHT:
for (loc = str - 1; loc >= startp;) {
if (patmatch(str, loc)) {
amount = loc - expdest;
STADJUST(amount, expdest);
return;
}
loc--;
}
break;
case VSTRIMRIGHTMAX:
for (loc = startp; loc < str - 1; loc++) {
if (patmatch(str, loc)) {
amount = loc - expdest;
STADJUST(amount, expdest);
return;
}
}
break;
default:
abort();
}
amount = (expdest - stackblock() - strloc) + 1;
STADJUST(-amount, expdest);
}
/* * Patmatch() code courtesy of Thomas Moore ([email protected]) * '|' support added by David MacMahon ([email protected]) * Case insensitive support added by Jason A. Donenfeld ([email protected]) * returns: * 1 on a match * 0 on a mismatch * -1 on a syntax error in the pattern */ int patmatch(char *buf, char *pat) { int match = 1,m,n; char *bar = strchr(pat, '|'); /* If a bar is found, call patmatch recursively on the two sub-patterns */ if (bar) { /* If the bar is the first or last character, it's a syntax error */ if (bar == pat || !bar[1]) { return -1; } /* Break pattern into two sub-patterns */ *bar = '\0'; match = patmatch(buf, pat); if (!match) { match = patmatch(buf,bar+1); } /* Join sub-patterns back into one pattern */ *bar = '|'; return match; } while(*pat && match) { switch(*pat) { case '[': pat++; if(*pat != '^') { n = 1; match = 0; } else { pat++; n = 0; } while(*pat != ']'){ if(*pat == '\\') pat++; if(!*pat /* || *pat == '/' */ ) return -1; if(pat[1] == '-'){ m = *pat; pat += 2; if(*pat == '\\' && *pat) pat++; if(cond_lower(*buf) >= cond_lower(m) && cond_lower(*buf) <= cond_lower(*pat)) match = n; if(!*pat) pat--; } else if(cond_lower(*buf) == cond_lower(*pat)) match = n; pat++; } buf++; break; case '*': pat++; if(!*pat) return 1; while(*buf && !(match = patmatch(buf++,pat))); return match; case '?': if(!*buf) return 0; buf++; break; case '\\': if(*pat) pat++; default: match = (cond_lower(*buf++) == cond_lower(*pat)); break; } pat++; if(match<1) return match; } if(!*buf) return match; return 0; }
