[unix-history] / usr / src / old / make / gcos.c

static	char *sccsid = "@(#)gcos.c	4.4 (Berkeley) 87/12/04";
/* GCOS DEPENDENT PROCEDURES */


/* DEFAULT RULES FOR GCOS */

char *builtin[]
	{
	".SUFFIXES : .d .c .y .lib",
	".d.c:",
	"\t./dtgen $<",
	".y.c:",
	"\t./yacc $<",
	"\tcopy y.tab.c; /$@",
	".y.lib:",
	"\t./yacc $<",
	"\t./cc y.tab.c r=$@",
	".c.lib:",
	"\t./cc $< r=$@",
	0 };
\f
# define MAXCSIZE 500
# define YZERO 60

int gtcalled 0;

/* all kinds of static declarations that must be used.. */

static double day { 64*1000*60*60*24 };  /* length of day in clock ticks */

struct { int lhs:18, rhs:18; };
struct catb {
	int words[6],
	name1, name2,
	passw1, passw2,
	word10, word11,
	datcreat, datmod,  datused,
	stuff[6],
	jjjj:18, tused:18;
	};
struct { int :3, slot:18; };  /* slot where time from cat. block fits */

struct catdesc {
	int cat1, cat2, cpass1, cpass2,
	    file1, file2, filep1, filep2,
	    endmark; };

extern int _q_reg, _a_reg;


# define A10(x,y) 10*x + y

/*	interpret the mm/dd/yy format */

struct d9 { int	:5, m1:4, :5, m2:4, :9,
		:5, d1:4, :5, d2:4, :9,
		:5, y1:4, :5, y2:4  ;};

struct d6 { int	:2, m61:4, :2, m62:4,
		:2, d61:4, :2, d62:4,
		:2, y61:4, :2, y62:4; };

static day6( d6word ){ /* return the day number of a word in bci format */
	int m, y, d;

	y = A10( d6word.y61, d6word.y62 );
	m = A10( d6word.m61, d6word.m62 );
	d = A10( d6word.d61, d6word.d62 );

	return( d + 31*( m + 12*(y-YZERO) ) );
	}

static day9( p ) register int *p; {

	int m, y, d;

	y = A10( p->y1, p->y2 );
	m = A10( p->m1, p->m2 );
	d = A10( p->d1, p->d2 );

	return( d + 31*( m + 12*(y-YZERO) ) );
	}


static int dfold( dayno, timeno ){
	int kk;
	kk = ( day*dayno + timeno) / 32768.;
	}

int prestime(){
	int date[2];
	drldrl( 021, date );
	return( dfold( day9(date), _q_reg ) );
	}


# define DODRL ar[0] = status; ar[1] = &b.cat1; drldrl(30,sp1,sp2); p=ar[0]<<18;

static struct { int fn1, fn2;  int ftm; } fbb[MAXCSIZE];
static int catsiz;

getcat() {

	register i, *p, j;
	int asname[4];
	struct catdesc b;
	int sp1, sp2, temp;
	int ar[2], status[2];
	int filbuf[380];

	gtcalled = 1;

	sp1 = ar;
	sp1 >>= 18;
	sp2 = filbuf;
	sp2 >>= 18;
	sp2.lhs = 19;

	b.cat1 = b.cat2 = b.file1 = -1;
	b.cpass1 = b.cpass2 = 0202020202020;

	DODRL
	sp2.lhs++;
	for( i=0; p!=0 && i<MAXCSIZE; ++i ){

		fbb[i].fn1 = b.file1 = p->name1;
		fbb[i].fn2 = b.file2 = p->name2;
		b.filep1 = p->passw1;
		b.filep2 = p->passw2;
		b.endmark = -1;
		temp = 0;
		temp.slot = p->tused;
		fbb[i].ftm = dfold( day6(p->datmod), temp );
		DODRL
		}
	catsiz = i;
	}

 exists( p ) 
 struct nameblock *p; {
	char *s, *cp, name[13];
	int i, *p, bcd[2];

/*
   cheat about names with slashes -- try opening;
   if it is openable, it exists, and assume it was made
   at t=1 (long time ago); otherwise, assume it
   does not exist
*/

cp = p->namep;

for(s=cp ; *s ; ++s)
	if(*s == '/')
		if(i = copen(cp,'r') < 0)
			return(0);
		else	{
			cclose(i);
			return(1);
			}

if(gtcalled == 0)  getcat();

	p = name;
	for( i=0; *cp; ++i ) name[i] = *cp++;
	while( i<12 ) name[i++] = ' ';
	f9to6( *p, bcd[0], 12 );
	for ( i=0; i<catsiz; ++i ){
		if( fbb[i].fn1 == bcd[0] && fbb[i].fn2 == bcd[1] )
			return( fbb[i].ftm );
		}
	return( 0 );
	}

