![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gcos.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / bin / make|
Return to gcos.c CVS log | Up to [CSRG BSD Unix] / 43BSD / bin / make |
1.1 root 1: static char *sccsid = "@(#)gcos.c 4.3 (Berkeley) 85/08/30";
2: /* GCOS DEPENDENT PROCEDURES */
3:
4:
5: /* DEFAULT RULES FOR GCOS */
6:
7: char *builtin[]
8: {
9: ".SUFFIXES : .d .c .y .lib",
10: ".d.c:",
11: "\t./dtgen $<",
12: ".y.c:",
13: "\t./yacc $<",
14: "\tcopy y.tab.c; /$@",
15: ".y.lib:",
16: "\t./yacc $<",
17: "\t./cc y.tab.c r=$@",
18: ".c.lib:",
19: "\t./cc $< r=$@",
20: 0 };
21:
22: # define MAXCSIZE 500
23: # define YZERO 60
24:
25: int gtcalled 0;
26:
27: /* all kinds of static declarations that must be used.. */
28:
29: static double day { 64*1000*60*60*24 }; /* length of day in clock ticks */
30:
31: struct { int lhs:18, rhs:18; };
32: struct catb {
33: int words[6],
34: name1, name2,
35: passw1, passw2,
36: word10, word11,
37: datcreat, datmod, datused,
38: stuff[6],
39: jjjj:18, tused:18;
40: };
41: struct { int :3, slot:18; }; /* slot where time from cat. block fits */
42:
43: struct catdesc {
44: int cat1, cat2, cpass1, cpass2,
45: file1, file2, filep1, filep2,
46: endmark; };
47:
48: extern int _q_reg, _a_reg;
49:
50:
51: # define A10(x,y) 10*x + y
52:
53: /* interpret the mm/dd/yy format */
54:
55: struct d9 { int :5, m1:4, :5, m2:4, :9,
56: :5, d1:4, :5, d2:4, :9,
57: :5, y1:4, :5, y2:4 ;};
58:
59: struct d6 { int :2, m61:4, :2, m62:4,
60: :2, d61:4, :2, d62:4,
61: :2, y61:4, :2, y62:4; };
62:
63: static day6( d6word ){ /* return the day number of a word in bci format */
64: int m, y, d;
65:
66: y = A10( d6word.y61, d6word.y62 );
67: m = A10( d6word.m61, d6word.m62 );
68: d = A10( d6word.d61, d6word.d62 );
69:
70: return( d + 31*( m + 12*(y-YZERO) ) );
71: }
72:
73: static day9( p ) register int *p; {
74:
75: int m, y, d;
76:
77: y = A10( p->y1, p->y2 );
78: m = A10( p->m1, p->m2 );
79: d = A10( p->d1, p->d2 );
80:
81: return( d + 31*( m + 12*(y-YZERO) ) );
82: }
83:
84:
85: static int dfold( dayno, timeno ){
86: int kk;
87: kk = ( day*dayno + timeno) / 32768.;
88: }
89:
90: int prestime(){
91: int date[2];
92: drldrl( 021, date );
93: return( dfold( day9(date), _q_reg ) );
94: }
95:
96:
97:
98: # define DODRL ar[0] = status; ar[1] = &b.cat1; drldrl(30,sp1,sp2); p=ar[0]<<18;
99:
100: static struct { int fn1, fn2; int ftm; } fbb[MAXCSIZE];
101: static int catsiz;
102:
103: getcat() {
104:
105: register i, *p, j;
106: int asname[4];
107: struct catdesc b;
108: int sp1, sp2, temp;
109: int ar[2], status[2];
110: int filbuf[380];
111:
112: gtcalled = 1;
113:
114: sp1 = ar;
115: sp1 =>> 18;
116: sp2 = filbuf;
117: sp2 =>>18;
118: sp2.lhs = 19;
119:
120: b.cat1 = b.cat2 = b.file1 = -1;
121: b.cpass1 = b.cpass2 = 0202020202020;
122:
123: DODRL
124: sp2.lhs++;
125: for( i=0; p!=0 && i<MAXCSIZE; ++i ){
126:
127: fbb[i].fn1 = b.file1 = p->name1;
128: fbb[i].fn2 = b.file2 = p->name2;
129: b.filep1 = p->passw1;
130: b.filep2 = p->passw2;
131: b.endmark = -1;
132: temp = 0;
133: temp.slot = p->tused;
134: fbb[i].ftm = dfold( day6(p->datmod), temp );
135: DODRL
136: }
137: catsiz = i;
138: }
139:
140: exists( p )
141: struct nameblock *p; {
142: char *s, *cp, name[13];
143: int i, *p, bcd[2];
144:
145: /*
146: cheat about names with slashes -- try opening;
147: if it is openable, it exists, and assume it was made
148: at t=1 (long time ago); otherwise, assume it
149: does not exist
150: */
151:
152: cp = p->namep;
153:
154: for(s=cp ; *s ; ++s)
155: if(*s == '/')
156: if(i = copen(cp,'r') < 0)
157: return(0);
158: else {
159: cclose(i);
160: return(1);
161: }
162:
163: if(gtcalled == 0) getcat();
164:
165: p = name;
166: for( i=0; *cp; ++i ) name[i] = *cp++;
167: while( i<12 ) name[i++] = ' ';
168: f9to6( *p, bcd[0], 12 );
169: for ( i=0; i<catsiz; ++i ){
170: if( fbb[i].fn1 == bcd[0] && fbb[i].fn2 == bcd[1] )
171: return( fbb[i].ftm );
172: }
173: return( 0 );
174: }
175:
176:
177: #include "defs"
178:
179: static char n13[13];
180: static char *n13end &n13[12];
181:
182:
183:
184: struct depblock *srchdir(pat, mkchain, nextdbl)
185:
186: char *pat; /* pattern to be matched in directory */
187: int mkchain; /* nonzero if results to be remembered */
188: struct depblock *nextdbl; /* final value for chain */
189: {
190: int dirf;
191: int i, nread;
192: char *dirname, *dirpref, *endir, *filepat, *p, temp[BUFSIZ];
193: char fullname[BUFSIZ], *p1, *p2, *copys();
194: struct nameblock *q;
195: struct depblock *thisdbl;
196: struct pattern *patp;
197: int *intp1, *intp2;
198:
199: if(gtcalled == 0) getcat();
200: thisdbl=0;
201:
202: if(mkchain == 0)
203: for(patp=firstpat ; patp!=0 ; patp = patp->nxtpattern)
204: if(! unequal(pat, patp->patval)) return(0);
205:
206: patp = ALLOC(pattern);
207: patp->nxtpattern = firstpat;
208: firstpat = patp;
209: patp->patval = copys(pat);
210:
211: endir = 0;
212:
213: for(p=pat; *p!='\0'; ++p)
214: if(*p=='/') endir = p;
215:
216: if(endir==0)
217: {
218: dirname = "";
219: dirpref = "";
220: filepat = pat;
221: }
222: else {
223: fatal("File name has an embedded slash");
224: dirname = pat;
225: *endir = '\0';
226: dirpref = concat(dirname, "/", temp);
227: filepat = endir+1;
228: }
229:
230: for(i=0;i<catsiz;++i)
231: {
232: intp1 = &fbb[i].fn1;
233: intp2 = n13;
234: f6to9(*intp1, *intp2, 12);
235: for(p1=n13; p1<n13end && *p1!=' ' ; ++p1)
236: if('A'<=*p1 && *p1<='Z') *p1 =+ ('a'-'A');
237: *p1 = '\0';
238:
239: if( amatch(n13,filepat) )
240: {
241: concat(dirpref,n13,fullname);
242: if( (q=srchname(fullname)) ==0)
243: q = makename(copys(fullname));
244: if(mkchain)
245: {
246: thisdbl = ALLOC(depblock);
247: thisdbl->nextp = nextdbl;
248: thisdbl->depname = q;
249: nextdbl = thisdbl;
250: }
251: }
252: }
253:
254: if(endir != 0) *endir = '/';
255:
256: return(thisdbl);
257: }
258:
259: /* stolen from glob through find */
260:
261: amatch(s, p)
262: char *s, *p;
263: {
264: register int cc, scc, k;
265: int c, lc;
266:
267: scc = *s;
268: lc = 077777;
269: switch (c = *p) {
270:
271: case '[':
272: k = 0;
273: while (cc = *++p) {
274: switch (cc) {
275:
276: case ']':
277: if (k)
278: return(amatch(++s, ++p));
279: else
280: return(0);
281:
282: case '-':
283: k =| lc <= scc & scc <= (cc=p[1]);
284: }
285: if (scc==(lc=cc)) k++;
286: }
287: return(0);
288:
289: case '?':
290: caseq:
291: if(scc) return(amatch(++s, ++p));
292: return(0);
293: case '*':
294: return(umatch(s, ++p));
295: case 0:
296: return(!scc);
297: }
298: if (c==scc) goto caseq;
299: return(0);
300: }
301:
302: umatch(s, p)
303: char *s, *p;
304: {
305: if(*p==0) return(1);
306: while(*s)
307: if (amatch(s++,p)) return(1);
308: return(0);
309: }
310:
311:
312:
313: dosys(comstring,nohalt)
314: char *comstring;
315: int nohalt;
316: {
317: char *p;
318:
319: for(p=comstring ; *p!='\0' ; ++p);
320: if( p-comstring > 80)
321: fatal("Command string longer than 80 characters");
322:
323: system(comstring);
324:
325: return(0);
326: }
327:
328:
329: touch(s)
330: char *s;
331: {
332: fprintf(stderr, "touch not yet implemented on GCOS\n");
333: cexit(2);
334: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.