![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to glob.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Plan 9 NeXT] / lucent / sys / src / cmd / rc|
Return to glob.c CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / cmd / rc |
1.1 root 1: #include "rc.h"
2: #include "exec.h"
3: #include "fns.h"
4: char *globname;
5: struct word *globv;
6: /*
7: * delete all the GLOB marks from s, in place
8: */
9: void deglob(char *s)
10: {
11: char *t=s;
12: do{
13: if(*t==GLOB) t++;
14: *s++=*t;
15: }while(*t++);
16: }
17: int globcmp(char **s, char **t)
18: {
19: return strcmp(*s, *t);
20: }
21: void globsort(word *left, word *right)
22: {
23: char **list;
24: word *a;
25: int n=0;
26: for(a=left;a!=right;a=a->next) n++;
27: list=(char **)emalloc(n*sizeof(char *));
28: for(a=left,n=0;a!=right;a=a->next,n++) list[n]=a->word;
29: qsort((char *)list, n, sizeof(char *), globcmp);
30: for(a=left,n=0;a!=right;a=a->next,n++) a->word=list[n];
31: efree((char *)list);
32: }
33: /*
34: * Push names prefixed by globname and suffixed by a match of p onto the astack.
35: * namep points to the end of the prefix in globname.
36: */
37: void globdir(char *p, char *namep)
38: {
39: char *t, *newp;
40: int f;
41: /* scan the pattern looking for a component with a metacharacter in it */
42: if(*p=='\0'){
43: globv=newword(globname, globv);
44: return;
45: }
46: t=namep;
47: newp=p;
48: while(*newp){
49: if(*newp==GLOB)
50: break;
51: *t=*newp++;
52: if(*t++=='/'){
53: namep=t;
54: p=newp;
55: }
56: }
57: /* If we ran out of pattern, append the name if accessible */
58: if(*newp=='\0'){
59: *t='\0';
60: if(access(globname, 0)==0)
61: globv=newword(globname, globv);
62: return;
63: }
64: /* read the directory and recur for any entry that matches */
65: *namep='\0';
66: if((f=Opendir(globname[0]?globname:"."))<0) return;
67: while(*newp!='/' && *newp!='\0') newp++;
68: while(Readdir(f, namep)){
69: if(matchfn(namep, p)){
70: for(t=namep;*t;t++);
71: globdir(newp, t);
72: }
73: }
74: Closedir(f);
75: }
76: /*
77: * Push all file names matched by p on the current thread's stack.
78: * If there are no matches, the list consists of p.
79: */
80: void glob(char *p)
81: {
82: word *svglobv=globv;
83: int globlen=Globsize(p);
84: if(!globlen){
85: deglob(p);
86: globv=newword(p, globv);
87: return;
88: }
89: globname=emalloc(globlen);
90: globname[0]='\0';
91: globdir(p, globname);
92: efree(globname);
93: if(svglobv==globv){
94: deglob(p);
95: globv=newword(p, globv);
96: }
97: else
98: globsort(globv, svglobv);
99: }
100: /*
101: * Do p and q point at equal utf codes
102: */
103: int equtf(char *p, char *q){
104: if(*p!=*q) return 0;
105: if(twobyte(*p)) return p[1]==q[1];
106: if(threebyte(*p)){
107: if(p[1]!=q[1]) return 0;
108: if(p[1]=='\0') return 1; /* broken code at end of string! */
109: return p[2]==q[2];
110: }
111: return 1;
112: }
113: /*
114: * Return a pointer to the next utf code in the string,
115: * not jumping past nuls in broken utf codes!
116: */
117: char *nextutf(char *p){
118: int u=*p&0xff;
119: if(twobyte(*p)) return p[1]=='\0'?p+1:p+2;
120: if(threebyte(*p)) return p[1]=='\0'?p+1:p[2]=='\0'?p+2:p+3;
121: return p+1;
122: }
123: /*
124: * Convert the utf code at *p to a unicode value
125: */
126: int unicode(char *p){
127: int u=*p&0xff, v;
128: if(twobyte(u)) return ((u&0x1f)<<6)|(p[1]&0x3f);
129: if(threebyte(u)) return (u<<12)|((p[1]&0x3f)<<6)|(p[2]&0x3f);
130: return u;
131: }
132: /*
133: * Does the string s match the pattern p
134: * . and .. are only matched by patterns starting with .
135: * * matches any sequence of characters
136: * ? matches any single character
137: * [...] matches the enclosed list of characters
138: */
139: int matchfn(char *s, char *p)
140: {
141: if(s[0]=='.' && (s[1]=='\0' || s[1]=='.' && s[2]=='\0') && p[0]!='.')
142: return 0;
143: return match(s, p, '/');
144: }
145: int match(char *s, char *p, int stop)
146: {
147: int compl, hit, lo, hi, t, c;
148: for(;*p!=stop && *p!='\0';s=nextutf(s),p=nextutf(p)){
149: if(*p!=GLOB){
150: if(!equtf(p, s)) return 0;
151: }
152: else switch(*++p){
153: case GLOB:
154: if(*s!=GLOB) return 0;
155: break;
156: case '*':
157: for(;;){
158: if(match(s, nextutf(p), stop)) return 1;
159: if(!*s) break;
160: s=nextutf(s);
161: }
162: return 0;
163: case '?':
164: if(*s=='\0') return 0;
165: break;
166: case '[':
167: if(*s=='\0') return 0;
168: c=unicode(s);
169: p++;
170: compl=*p=='~';
171: if(compl) p++;
172: hit=0;
173: while(*p!=']'){
174: if(*p=='\0') return 0; /* syntax error */
175: lo=unicode(p);
176: p=nextutf(p);
177: if(*p!='-') hi=lo;
178: else{
179: p++;
180: if(*p=='\0') return 0; /* syntax error */
181: hi=unicode(p);
182: p=nextutf(p);
183: if(hi<lo){ t=lo; lo=hi; hi=t; }
184: }
185: if(lo<=c && c<=hi) hit=1;
186: }
187: if(compl) hit=!hit;
188: if(!hit) return 0;
189: break;
190: }
191: }
192: return *s=='\0';
193: }
194: void globlist1(word *gl)
195: {
196: if(gl){
197: globlist1(gl->next);
198: glob(gl->word);
199: }
200: }
201: void globlist(void){
202: word *a;
203: globv=0;
204: globlist1(runq->argv->words);
205: poplist();
206: pushlist();
207: if(globv){
208: for(a=globv;a->next;a=a->next);
209: a->next=runq->argv->words;
210: runq->argv->words=globv;
211: }
212: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.