\f
#include "defs"

static char n13[13];
static char *n13end &n13[12];


struct depblock *srchdir(pat, mkchain, nextdbl)

char *pat; /* pattern to be matched in directory */
int mkchain;  /* nonzero if results to be remembered */
struct depblock *nextdbl;  /* final value for chain */
{
int dirf;
int i, nread;
char *dirname, *dirpref, *endir, *filepat, *p, temp[BUFSIZ];
char fullname[BUFSIZ], *p1, *p2, *copys();
struct nameblock *q;
struct depblock *thisdbl;
struct pattern *patp;
int *intp1, *intp2;

if(gtcalled == 0)  getcat();
thisdbl=0;

if(mkchain == 0)
	for(patp=firstpat ; patp!=0 ; patp = patp->nxtpattern)
		if(! unequal(pat, patp->patval)) return(0);

patp = ALLOC(pattern);
patp->nxtpattern = firstpat;
firstpat = patp;
patp->patval = copys(pat);

endir = 0;

for(p=pat; *p!='\0'; ++p)
	if(*p=='/') endir = p;

if(endir==0)
	{
	dirname = "";
	dirpref = "";
	filepat = pat;
	}
else	{
fatal("File name has an embedded slash");
	dirname = pat;
	*endir = '\0';
	dirpref = concat(dirname, "/", temp);
	filepat = endir+1;
	}

for(i=0;i<catsiz;++i)
	{
	intp1 = &fbb[i].fn1;
	intp2 = n13;
	f6to9(*intp1, *intp2, 12);
	for(p1=n13; p1<n13end && *p1!=' ' ; ++p1) 
		if('A'<=*p1 && *p1<='Z') *p1 += ('a'-'A');
		*p1 = '\0';

	if( amatch(n13,filepat) )
		{
		concat(dirpref,n13,fullname);
		if( (q=srchname(fullname)) ==0)
			q = makename(copys(fullname));
		if(mkchain)
			{
			thisdbl = ALLOC(depblock);
			thisdbl->nextp = nextdbl;
			thisdbl->depname = q;
			nextdbl = thisdbl;
			}
		}
	}

if(endir != 0)  *endir = '/';

return(thisdbl);
}
\f
/* stolen from glob through find */

amatch(s, p)
char *s, *p;
{
	register int cc, scc, k;
	int c, lc;

	scc = *s;
	lc = 077777;
	switch (c = *p) {

	case '[':
		k = 0;
		while (cc = *++p) {
			switch (cc) {

			case ']':
				if (k)
					return(amatch(++s, ++p));
				else
					return(0);

			case '-':
				k |= lc <= scc & scc <= (cc=p[1]);
			}
			if (scc==(lc=cc)) k++;
		}
		return(0);

	case '?':
	caseq:
		if(scc) return(amatch(++s, ++p));
		return(0);
	case '*':
		return(umatch(s, ++p));
	case 0:
		return(!scc);
	}
	if (c==scc) goto caseq;
	return(0);
}

umatch(s, p)
char *s, *p;
{
	if(*p==0) return(1);
	while(*s)
		if (amatch(s++,p)) return(1);
	return(0);
}
\f


dosys(comstring,nohalt)
char *comstring;
int nohalt;
{
char *p;

for(p=comstring ; *p!='\0' ; ++p);
if( p-comstring > 80)
	fatal("Command string longer than 80 characters");

system(comstring);

return(0);
}


touch(s)
char *s;
{
fprintf(stderr, "touch not yet implemented on GCOS\n");
cexit(2);
}
Commit	Line	Data
572693b3	1	static char *sccsid = "@(#)gcos.c 4.4 (Berkeley) 87/12/04";
84e47efb BJ	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	\f
	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 { 641000606024 }; /* 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;
572693b3	115	sp1 >>= 18;
84e47efb	116	sp2 = filbuf;
572693b3	117	sp2 >>= 18;
84e47efb BJ	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
a10b24d4 KM	140	exists( p )
	141	struct nameblock *p; {
	142	char s, cp, name[13];
84e47efb BJ	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
a10b24d4 KM	152	cp = p->namep;
a10b24d4 KM	153
84e47efb BJ	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	\f
	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;
dbf5cc74 JB	192	char dirname, dirpref, endir, filepat, *p, temp[BUFSIZ];
dbf5cc74 JB	193	char fullname[BUFSIZ], p1, p2, *copys();
84e47efb BJ	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)
572693b3	236	if('A'<=p1 && p1<='Z') *p1 += ('a'-'A');
84e47efb BJ	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	\f
	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 '-':
572693b3	283	k \|= lc <= scc & scc <= (cc=p[1]);
84e47efb BJ	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	\f
	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	}