make.c

LSI C-86 compiler,小日本写的C语言编译器

	ATOM	*a, *b, *p;
	char	*path, *s, *t, delim, c;
	char	buff[MAXNAME * 2];

	/* search .SUFFIXES */
	forall (l, SUFFIXES->src) {
		strcat(strcpy(buff, l->atom->name), suffix(tar->name));
		if ((a = lookup(buff)) == NULL || a->commands == NULL)
			continue;
		strcat(prefix(buff, tar->name), l->atom->name);
		if (Dflag)
			fprintf(stderr, "searching %s...", buff);
		if (lookup(buff) || exist(buff)) {
			if (Dflag)
				fprintf(stderr, "found\n");
			b = intern(buff);
			tar->src = cons(b, tar->src);
			if (tar->commands == NULL)
				tar->commands = a->commands;
			return;
		}
		if (Dflag)
			putchar('\n');
	}
#ifdef	OLDLSIFASHION
	/* if there's PATH definition, try other directories */
	forall (m, intern(".PATH")->src) {
		forall (l, SUFFIXES->src) {
			strcat(strcpy(buff, l->atom->name), suffix(tar->name));
			if ((a = lookup(buff)) == NULL || a->commands == NULL)
				continue;
			strcpy(buff, m->atom->name);
			if (buff[0] != '\0' &&
				(c = buff[strlen(buff) - 1]) != ':' &&
					c != '\\' && c != '/')
				strcat(buff, "/");
			prefix(buff + strlen(buff), barename(tar->name));
			strcat(buff, l->atom->name);
			if (Dflag)
				fprintf(stderr, "searching %s...", buff);
			if (lookup(buff) || exist(buff)) {
				if (Dflag)
					fprintf(stderr, "found\n");
				b = intern(buff);
				tar->src = cons(b, tar->src);
				if (tar->commands == NULL)
					tar->commands = a->commands;
				return;
			}
			if (Dflag)
				putchar('\n');
		}
	}
#endif
	/* if VPATH macro is defined, try other directories */
	if ((p = lookup("VPATH")) == NULL || p->macro == NULL)
		return;
	path = p->macro;
	if ((p = lookup("VPATHDELIM")) != NULL && p->macro && *p->macro)
		delim = *p->macro;
	else
		delim = ':';
	while (*path) {
		forall (l, SUFFIXES->src) {
			strcat(strcpy(buff, l->atom->name), suffix(tar->name));
			if ((a = lookup(buff)) == NULL || a->commands == NULL)
				continue;
			for (s = path, t = buff; *s && *s != delim; s++, t++)
				*t = *s;
			if (t > buff &&
				(c = t[-1]) != ':' && c != '\\' && c != '/')
				*t++ = '/';
			prefix(t, barename(tar->name));
			strcat(buff, l->atom->name);
			if (Dflag)
				fprintf(stderr, "searching %s...", buff);
			if (lookup(buff) || exist(buff)) {
				if (Dflag)
					fprintf(stderr, "found\n");
				b = intern(buff);
				tar->src = cons(b, tar->src);
				if (tar->commands == NULL)
					tar->commands = a->commands;
				return;
			}
			if (Dflag)
				putchar('\n');
		}
		while (*path && *path++ != delim)
			;
	}
}


#ifdef	OLDLSIFASHION
recursive
bool	makepath(ATOM *src, ATOM *tar)
{
	LIST	*l;
	char	buff[MAXNAME * 2];
	ATOM	*a, *b;

	if (tar == src)
		return (YES);
	/* search .SUFFIXES */
	forall (l, SUFFIXES->src) {
		strcat(strcpy(buff, l->atom->name), suffix(tar->name));
		if ((a = lookup(buff)) == NULL || a->command == NULL)
			continue;
		prefix(buff, src->name);
		prefix(buff + strlen(buff), a->name);
		b = intern(buff);
		if (makepath(src, b)) {
			src->type = ' ';
			tar->src = cons(b, tar->src);
			if (tar->commands == NULL)
				tar->commands = a->commands;
			return (YES);
		}
	}
	return (NO);
}




recursive
void	complsi1(LIST *src, ATOM *tar)
{
	if (src == NULL)
		return;
	complsi1(src->next, tar);
	if (! makepath(src->atom, tar))
		error("Don't know how to deal with %s\n", src->atom->name);
}


void	complete_lsi(ATOM *tar)
{
	LIST	*l, *p;

	fprintf(stderr, "Warning: old-fashioned dependency line: <\n");
	l = tar->src;
	complsi1(tar->src, tar);
	for (p = tar->src; p != NULL && p->next != l; p = p->next)
		;
	if (p != NULL)
		p->next = NULL;	/* remove old list */
	tar->type = ':';
}
#endif



#define	MAXCOLUMN	70
char	CloseChar;
FILE	*Fp;
char	*Cp;
char	Cmdline[128];
int	ExecRc;
int	Column;
char	Delim;


