2016-11-25 17:18:40 +01:00
|
|
|
/*
|
|
|
|
* This file is part of the UCB release of Plan 9. It is subject to the license
|
|
|
|
* terms in the LICENSE file found in the top-level directory of this
|
|
|
|
* distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
|
|
|
|
* part of the UCB release of Plan 9, including this file, may be copied,
|
|
|
|
* modified, propagated, or distributed except according to the terms contained
|
|
|
|
* in the LICENSE file.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "rc.h"
|
|
|
|
#include "exec.h"
|
|
|
|
#include "fns.h"
|
|
|
|
char *globname;
|
|
|
|
struct word *globv;
|
|
|
|
/*
|
|
|
|
* delete all the GLOB marks from s, in place
|
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
|
|
|
deglob(void *as)
|
|
|
|
{
|
|
|
|
char *s = as;
|
|
|
|
char *t = s;
|
|
|
|
do{
|
|
|
|
if(*t==GLOB)
|
|
|
|
t++;
|
|
|
|
*s++=*t;
|
|
|
|
}while(*t++);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
globcmp(const void *s, const void *t)
|
|
|
|
{
|
|
|
|
return strcmp(*(char**)s, *(char**)t);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
globsort(word *left, word *right)
|
|
|
|
{
|
|
|
|
char **list;
|
|
|
|
word *a;
|
|
|
|
int n = 0;
|
|
|
|
for(a = left;a!=right;a = a->next) n++;
|
|
|
|
list = (char **)emalloc(n*sizeof(char *));
|
|
|
|
for(a = left,n = 0;a!=right;a = a->next,n++) list[n] = a->word;
|
|
|
|
qsort((void *)list, n, sizeof(void *), globcmp);
|
|
|
|
for(a = left,n = 0;a!=right;a = a->next,n++) a->word = list[n];
|
|
|
|
efree((char *)list);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Push names prefixed by globname and suffixed by a match of p onto the astack.
|
|
|
|
* namep points to the end of the prefix in globname.
|
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
|
|
|
globdir(uint8_t *p, uint8_t *namep)
|
|
|
|
{
|
|
|
|
uint8_t *t, *newp;
|
|
|
|
int f;
|
|
|
|
/* scan the pattern looking for a component with a metacharacter in it */
|
|
|
|
if(*p=='\0'){
|
|
|
|
globv = newword(globname, globv);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
t = namep;
|
|
|
|
newp = p;
|
|
|
|
while(*newp){
|
|
|
|
if(*newp==GLOB)
|
|
|
|
break;
|
|
|
|
*t=*newp++;
|
|
|
|
if(*t++=='/'){
|
|
|
|
namep = t;
|
|
|
|
p = newp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* If we ran out of pattern, append the name if accessible */
|
|
|
|
if(*newp=='\0'){
|
|
|
|
*t='\0';
|
2016-12-01 00:09:42 +01:00
|
|
|
if(access(globname, AEXIST)==0)
|
2016-11-25 17:18:40 +01:00
|
|
|
globv = newword(globname, globv);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* read the directory and recur for any entry that matches */
|
|
|
|
*namep='\0';
|
|
|
|
if((f = Opendir(globname[0]?globname:"."))<0) return;
|
|
|
|
while(*newp!='/' && *newp!='\0') newp++;
|
|
|
|
while(Readdir(f, namep, *newp=='/')){
|
|
|
|
if(matchfn(namep, p)){
|
|
|
|
for(t = namep;*t;t++);
|
|
|
|
globdir(newp, t);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Closedir(f);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Push all file names matched by p on the current thread's stack.
|
|
|
|
* If there are no matches, the list consists of p.
|
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
|
|
|
glob(void *ap)
|
|
|
|
{
|
|
|
|
uint8_t *p = ap;
|
|
|
|
word *svglobv = globv;
|
|
|
|
int globlen = Globsize(ap);
|
|
|
|
|
|
|
|
if(!globlen){
|
|
|
|
deglob(p);
|
|
|
|
globv = newword((char *)p, globv);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
globname = emalloc(globlen);
|
|
|
|
globname[0]='\0';
|
|
|
|
globdir(p, (uint8_t *)globname);
|
|
|
|
efree(globname);
|
|
|
|
if(svglobv==globv){
|
|
|
|
deglob(p);
|
|
|
|
globv = newword((char *)p, globv);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
globsort(globv, svglobv);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do p and q point at equal utf codes
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
equtf(uint8_t *p, uint8_t *q)
|
|
|
|
{
|
|
|
|
Rune pr, qr;
|
|
|
|
if(*p!=*q)
|
|
|
|
return 0;
|
2016-12-01 00:09:42 +01:00
|
|
|
|
2016-11-25 17:18:40 +01:00
|
|
|
chartorune(&pr, (char*)p);
|
|
|
|
chartorune(&qr, (char*)q);
|
|
|
|
return pr == qr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return a pointer to the next utf code in the string,
|
|
|
|
* not jumping past nuls in broken utf codes!
|
|
|
|
*/
|
|
|
|
|
|
|
|
uint8_t*
|
|
|
|
nextutf(uint8_t *p)
|
|
|
|
{
|
|
|
|
Rune dummy;
|
|
|
|
return p + chartorune(&dummy, (char*)p);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert the utf code at *p to a unicode value
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
|
|
|
unicode(uint8_t *p)
|
|
|
|
{
|
|
|
|
Rune r;
|
|
|
|
|
|
|
|
chartorune(&r, (char*)p);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Does the string s match the pattern p
|
|
|
|
* . and .. are only matched by patterns starting with .
|
|
|
|
* * matches any sequence of characters
|
|
|
|
* ? matches any single character
|
|
|
|
* [...] matches the enclosed list of characters
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
|
|
|
matchfn(void *as, void *ap)
|
|
|
|
{
|
|
|
|
uint8_t *s = as, *p = ap;
|
|
|
|
|
|
|
|
if(s[0]=='.' && (s[1]=='\0' || s[1]=='.' && s[2]=='\0') && p[0]!='.')
|
|
|
|
return 0;
|
|
|
|
return match(s, p, '/');
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
match(void *as, void *ap, int stop)
|
|
|
|
{
|
|
|
|
int compl, hit, lo, hi, t, c;
|
|
|
|
uint8_t *s = as, *p = ap;
|
|
|
|
|
|
|
|
for(; *p!=stop && *p!='\0'; s = nextutf(s), p = nextutf(p)){
|
|
|
|
if(*p!=GLOB){
|
|
|
|
if(!equtf(p, s)) return 0;
|
|
|
|
}
|
|
|
|
else switch(*++p){
|
|
|
|
case GLOB:
|
|
|
|
if(*s!=GLOB)
|
|
|
|
return 0;
|
|
|
|
break;
|
|
|
|
case '*':
|
|
|
|
for(;;){
|
|
|
|
if(match(s, nextutf(p), stop)) return 1;
|
|
|
|
if(!*s)
|
|
|
|
break;
|
|
|
|
s = nextutf(s);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
case '?':
|
|
|
|
if(*s=='\0')
|
|
|
|
return 0;
|
|
|
|
break;
|
|
|
|
case '[':
|
|
|
|
if(*s=='\0')
|
|
|
|
return 0;
|
|
|
|
c = unicode(s);
|
|
|
|
p++;
|
|
|
|
compl=*p=='~';
|
|
|
|
if(compl)
|
|
|
|
p++;
|
|
|
|
hit = 0;
|
|
|
|
while(*p!=']'){
|
|
|
|
if(*p=='\0')
|
|
|
|
return 0; /* syntax error */
|
|
|
|
lo = unicode(p);
|
|
|
|
p = nextutf(p);
|
|
|
|
if(*p!='-')
|
|
|
|
hi = lo;
|
|
|
|
else{
|
|
|
|
p++;
|
|
|
|
if(*p=='\0')
|
|
|
|
return 0; /* syntax error */
|
|
|
|
hi = unicode(p);
|
|
|
|
p = nextutf(p);
|
|
|
|
if(hi<lo){ t = lo; lo = hi; hi = t; }
|
|
|
|
}
|
|
|
|
if(lo<=c && c<=hi)
|
|
|
|
hit = 1;
|
|
|
|
}
|
|
|
|
if(compl)
|
|
|
|
hit=!hit;
|
|
|
|
if(!hit)
|
|
|
|
return 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return *s=='\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
globlist1(word *gl)
|
|
|
|
{
|
|
|
|
if(gl){
|
|
|
|
globlist1(gl->next);
|
|
|
|
glob(gl->word);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
globlist(void)
|
|
|
|
{
|
|
|
|
word *a;
|
|
|
|
globv = 0;
|
|
|
|
globlist1(runq->argv->words);
|
|
|
|
poplist();
|
|
|
|
pushlist();
|
|
|
|
if(globv){
|
|
|
|
for(a = globv;a->next;a = a->next);
|
|
|
|
a->next = runq->argv->words;
|
|
|
|
runq->argv->words = globv;
|
|
|
|
}
|
|
|
|
}
|