Upload

Digital Research

CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v101/c/preproc/macro.c

@@ -0,0 +1,577 @@
+#
+/*
+	Copyright 1981
+	Alcyon Corporation
+	8474 Commerce Av.
+	San Diego, Ca.  92121
+*/
+
+#include "preproc.h"
+#define	CSTKSIZE	20
+
+#ifdef	VAX
+char *stdincl "lib:";		/*standard include directory*/
+#endif
+
+#ifdef UNIX
+char *stdincl ="/usr/include/";
+#endif
+
+#ifdef MC68000
+char *stdincl "";
+#endif
+
+int clabel =1000;
+int nlabel =1001;
+int lineno = 0;
+
+struct builtin {
+	char *b_name;
+	int b_type;
+} btab[] {
+	"define",	DEFINE,
+	"include",	INCLUDE,
+	"undef",	UNDEF,
+	"ifdef",	IFDEF,
+	"ifndef",	IFNDEF,
+	"else",		ELSE,
+	"endif",	ENDIF,
+	"if",		IF,
+	0,
+};
+
+char cstack[CSTKSIZE]={0};
+char *cstkptr=0;
+
+/* domacro - do macro processing*/
+/*		Does the macro pre-processing on the input file and leaves the*/
+/*		result on the output file.*/
+domacro(infile,outfile,nd,nds)		/* returns 1 if ok, 0 otherwise*/
+char *infile;						/* input file name*/
+char *outfile;						/* output file name*/
+int nd;							/* number of defines*/
+char *nds[];						/*points to defines*/
+{
+	register struct builtin *bp;
+	register char *l;
+
+	filep = 0;
+	if( fopen(infile,&inbuf[filep],0) < 0 ) {
+		error("can't open %s\n",infile);
+		return(0);
+	}
+	if( fcreat(outfile,&outbuf,0666) < 0 ) {
+		error("can't creat %s\n",outfile);
+		return(0);
+	}
+	if( defap == 0 ) {
+		defp = defap = sbrk(1024);
+		defmax = defcount = 1024;
+	}
+	else {
+		defcount = defmax;
+		defp = defap;
+	}
+	lineno = 1;
+	defused = 0;
+	mfail = 0;
+	pbp = &pbbuf[0];
+	cstkptr = &cstack[0];
+	install("Newlabel",NEWLABEL);
+	install("Label",LABEL);
+	while( --nd >= 0 )
+		install(nds[nd],0);
+	while( getline() ) {
+		l = line;
+		if( filep == 0 && pbp == pbbuf )
+			lineno++;
+		else if( pflag == 0 && asflag == 0 )
+			putc(SOH,&outbuf);
+		while( *l )
+			putc(*l++,&outbuf);
+		putc('\n',&outbuf);
+	}
+	if( cstkptr != &cstack[0] )
+		error("unmatched conditional");
+	if( defused > defmax )
+		defmax = defused;
+	myfflush(&outbuf);
+	close(outbuf.fd);
+	close(inbuf[0].fd);
+	return(mfail==0);
+}
+
+/* kwlook - look up the macro built-in names*/
+/*		Searches thru the built-in table for the name.*/
+kwlook(name)						/* returns keyword index or 0*/
+char *name;							/* keyword name to lookup*/
+{
+	register struct builtin *bp;
+
+	for( bp = &btab[0]; bp->b_name; bp++ )
+		if( strcmp(bp->b_name,name) == 0 )
+			return(bp->b_type);
+	return(0);
+}
+
+/* getline - get input line handling macro statements*/
+/*		Checks for a preprocessor statement on the line and if there*/
+/*		is one there, it processes it.  Note that most of the work is*/
+/*		in determining whether we need to skip the current line or not.*/
+/*		This is all handled with the condition stack and the skip variable.*/
+/*		The skip variable is non-zero if any condition on the condition*/
+/*		stack is SKIP.*/
+getline()							/* returns 0 for EOF, 1 otherwise*/
+{
+	char token[TOKSIZE];
+	register int type, i;
+	register char *p;
+
+	initl();
+	if( (type=gettok(token)) == EOF )
+		return(0);
+	if( type == POUND ) {
+		if( (type=getntok(token)) == NEWL )
+			return(1);
+		switch( kwlook(token) ) {
+
+		case IFDEF:
+			if( getntok(token) == ALPHA && lookup(token) )
+				push(NOSKIP);
+			else {
+				push(SKIP);
+				skip++;
+			}
+			break;
+
+		case IFNDEF:
+			if( getntok(token) == ALPHA && lookup(token) ) {
+				push(SKIP);
+				skip++;
+			}
+			else
+				push(NOSKIP);
+			break;
+
+		case ENDIF:
+			if( (i=pop()) == SKIP )
+				skip--;
+			else if( i != NOSKIP )
+				error("invalid #endif");
+			break;
+
+		case ELSE:
+			if( (i=pop()) == SKIP ) {
+				skip--;
+				push(NOSKIP);
+			}
+			else if( i == NOSKIP ) {
+				skip++;
+				push(SKIP);
+			}
+			else
+				error("invalid #else");
+			break;
+
+		case DEFINE:
+			if( skip == 0 )			/*if in skip, don't do define*/
+				dodefine();
+			break;
+
+		case UNDEF:
+			if( skip == 0 ) {		/*if in skip, don't undef*/
+				if( (type=getntok(token)) == ALPHA )
+					undefine(token);
+			}
+			break;
+
+		case INCLUDE:
+			if( skip == 0 )			/*if in skip, don't do include*/
+				doinclude();
+			break;
+
+		case IF:
+			if( cexpr() )			/*evaluate constant expression*/
+				push(NOSKIP);		/*non-zero, so don't skip*/
+			else {
+				push(SKIP);
+				skip++;
+			}
+			break;
+
+		default:
+			error("invalid preprocessor command");
+			break;
+		}
+		eatup();
+	}
+	else if( type == NEWL )
+		;
+	else if( skip )
+		eatup();
+	else {
+		for( ; type != NEWL && type != EOF ; type = gettok(token) ) {
+			if( type == ALPHA && (p=lookup(token)) )
+				expand(p);
+			else {
+				for( p = token; *p ; )
+					putl(*p++);
+			}
+		}
+	}
+	putl('\0');
+	return(1);
+}
+
+/* eatup - eat up the rest of the input line until a newline or EOF*/
+/*		Does gettok calls.*/
+eatup()								/* returns - none*/
+{
+	register int type;
+	char token[TOKSIZE];
+
+	while( (type=gettok(token)) != NEWL && type != EOF )
+		;
+}
+
+/* putl - put a character to the current output line*/
+/*		Checks for line overflow.*/
+putl(c)								/* returns - none*/
+int c;								/* character to put on line*/
+{
+	if( linep < &line[LINESIZE] )
+		*linep++ = c;
+	else if( loverflow == 0 ) {
+		loverflow++;
+		error("line overflow");
+	}
+}
+
+/* initl - initialize current line*/
+/*		Sets the line pointer and the line overflow flag.*/
+initl()								/* returns - none*/
+{
+	*(linep= &line[0]) = '\0';
+	loverflow = 0;
+}
+
+/* putd - put a character to the define buffer*/
+/*		Does dynamic allocation for define buffer*/
+putd(c)								/* returns - none*/
+int c;								/* character to put in buffer*/
+{
+	if( defcount == 0 ) {
+		if( sbrk(DEFSIZE) == -1 ) {
+			error("define table overflow");
+			cexit();
+		}
+		defcount = DEFSIZE;
+	}
+	defused++;
+	defcount--;
+	*defp++ = c;
+}
+
+/* undefine - does undef command*/
+/*		Sets the symbols definition to the null pointer*/
+undefine(name)						/* returns - none*/
+char *name;							/* pointer to name to undef*/
+{
+	register struct symbol *sp;
+
+	sp = getsp(name);
+	if( sp->s_def )
+		sp->s_def = null;
+}
+
+/* dodefine - do #define processing*/
+/*		Checks the define name, collects formal arguements and saves*/
+/*		macro definition, substituting for formal arguments as it goes.*/
+dodefine()							/* returns - none*/
+{
+	char token[TOKSIZE], *args[MAXARGS], argbuf[ARGBSIZE];
+	register char *abp, *p;
+	register int type, nargs, i;
+	register struct symbol *sp;
+
+	if( (type=getntok(token)) != ALPHA ) {
+		error("bad define name: %s",token);
+		return;
+	}
+	sp = getsp(token);
+	symcopy(token,sp->s_name);
+	sp->s_def = defp;
+	nargs = 0;
+	abp = argbuf;
+	if( (type=gettok(token)) == LPAREN ) {
+		for( ; (type=getfarg(token)) != RPAREN; nargs++ ) {
+			if( nargs >= MAXARGS ) {
+				error("too many arguments");
+				break;
+			}
+			args[nargs] = abp;
+			for( p = token; *abp++ = *p++; ) {
+				if( abp >= &argbuf[ARGBSIZE] ) {
+					error("argument buffer overflow");
+					break;
+				}
+			}
+		}
+		putd(nargs);
+	}
+	else {
+		pbtok(token);
+		putd(NOARGS);
+	}
+	type = getntok(token);			/*get next non-white token*/
+	for( ; type != NEWL && type != EOF; type = gettok(token) ) {
+		if( type == ALPHA ) {
+			for( i = 0; i < nargs; i++ ) {
+				if( strcmp(args[i],token) == 0 )
+					break;
+			}
+			if( i < nargs ) {		/*sub ARG marker for formal arg*/
+				putd(i+1);
+				putd(ARG);
+				continue;
+			}
+		}
+		else if( type == BSLASH ) {
+			if( (i=ngetch()) == '\n' ) {	/*multi-line macro?*/
+				if( filep == 0 && pbp == pbbuf ) {
+					lineno++;
+					putc('\n',&outbuf);
+				}
+			}
+			putd(i);
+			continue;
+		}
+		for( p = token; *p ; )
+			putd(*p++);
+	}
+	pbtok(token);
+	putd('\0');
+}
+
+/* expand - expands the macro definition*/
+/*		Checks for define recursion and #define x x problems, collects*/
+/*		the actual arguments using getaarg, and then expands the macro*/
+/*		by pushing it onto the push back buffer, substituting arguments*/
+/*		as it goes.*/
+expand(sp)							/* returns - none*/
+struct symbol *sp;					/* pointer to macro to expand*/
+{
+	char argbuf[ARGBSIZE], *args[MAXARGS], token[TOKSIZE];
+	register char *p, *abp, *mdef;
+	register int i, j, nargs, type;
+
+	if( pbflag++ > 100 ) {
+		error("define recursion");
+		return;
+	}
+	if( strcmp(sp->s_name,mdef=sp->s_def) == 0 ) {	/*handle #define x x*/
+		while( *mdef )
+			putl(*mdef++);
+		return;
+	}
+	nargs = 0;
+	if( *mdef == NOARGS )					/*suppress grabbing of args*/
+		;
+	else if( gettok(token) != LPAREN )
+		pbtok(token);
+	else {
+		abp = &argbuf[0];
+		while( (type=getaarg(token)) != EOF ) {
+			if( nargs >= MAXARGS ) {
+				error("too many arguments");
+				return;
+			}
+			args[nargs++] = abp;
+			for( p = token; *abp++ = *p++; ) {
+				if( abp >= &argbuf[ARGBSIZE] ) {
+					error("argument buffer overflow");
+					return;
+				}
+			}
+			if( type == RPAREN )
+				break;
+		}
+	}
+	if( *mdef == NEWLABEL ) {
+		clabel = nlabel;
+		if( nargs == 0 )
+			nlabel++;
+		else
+			nlabel =+ atoi(args[0]);
+	}
+	else if( *mdef == LABEL ) {
+		if( nargs == 0 )
+			i = clabel;
+		else
+			i = clabel + atoi(args[0]);
+		pbnum(i);
+		pbtok("_L");
+	}
+	else {
+		mdef++;						/*skip no. of args*/
+		for( p = mdef + strlen(mdef) - 1; p >= mdef; p-- ) {
+			if( *p == ARG ) {
+				if( (j= *--p) <= nargs )
+					pbtok(args[j-1]);
+			}
+			else
+				putback(*p);
+		}
+	}
+}
+
+/* getfarg - get macro formal parameters*/
+/*		Skips blanks and handles "," and ")".*/
+getfarg(token)						/* returns token type*/
+char *token;						/* token returned*/
+{
+	register int type;
+
+	if( (type=getntok(token)) == RPAREN || type == ALPHA )
+		return(type);
+	if( type != COMMA || (type=getntok(token)) != ALPHA )
+		error("bad argument:%s",token);
+	return(type);
+}
+
+/* getntok - get next token, suppressing white space*/
+/*		Merely gettok's until non-white space is there*/
+getntok(token)						/* returns token type*/
+char *token;						/* token returned*/
+{
+	register int type;
+
+	while( (type=gettok(token)) == WHITE )
+		;
+	return(type);
+}
+
+/* getaarg - get macro actual argument*/
+/*		This handles the collecting of the macro's call arguments.*/
+/*		Note that you may have parenthesis as part of the macro argument,*/
+/*		hence you need to keep track of them.*/
+getaarg(argp)						/* returns token type*/
+char *argp;							/* argument returned*/
+{
+	int type, plevel, i;
+	register char *p, *ap;
+	char token[TOKSIZE];
+	
+	ap = argp;
+	*ap = '\0';
+	plevel = 0;
+	i = TOKSIZE;
+	while( ((type=gettok(token)) != COMMA && type != RPAREN) || plevel ) {
+		for( p = token; *ap = *p++; ap++ )
+			if( --i <= 0 ) {
+				error("macro argument too long");
+				return(EOF);
+			}
+		if( type == LPAREN )
+			plevel++;
+		else if( type == RPAREN )
+			plevel--;
+		else if( type == EOF ) {
+			error("unexpected EOF");
+			cexit();
+		}
+	}
+	if( ap == argp )
+		type = EOF;
+	return(type);
+}
+
+/* push - push a #ifdef condition value on condition stack*/
+/*		Checks for stack overflow.*/
+push(val)							/* returns - none*/
+int val;							/* value to push*/
+{
+	if( cstkptr >= &cstack[CSTKSIZE] ) {
+		error("condition stack overflow");
+		cexit();
+	}
+	*cstkptr++ = val;
+}
+
+/* pop - pop the #ifdef, etc. condition stack*/
+/*		Checks for stack undeflow.*/
+pop()								/* returns - top of condition stack*/
+{
+	if( cstkptr <= &cstack[0] )
+		return(-1);
+	return( *--cstkptr );
+}
+
+/* doinclude - handle #include command*/
+/*		Checks for file name or library file name and pushes file on*/
+/*		include file stack.*/
+doinclude()							/* returns - none*/
+{
+	register int type, fd;
+	char token[TOKSIZE], fname[TOKSIZE];
+	register char *p, *q, c;
+
+	p = fname;
+	if( (type=getntok(token)) == SQUOTE || type == DQUOTE ) {
+		for( c = token[0], q = &token[1]; *q != c; )
+			*p++ = *q++;
+		*p = '\0';
+	}
+	else if( type != LESS ) {
+		error("bad include file");
+		return;
+	}
+	else {
+		for( q = stdincl; *p = *q++; p++ )
+			;
+		while( (type=gettok(token))!=GREAT && type!=NEWL && type!=EOF )
+			for( q = token; *p = *q++; p++ )
+				;
+		if( type != GREAT ) {
+			error("bad include file name");
+			pbtok(token);
+			return;
+		}
+	}
+	eatup();						/*need here...*/
+	if( filep >= NINCS-1 )
+		error("includes nested too deeply");
+	else {
+		filep++;
+		if( fopen(fname,&inbuf[filep],0) < 0 ) {
+			error("can't open %s",fname);
+			filep--;
+		}
+	}
+	putback('\n');					/*for eatup in domacro*/
+}
+
+install(name,def)					/* returns - none*/
+char *name;							/* macro name*/
+char def;							/* pointer to definition*/
+{
+	register struct symbol *sp;
+
+	sp = getsp(name);
+	symcopy(name,sp->s_name);
+	sp->s_def = defp;
+	putd(def);
+	putd('\0');
+}
+
+pbnum(num)							/* returns - none*/
+int num;
+{
+	register int digit;
+
+	do {
+		digit = num % 10;
+		num =/ 10;
+		putback(digit+'0');
+	} while( num > 0 );
+}