void	checkCp(int n)
{
	if (Cp + n > Cmdline + 127) {
		*Cp = '\0';
		fprintf(stderr, "make: Too long command line:\n");
		fprintf(stderr, "	%s...\n", Cmdline);
		exit(1);
	}
}



char	*skipsp(char *s)
{
	while (*s == ' ' || *s == '\t')
		s++;
	return (s);
}


char	*requireShell(char *s)
{
	char	c;

	while (c = *s++) {
		if (c == '<' || c == '>' || c == '|')
			return (s - 1);
		if (c == '"' || c == '\'') {
			while (*s && *s++ != c)
				;
		}
	}
	return (NULL);
}


void	exput(char c)
{
	if (ExecRc)
		return;
	if (Fp != NULL) {
		if (c == CloseChar) {
			putc('\n', Fp);
			putc('\x1A', Fp);	/* 27-Oct-1988 */
			fclose(Fp);
			Fp = NULL;
		} else {
			Column++;
			putc(c, Fp);
			if (c == '\n')
				Column = 0;
			if (Column > MAXCOLUMN && c == Delim) {
				putc('\n', Fp);
				Column = 0;
			}
		}
	} else if (c == '\n') {
		int	n, ret;
		char	*p;
		char	cmd[128];
		bool	silent = Sflag, ignore = Iflag,
			shell = NO, evergo = NO;

		*Cp = '\0';
		p = Cp = Cmdline;
		for (; ; p++) {
			if (*p == '+')
				shell = YES;
			else if (*p == '@')
				silent = YES;
			else if (*p == '-')
				ignore = YES;
			else if (*p == '*')
				evergo = YES;
			else if (*p == ' ' || *p == '\t')
				;
			else
				break;
		}
		if (*p == '#' || *p == '\0')
			return;		/* comment 06-Feb-1989 19:06 */
		if (! silent)
			fprintf(stderr, "%s\n", p);
		if (Nflag && !evergo)
			return;
		if (shell || requireShell(p))
			ret = system(p);
		else {
			n = strcspn(p, " \t");
			strncpy(cmd, p, n);
			cmd[n] = '\0';
			ret = spawnlp(0, cmd, cmd, p + n, NULL);
			if (ret < 0)
				ret = system(p);
		}
		if (! ignore && ret != 0) {
			fprintf(stderr, "\a**** Error %d\n", ret);
			if (Kflag) {
				ExecRc = ret;
				return;
			}
			exit(ret);
		}
	} else {
		checkCp(1);
		*Cp++ = c;
	}
}


void	exputs(char *s)
{
	char	c;

	while (c = *s++)
		exput(c);
}


int	execute(ATOM *tar)
{
	static	char	buf[MAXNAME + 1];
	command *p;
	int	c;
	LIST	*f;
	bool	x;

	Delim = ' ';
	ExecRc = 0;
	/* copy commands */
	for (p = tar->commands; p != NULL; p = p->next)
		ungets(p->body);
	Cp = Cmdline;
	Fp = NULL;
	while ((c = get()) != EOF) {
		switch (c) {
		case -'@':
			exputs(tar->name);
			break;
		case -'*':
			exputs(prefix(buf, tar->name));
			break;
		case -'<':
			exputs(tar->src->atom->name);
			break;
		case -'>':
			exputs(prefix(buf, tar->src->atom->name));
			break;
		case -'?':
			x = NO;
			forall (f, tar->src)
				if (timeof(f->atom) > timeof(tar)) {
					if (x)
						exput(Delim);
					exputs(f->atom->name);
					x = YES;
				}
			break;
		case -'#':
			x = NO;
			forall (f, tar->src) {
				if (x)
					exput(Delim);
				exputs(f->atom->name);
				x = YES;
			}
			break;
		case -'&':
			x = NO;
			forall (f, tar->src) {
				if (x)
					exput(Delim);
				exputs(prefix(buf, f->atom->name));
				x = YES;
			}
			break;
		case -':':
			Delim = get();
			break;
		case -'[':
			CloseChar = ']';
			goto makeresp;
		case -'{':
			CloseChar = '}';
		makeresp:
			if (Fp != NULL)
				error("can't nest $[\n", NULL);
			checkCp(6);
			strcpy(Cp, "make.i");
			Fp = fopen(Cp, "w");
			Column = 0;
			Cp += strlen(Cp);
			break;
		default:
			exput(c);
			break;
		}
	}
	if (Fp != NULL)
		error("unbalanced \n", NULL);
	return (ExecRc);
}


bool	needtodo(ATOM *tar)
{
	LIST	*f;
	time_t	tm;

	if (tar->commands != NULL && tar->src == NULL)
		return (YES);
	if ((tm = timeof(tar)) == 0)
		return (YES);
	forall (f, tar->src)
		if (timeof(f->atom) > tm)
			return (YES);
	return (NO);
}


int	Dlev;
int	Nexec;

recursive int	makethis(ATOM *tar)
{
	LIST	*f;
	int	n;

#ifdef	OLDLSIFASHION
	if (tar->type == '<')
		complete_lsi(tar);
	else
#endif
	if (tar->type != ' ' && tar->commands == NULL)
		complete_unix(tar);
	if (Dflag) {
		int	i;

		for (i = 0; i < Dlev; i++)
			fprintf(stderr, "  ");
		fprintf(stderr, "-%s\n", tar->name);
	}
	if (tar->visit)
		error("'%s' is defined recursively\n", tar->name);
	tar->visit = YES;
	Dlev++;
	n = 0;
	forall (f, tar->src)
		n |= makethis(f->atom);
	tar->visit = NO;
	Dlev--;
	if (n != 0)
		return (n);
	if (! needtodo(tar))
		return (0);
	else if (tar->commands == NULL) {
		if (tar->src == NULL)
			error("Don't know how to make %s\n", tar->name);
		return (0);
	} else if (Tflag) {
		touch(tar);
		return (0);
	} else {
		Nexec++;
		n = execute(tar);
		if (Nflag)
			tar->uptime = time(0);
		else
			tar->uptime = 0;
		return (n);
	}
}



int	domake(ATOM *tar)
{
	int	rc;

	Nexec = 0;
	if ((rc = makethis(tar)) != 0)
		fprintf(stderr, "Failed to make %s\n", tar->name);
	else if (Nexec == 0)
		fprintf(stderr, "%s is up to date.\n", tar->name);
	return (rc);
}



void	defmac(char *s)
{
	char	buf[MAXNAME + 1], *p;
	ATOM	*a;

	p = buf;
	while (*s && *s != '=') {
		if (p >= buf + MAXNAME) {
			*p = '\0';
			error(Longmsg, buf);
		}
		*p++ = *s++;
	}
	*p = '\0';
	if (*s == '=')
		s++;
	a = intern(buf);
	a->macro = s;
	a->userdef = YES;
}



char	*getfull(char *buf, char *file)
{
	int	fd;
	char	*p, *d;

	fd = -1;
	strcpy(buf, file);
	if ((fd = open(buf, 0)) < 0 && (p = getenv("PATH")) != NULL) {
		while (*p) {
			d = buf;
			while (*p && *p != ';')
				*d++ = *p++;
			if (d > buf && d[-1] != ':' && d[-1] != '\\')
				*d++ = '\\';
			strcpy(d, file);
			if ((fd = open(buf, 0)) >= 0)
				break;
			if (*p == ';')
				p++;
		}
	}
	if (fd >= 0)
		close(fd);
	else
		strcpy(buf, file);
	return (buf);
}


void	main(int argc, char *argv[])
{
	char	*makef = "makefile";
	bool	rflag = NO;
	ATOM	*tar;
	char	*p, c, buf[256], *mf;
	int	i, n, rc;

	strcpy(buf, "*make");
	mf = buf + strlen(buf);
	while (++argv, --argc != 0 && argv[0][0] == '-') {
		*mf++ = ' ';
		strcpy(mf, argv[0]);
		mf += strlen(mf);
		for (p = argv[0] + 1; c = *p++; ) {
			switch (c) {
			case 'n':
				Nflag = YES;
				break;
			case 't':
				Tflag = YES;
				break;
			case 's':
				Sflag = YES;
				break;
			case 'd':
				Dflag = YES;
				break;
			case 'r':
				rflag = YES;
				break;
			case 'i':
				Iflag = YES;
				break;
			case 'k':
				Kflag = YES;
				break;
			case 'f':
				if (--argc != 0) {
					makef = *++argv;
					*mf++ = ' ';
					strcpy(mf, makef);
					mf += strlen(mf);
					break;
				}
				/* thru */
			default:
				fprintf(stderr, Usage);
				exit(1);
			}
		}
	}

/* init gettok */
	initgettok();

/* do macro-definitions in command line */
	for (i = 0; i < argc; i++) {
		if (strchr(argv[i], '=')) {
			defmac(argv[i]);
			*mf++ = ' ';
			strcpy(mf, argv[i]);
			mf += strlen(mf);
		}
	}

/* set MAKE, MFLAGS macro */
	*mf = '\0';

	MAKE->macro = strcpy(new(char, strlen(buf) + 1), buf);
	MFLAGS->macro = MAKE->macro + 5;

/* read makefile */
	if (!rflag)
		readmake(getfull(buf, "makedef"));
	tar = readmake(makef);

/* make */
	n = 0;
	rc = 0;
	for (i = 0; i < argc; i++)
		if (strchr(argv[i], '=') == NULL) {
			rc |= domake(intern(argv[i]));
			n++;
		}
	if (n == 0) {
		if (tar == NULL) {
			if (errno) {
				fprintf(stderr, "make: ");
				perror(makef);
				exit(1);
			} else
				error("No target defined in %s\n", makef);
		}
		rc |= domake(tar);
	}
	exit(rc);
}