* Moved lcc and q3asm into code/tools

git-svn-id: svn://svn.icculus.org/quake3/trunk@134 edf5b092-35ff-0310-97b2-ce42778d08ea

11 files changed, 0 insertions, 2977 deletions

diff --git a/lcc/cpp/cpp.c b/lcc/cpp/cpp.c
deleted file mode 100644
index 6739e4d..0000000
--- a/lcc/cpp/cpp.c
+++ /dev/null
@@ -1,322 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-#include <stdarg.h>
-#include "cpp.h"
-
-char rcsid[] = "cpp.c - faked rcsid";
-
-#define	OUTS	16384
-char	outbuf[OUTS];
-char	*outp = outbuf;
-Source	*cursource;
-int	nerrs;
-struct	token nltoken = { NL, 0, 0, 0, 1, (uchar*)"\n" };
-char	*curtime;
-int	incdepth;
-int	ifdepth;
-int	ifsatisfied[NIF];
-int	skipping;
-
-
-int
-main(int argc, char **argv)
-{
-	Tokenrow tr;
-	time_t t;
-	char ebuf[BUFSIZ];
-
-	setbuf(stderr, ebuf);
-	t = time(NULL);
-	curtime = ctime(&t);
-	maketokenrow(3, &tr);
-	expandlex();
-	setup(argc, argv);
-	fixlex();
-	iniths();
-	genline();
-	process(&tr);
-	flushout();
-	fflush(stderr);
-	exit(nerrs > 0);
-	return 0;
-}
-
-void
-process(Tokenrow *trp)
-{
-	int anymacros = 0;
-
-	for (;;) {
-		if (trp->tp >= trp->lp) {
-			trp->tp = trp->lp = trp->bp;
-			outp = outbuf;
-			anymacros |= gettokens(trp, 1);
-			trp->tp = trp->bp;
-		}
-		if (trp->tp->type == END) {
-			if (--incdepth>=0) {
-				if (cursource->ifdepth)
-					error(ERROR,
-					 "Unterminated conditional in #include");
-				unsetsource();
-				cursource->line += cursource->lineinc;
-				trp->tp = trp->lp;
-				genline();
-				continue;
-			}
-			if (ifdepth)
-				error(ERROR, "Unterminated #if/#ifdef/#ifndef");
-			break;
-		}
-		if (trp->tp->type==SHARP) {
-			trp->tp += 1;
-			control(trp);
-		} else if (!skipping && anymacros)
-			expandrow(trp, NULL);
-		if (skipping)
-			setempty(trp);
-		puttokens(trp);
-		anymacros = 0;
-		cursource->line += cursource->lineinc;
-		if (cursource->lineinc>1) {
-			genline();
-		}
-	}
-}
-	
-void
-control(Tokenrow *trp)
-{
-	Nlist *np;
-	Token *tp;
-
-	tp = trp->tp;
-	if (tp->type!=NAME) {
-		if (tp->type==NUMBER)
-			goto kline;
-		if (tp->type != NL)
-			error(ERROR, "Unidentifiable control line");
-		return;			/* else empty line */
-	}
-	if ((np = lookup(tp, 0))==NULL || ((np->flag&ISKW)==0 && !skipping)) {
-		error(WARNING, "Unknown preprocessor control %t", tp);
-		return;
-	}
-	if (skipping) {
-		switch (np->val) {
-		case KENDIF:
-			if (--ifdepth<skipping)
-				skipping = 0;
-			--cursource->ifdepth;
-			setempty(trp);
-			return;
-
-		case KIFDEF:
-		case KIFNDEF:
-		case KIF:
-			if (++ifdepth >= NIF)
-				error(FATAL, "#if too deeply nested");
-			++cursource->ifdepth;
-			return;
-
-		case KELIF:
-		case KELSE:
-			if (ifdepth<=skipping)
-				break;
-			return;
-
-		default:
-			return;
-		}
-	}
-	switch (np->val) {
-	case KDEFINE:
-		dodefine(trp);
-		break;
-
-	case KUNDEF:
-		tp += 1;
-		if (tp->type!=NAME || trp->lp - trp->bp != 4) {
-			error(ERROR, "Syntax error in #undef");
-			break;
-		}
-		if ((np = lookup(tp, 0)) != NULL)
-			np->flag &= ~ISDEFINED;
-		break;
-
-	case KPRAGMA:
-		return;
-
-	case KIFDEF:
-	case KIFNDEF:
-	case KIF:
-		if (++ifdepth >= NIF)
-			error(FATAL, "#if too deeply nested");
-		++cursource->ifdepth;
-		ifsatisfied[ifdepth] = 0;
-		if (eval(trp, np->val))
-			ifsatisfied[ifdepth] = 1;
-		else
-			skipping = ifdepth;
-		break;
-
-	case KELIF:
-		if (ifdepth==0) {
-			error(ERROR, "#elif with no #if");
-			return;
-		}
-		if (ifsatisfied[ifdepth]==2)
-			error(ERROR, "#elif after #else");
-		if (eval(trp, np->val)) {
-			if (ifsatisfied[ifdepth])
-				skipping = ifdepth;
-			else {
-				skipping = 0;
-				ifsatisfied[ifdepth] = 1;
-			}
-		} else
-			skipping = ifdepth;
-		break;
-
-	case KELSE:
-		if (ifdepth==0 || cursource->ifdepth==0) {
-			error(ERROR, "#else with no #if");
-			return;
-		}
-		if (ifsatisfied[ifdepth]==2)
-			error(ERROR, "#else after #else");
-		if (trp->lp - trp->bp != 3)
-			error(ERROR, "Syntax error in #else");
-		skipping = ifsatisfied[ifdepth]? ifdepth: 0;
-		ifsatisfied[ifdepth] = 2;
-		break;
-
-	case KENDIF:
-		if (ifdepth==0 || cursource->ifdepth==0) {
-			error(ERROR, "#endif with no #if");
-			return;
-		}
-		--ifdepth;
-		--cursource->ifdepth;
-		if (trp->lp - trp->bp != 3)
-			error(WARNING, "Syntax error in #endif");
-		break;
-
-	case KERROR:
-		trp->tp = tp+1;
-		error(WARNING, "#error directive: %r", trp);
-		break;
-
-	case KLINE:
-		trp->tp = tp+1;
-		expandrow(trp, "<line>");
-		tp = trp->bp+2;
-	kline:
-		if (tp+1>=trp->lp || tp->type!=NUMBER || tp+3<trp->lp
-		 || ((tp+3==trp->lp && ((tp+1)->type!=STRING))||*(tp+1)->t=='L')){
-			error(ERROR, "Syntax error in #line");
-			return;
-		}
-		cursource->line = atol((char*)tp->t)-1;
-		if (cursource->line<0 || cursource->line>=32768)
-			error(WARNING, "#line specifies number out of range");
-		tp = tp+1;
-		if (tp+1<trp->lp)
-			cursource->filename=(char*)newstring(tp->t+1,tp->len-2,0);
-		return;
-
-	case KDEFINED:
-		error(ERROR, "Bad syntax for control line");
-		break;
-
-	case KINCLUDE:
-		doinclude(trp);
-		trp->lp = trp->bp;
-		return;
-
-	case KEVAL:
-		eval(trp, np->val);
-		break;
-
-	default:
-		error(ERROR, "Preprocessor control `%t' not yet implemented", tp);
-		break;
-	}
-	setempty(trp);
-	return;
-}
-
-void *
-domalloc(int size)
-{
-	void *p = malloc(size);
-
-	if (p==NULL)
-		error(FATAL, "Out of memory from malloc");
-	return p;
-}
-
-void
-dofree(void *p)
-{
-	free(p);
-}
-
-void
-error(enum errtype type, char *string, ...)
-{
-	va_list ap;
-	char *cp, *ep;
-	Token *tp;
-	Tokenrow *trp;
-	Source *s;
-	int i;
-
-	fprintf(stderr, "cpp: ");
-	for (s=cursource; s; s=s->next)
-		if (*s->filename)
-			fprintf(stderr, "%s:%d ", s->filename, s->line);
-	va_start(ap, string);
-	for (ep=string; *ep; ep++) {
-		if (*ep=='%') {
-			switch (*++ep) {
-
-			case 's':
-				cp = va_arg(ap, char *);
-				fprintf(stderr, "%s", cp);
-				break;
-			case 'd':
-				i = va_arg(ap, int);
-				fprintf(stderr, "%d", i);
-				break;
-			case 't':
-				tp = va_arg(ap, Token *);
-				fprintf(stderr, "%.*s", tp->len, tp->t);
-				break;
-
-			case 'r':
-				trp = va_arg(ap, Tokenrow *);
-				for (tp=trp->tp; tp<trp->lp&&tp->type!=NL; tp++) {
-					if (tp>trp->tp && tp->wslen)
-						fputc(' ', stderr);
-					fprintf(stderr, "%.*s", tp->len, tp->t);
-				}
-				break;
-
-			default:
-				fputc(*ep, stderr);
-				break;
-			}
-		} else
-			fputc(*ep, stderr);
-	}
-	va_end(ap);
-	fputc('\n', stderr);
-	if (type==FATAL)
-		exit(1);
-	if (type!=WARNING)
-		nerrs = 1;
-	fflush(stderr);
-}
diff --git a/lcc/cpp/cpp.h b/lcc/cpp/cpp.h
deleted file mode 100644
index d72f24a..0000000
--- a/lcc/cpp/cpp.h
+++ /dev/null
@@ -1,163 +0,0 @@
-#define	INS	32768		/* input buffer */
-#define	OBS	4096		/* outbut buffer */
-#define	NARG	32		/* Max number arguments to a macro */
-#define	NINCLUDE 32		/* Max number of include directories (-I) */
-#define	NIF	32		/* depth of nesting of #if */
-#ifndef EOF
-#define	EOF	(-1)
-#endif
-#ifndef NULL
-#define NULL	0
-#endif
-
-#ifndef __alpha
-typedef unsigned char uchar;
-#endif
-
-enum toktype { END, UNCLASS, NAME, NUMBER, STRING, CCON, NL, WS, DSHARP,
-		EQ, NEQ, LEQ, GEQ, LSH, RSH, LAND, LOR, PPLUS, MMINUS,
-		ARROW, SBRA, SKET, LP, RP, DOT, AND, STAR, PLUS, MINUS,
-		TILDE, NOT, SLASH, PCT, LT, GT, CIRC, OR, QUEST,
-		COLON, ASGN, COMMA, SHARP, SEMIC, CBRA, CKET,
-		ASPLUS, ASMINUS, ASSTAR, ASSLASH, ASPCT, ASCIRC, ASLSH,
-		ASRSH, ASOR, ASAND, ELLIPS,
-		DSHARP1, NAME1, DEFINED, UMINUS };
-
-enum kwtype { KIF, KIFDEF, KIFNDEF, KELIF, KELSE, KENDIF, KINCLUDE, KDEFINE,
-		KUNDEF, KLINE, KERROR, KPRAGMA, KDEFINED,
-		KLINENO, KFILE, KDATE, KTIME, KSTDC, KEVAL };
-
-#define	ISDEFINED	01	/* has #defined value */
-#define	ISKW		02	/* is PP keyword */
-#define	ISUNCHANGE	04	/* can't be #defined in PP */
-#define	ISMAC		010	/* builtin macro, e.g. __LINE__ */
-
-#define	EOB	0xFE		/* sentinel for end of input buffer */
-#define	EOFC	0xFD		/* sentinel for end of input file */
-#define	XPWS	1		/* token flag: white space to assure token sep. */
-
-typedef struct token {
-	unsigned char	type;
-	unsigned char 	flag;
-	unsigned short	hideset;
-	unsigned int	wslen;
-	unsigned int	len;
-	uchar	*t;
-} Token;
-
-typedef struct tokenrow {
-	Token	*tp;		/* current one to scan */
-	Token	*bp;		/* base (allocated value) */
-	Token	*lp;		/* last+1 token used */
-	int	max;		/* number allocated */
-} Tokenrow;
-
-typedef struct source {
-	char	*filename;	/* name of file of the source */
-	int	line;		/* current line number */
-	int	lineinc;	/* adjustment for \\n lines */
-	uchar	*inb;		/* input buffer */
-	uchar	*inp;		/* input pointer */
-	uchar	*inl;		/* end of input */
-	int	fd;		/* input source */
-	int	ifdepth;	/* conditional nesting in include */
-	struct	source *next;	/* stack for #include */
-} Source;
-
-typedef struct nlist {
-	struct nlist *next;
-	uchar	*name;
-	int	len;
-	Tokenrow *vp;		/* value as macro */
-	Tokenrow *ap;		/* list of argument names, if any */
-	char	val;		/* value as preprocessor name */
-	char	flag;		/* is defined, is pp name */
-} Nlist;
-
-typedef	struct	includelist {
-	char	deleted;
-	char	always;
-	char	*file;
-} Includelist;
-
-#define	new(t)	(t *)domalloc(sizeof(t))
-#define	quicklook(a,b)	(namebit[(a)&077] & (1<<((b)&037)))
-#define	quickset(a,b)	namebit[(a)&077] |= (1<<((b)&037))
-extern	unsigned long namebit[077+1];
-
-enum errtype { WARNING, ERROR, FATAL };
-
-void	expandlex(void);
-void	fixlex(void);
-void	setup(int, char **);
-int	gettokens(Tokenrow *, int);
-int	comparetokens(Tokenrow *, Tokenrow *);
-Source	*setsource(char *, int, char *);
-void	unsetsource(void);
-void	puttokens(Tokenrow *);
-void	process(Tokenrow *);
-void	*domalloc(int);
-void	dofree(void *);
-void	error(enum errtype, char *, ...);
-void	flushout(void);
-int	fillbuf(Source *);
-int	trigraph(Source *);
-int	foldline(Source *);
-Nlist	*lookup(Token *, int);
-void	control(Tokenrow *);
-void	dodefine(Tokenrow *);
-void	doadefine(Tokenrow *, int);
-void	doinclude(Tokenrow *);
-void	doif(Tokenrow *, enum kwtype);
-void	expand(Tokenrow *, Nlist *);
-void	builtin(Tokenrow *, int);
-int	gatherargs(Tokenrow *, Tokenrow **, int *);
-void	substargs(Nlist *, Tokenrow *, Tokenrow **);
-void	expandrow(Tokenrow *, char *);
-void	maketokenrow(int, Tokenrow *);
-Tokenrow *copytokenrow(Tokenrow *, Tokenrow *);
-Token	*growtokenrow(Tokenrow *);
-Tokenrow *normtokenrow(Tokenrow *);
-void	adjustrow(Tokenrow *, int);
-void	movetokenrow(Tokenrow *, Tokenrow *);
-void	insertrow(Tokenrow *, int, Tokenrow *);
-void	peektokens(Tokenrow *, char *);
-void	doconcat(Tokenrow *);
-Tokenrow *stringify(Tokenrow *);
-int	lookuparg(Nlist *, Token *);
-long	eval(Tokenrow *, int);
-void	genline(void);
-void	setempty(Tokenrow *);
-void	makespace(Tokenrow *);
-char	*outnum(char *, int);
-int	digit(int);
-uchar	*newstring(uchar *, int, int);
-int	checkhideset(int, Nlist *);
-void	prhideset(int);
-int	newhideset(int, Nlist *);
-int	unionhideset(int, int);
-void	iniths(void);
-void	setobjname(char *);
-#define	rowlen(tokrow)	((tokrow)->lp - (tokrow)->bp)
-
-extern	char *outp;
-extern	Token	nltoken;
-extern	Source *cursource;
-extern	char *curtime;
-extern	int incdepth;
-extern	int ifdepth;
-extern	int ifsatisfied[NIF];
-extern	int Mflag;
-extern	int skipping;
-extern	int verbose;
-extern	int Cplusplus;
-extern	Nlist *kwdefined;
-extern	Includelist includelist[NINCLUDE];
-extern	char wd[];
-
-extern int creat(char *, int);
-extern int open(char *, int);
-extern int close(int);
-extern int dup2(int, int);
-extern int write(int, char *, size_t);
-extern int read(int, char *, size_t);
diff --git a/lcc/cpp/eval.c b/lcc/cpp/eval.c
deleted file mode 100644
index 7061eff..0000000
--- a/lcc/cpp/eval.c
+++ /dev/null
@@ -1,520 +0,0 @@
-#include <stdlib.h>
-#include <string.h>
-#include "cpp.h"
-
-#define	NSTAK	32
-#define	SGN	0
-#define	UNS	1
-#define	UND	2
-
-#define	UNSMARK	0x1000
-
-struct value {
-	long	val;
-	int	type;
-};
-
-/* conversion types */
-#define	RELAT	1
-#define	ARITH	2
-#define	LOGIC	3
-#define	SPCL	4
-#define	SHIFT	5
-#define	UNARY	6
-
-/* operator priority, arity, and conversion type, indexed by tokentype */
-struct pri {
-	char	pri;
-	char	arity;
-	char	ctype;
-} priority[] = {
-	{ 0, 0, 0 },		/* END */
-	{ 0, 0, 0 },		/* UNCLASS */
-	{ 0, 0, 0 },		/* NAME */
-	{ 0, 0, 0 },		/* NUMBER */
-	{ 0, 0, 0 },		/* STRING */
-	{ 0, 0, 0 },		/* CCON */
-	{ 0, 0, 0 },		/* NL */
-	{ 0, 0, 0 },		/* WS */
-	{ 0, 0, 0 },		/* DSHARP */
-	{ 11, 2, RELAT },	/* EQ */
-	{ 11, 2, RELAT },	/* NEQ */
-	{ 12, 2, RELAT },	/* LEQ */
-	{ 12, 2, RELAT },	/* GEQ */
-	{ 13, 2, SHIFT },	/* LSH */
-	{ 13, 2, SHIFT },	/* RSH */
-	{ 7, 2, LOGIC },	/* LAND */
-	{ 6, 2, LOGIC },	/* LOR */
-	{ 0, 0, 0 },		/* PPLUS */
-	{ 0, 0, 0 },		/* MMINUS */
-	{ 0, 0, 0 },		/* ARROW */
-	{ 0, 0, 0 },		/* SBRA */
-	{ 0, 0, 0 },		/* SKET */
-	{ 3, 0, 0 },		/* LP */
-	{ 3, 0, 0 },		/* RP */
-	{ 0, 0, 0 },		/* DOT */
-	{ 10, 2, ARITH },	/* AND */
-	{ 15, 2, ARITH },	/* STAR */
-	{ 14, 2, ARITH },	/* PLUS */
-	{ 14, 2, ARITH },	/* MINUS */
-	{ 16, 1, UNARY },	/* TILDE */
-	{ 16, 1, UNARY },	/* NOT */
-	{ 15, 2, ARITH },	/* SLASH */
-	{ 15, 2, ARITH },	/* PCT */
-	{ 12, 2, RELAT },	/* LT */
-	{ 12, 2, RELAT },	/* GT */
-	{ 9, 2, ARITH },	/* CIRC */
-	{ 8, 2, ARITH },	/* OR */
-	{ 5, 2, SPCL },		/* QUEST */
-	{ 5, 2, SPCL },		/* COLON */
-	{ 0, 0, 0 },		/* ASGN */
-	{ 4, 2, 0 },		/* COMMA */
-	{ 0, 0, 0 },		/* SHARP */
-	{ 0, 0, 0 },		/* SEMIC */
-	{ 0, 0, 0 },		/* CBRA */
-	{ 0, 0, 0 },		/* CKET */
-	{ 0, 0, 0 },		/* ASPLUS */
- 	{ 0, 0, 0 },		/* ASMINUS */
- 	{ 0, 0, 0 },		/* ASSTAR */
- 	{ 0, 0, 0 },		/* ASSLASH */
- 	{ 0, 0, 0 },		/* ASPCT */
- 	{ 0, 0, 0 },		/* ASCIRC */
- 	{ 0, 0, 0 },		/* ASLSH */
-	{ 0, 0, 0 },		/* ASRSH */
- 	{ 0, 0, 0 },		/* ASOR */
- 	{ 0, 0, 0 },		/* ASAND */
-	{ 0, 0, 0 },		/* ELLIPS */
-	{ 0, 0, 0 },		/* DSHARP1 */
-	{ 0, 0, 0 },		/* NAME1 */
-	{ 16, 1, UNARY },	/* DEFINED */
-	{ 16, 0, UNARY },	/* UMINUS */
-};
-
-int	evalop(struct pri);
-struct	value tokval(Token *);
-struct value vals[NSTAK], *vp;
-enum toktype ops[NSTAK], *op;
-
-/*
- * Evaluate an #if #elif #ifdef #ifndef line.  trp->tp points to the keyword.
- */
-long
-eval(Tokenrow *trp, int kw)
-{
-	Token *tp;
-	Nlist *np;
-	int ntok, rand;
-
-	trp->tp++;
-	if (kw==KIFDEF || kw==KIFNDEF) {
-		if (trp->lp - trp->bp != 4 || trp->tp->type!=NAME) {
-			error(ERROR, "Syntax error in #ifdef/#ifndef");
-			return 0;
-		}
-		np = lookup(trp->tp, 0);
-		return (kw==KIFDEF) == (np && np->flag&(ISDEFINED|ISMAC));
-	}
-	ntok = trp->tp - trp->bp;
-	kwdefined->val = KDEFINED;	/* activate special meaning of defined */
-	expandrow(trp, "<if>");
-	kwdefined->val = NAME;
-	vp = vals;
-	op = ops;
-	*op++ = END;
-	for (rand=0, tp = trp->bp+ntok; tp < trp->lp; tp++) {
-		switch(tp->type) {
-		case WS:
-		case NL:
-			continue;
-
-		/* nilary */
-		case NAME:
-		case NAME1:
-		case NUMBER:
-		case CCON:
-		case STRING:
-			if (rand)
-				goto syntax;
-			*vp++ = tokval(tp);
-			rand = 1;
-			continue;
-
-		/* unary */
-		case DEFINED:
-		case TILDE:
-		case NOT:
-			if (rand)
-				goto syntax;
-			*op++ = tp->type;
-			continue;
-
-		/* unary-binary */
-		case PLUS: case MINUS: case STAR: case AND:
-			if (rand==0) {
-				if (tp->type==MINUS)
-					*op++ = UMINUS;
-				if (tp->type==STAR || tp->type==AND) {
-					error(ERROR, "Illegal operator * or & in #if/#elsif");
-					return 0;
-				}
-				continue;
-			}
-			/* flow through */
-
-		/* plain binary */
-		case EQ: case NEQ: case LEQ: case GEQ: case LSH: case RSH:
-		case LAND: case LOR: case SLASH: case PCT:
-		case LT: case GT: case CIRC: case OR: case QUEST:
-		case COLON: case COMMA:
-			if (rand==0)
-				goto syntax;
-			if (evalop(priority[tp->type])!=0)
-				return 0;
-			*op++ = tp->type;
-			rand = 0;
-			continue;
-
-		case LP:
-			if (rand)
-				goto syntax;
-			*op++ = LP;
-			continue;
-
-		case RP:
-			if (!rand)
-				goto syntax;
-			if (evalop(priority[RP])!=0)
-				return 0;
-			if (op<=ops || op[-1]!=LP) {
-				goto syntax;
-			}
-			op--;
-			continue;
-
-		default:
-			error(ERROR,"Bad operator (%t) in #if/#elsif", tp);
-			return 0;
-		}
-	}
-	if (rand==0)
-		goto syntax;
-	if (evalop(priority[END])!=0)
-		return 0;
-	if (op!=&ops[1] || vp!=&vals[1]) {
-		error(ERROR, "Botch in #if/#elsif");
-		return 0;
-	}
-	if (vals[0].type==UND)
-		error(ERROR, "Undefined expression value");
-	return vals[0].val;
-syntax:
-	error(ERROR, "Syntax error in #if/#elsif");
-	return 0;
-}
-
-int
-evalop(struct pri pri)
-{
-	struct value v1, v2;
-	long rv1, rv2;
-	int rtype, oper;
-
-	rv2=0;
-	rtype=0;
-	while (pri.pri < priority[op[-1]].pri) {
-		oper = *--op;
-		if (priority[oper].arity==2) {
-			v2 = *--vp;
-			rv2 = v2.val;
-		}
-		v1 = *--vp;
-		rv1 = v1.val;
-/*lint -e574 -e644 */
-		switch (priority[oper].ctype) {
-		case 0:
-		default:
-			error(WARNING, "Syntax error in #if/#endif");
-			return 1;
-		case ARITH:
-		case RELAT:
-			if (v1.type==UNS || v2.type==UNS)
-				rtype = UNS;
-			else
-				rtype = SGN;
-			if (v1.type==UND || v2.type==UND)
-				rtype = UND;
-			if (priority[oper].ctype==RELAT && rtype==UNS) {
-				oper |= UNSMARK;
-				rtype = SGN;
-			}
-			break;
-		case SHIFT:
-			if (v1.type==UND || v2.type==UND)
-				rtype = UND;
-			else
-				rtype = v1.type;
-			if (rtype==UNS)
-				oper |= UNSMARK;
-			break;
-		case UNARY:
-			rtype = v1.type;
-			break;
-		case LOGIC:
-		case SPCL:
-			break;
-		}
-		switch (oper) {
-		case EQ: case EQ|UNSMARK:
-			rv1 = rv1==rv2; break;
-		case NEQ: case NEQ|UNSMARK:
-			rv1 = rv1!=rv2; break;
-		case LEQ:
-			rv1 = rv1<=rv2; break;
-		case GEQ:
-			rv1 = rv1>=rv2; break;
-		case LT:
-			rv1 = rv1<rv2; break;
-		case GT:
-			rv1 = rv1>rv2; break;
-		case LEQ|UNSMARK:
-			rv1 = (unsigned long)rv1<=rv2; break;
-		case GEQ|UNSMARK:
-			rv1 = (unsigned long)rv1>=rv2; break;
-		case LT|UNSMARK:
-			rv1 = (unsigned long)rv1<rv2; break;
-		case GT|UNSMARK:
-			rv1 = (unsigned long)rv1>rv2; break;
-		case LSH:
-			rv1 <<= rv2; break;
-		case LSH|UNSMARK:
-			rv1 = (unsigned long)rv1<<rv2; break;
-		case RSH:
-			rv1 >>= rv2; break;
-		case RSH|UNSMARK:
-			rv1 = (unsigned long)rv1>>rv2; break;
-		case LAND:
-			rtype = UND;
-			if (v1.type==UND)
-				break;
-			if (rv1!=0) {
-				if (v2.type==UND)
-					break;
-				rv1 = rv2!=0;
-			} else
-				rv1 = 0;
-			rtype = SGN;
-			break;
-		case LOR:
-			rtype = UND;
-			if (v1.type==UND)
-				break;
-			if (rv1==0) {
-				if (v2.type==UND)
-					break;
-				rv1 = rv2!=0;
-			} else
-				rv1 = 1;
-			rtype = SGN;
-			break;
-		case AND:
-			rv1 &= rv2; break;
-		case STAR:
-			rv1 *= rv2; break;
-		case PLUS:
-			rv1 += rv2; break;
-		case MINUS:
-			rv1 -= rv2; break;
-		case UMINUS:
-			if (v1.type==UND)
-				rtype = UND;
-			rv1 = -rv1; break;
-		case OR:
-			rv1 |= rv2; break;
-		case CIRC:
-			rv1 ^= rv2; break;
-		case TILDE:
-			rv1 = ~rv1; break;
-		case NOT:
-			rv1 = !rv1; if (rtype!=UND) rtype = SGN; break;
-		case SLASH:
-			if (rv2==0) {
-				rtype = UND;
-				break;
-			}
-			if (rtype==UNS)
-				rv1 /= (unsigned long)rv2;
-			else
-				rv1 /= rv2;
-			break;
-		case PCT:
-			if (rv2==0) {
-				rtype = UND;
-				break;
-			}
-			if (rtype==UNS)
-				rv1 %= (unsigned long)rv2;
-			else
-				rv1 %= rv2;
-			break;
-		case COLON:
-			if (op[-1] != QUEST)
-				error(ERROR, "Bad ?: in #if/endif");
-			else {
-				op--;
-				if ((--vp)->val==0)
-					v1 = v2;
-				rtype = v1.type;
-				rv1 = v1.val;
-			}
-			break;
-		case DEFINED:
-			break;
-		default:
-			error(ERROR, "Eval botch (unknown operator)");
-			return 1;
-		}
-/*lint +e574 +e644 */
-		v1.val = rv1;
-		v1.type = rtype;
-		*vp++ = v1;
-	}
-	return 0;
-}
-
-struct value
-tokval(Token *tp)
-{
-	struct value v;
-	Nlist *np;
-	int i, base, c;
-	unsigned long n;
-	uchar *p;
-
-	v.type = SGN;
-	v.val = 0;
-	switch (tp->type) {
-
-	case NAME:
-		v.val = 0;
-		break;
-
-	case NAME1:
-		if ((np = lookup(tp, 0)) != NULL && np->flag&(ISDEFINED|ISMAC))
-			v.val = 1;
-		break;
-
-	case NUMBER:
-		n = 0;
-		base = 10;
-		p = tp->t;
-		c = p[tp->len];
-		p[tp->len] = '\0';
-		if (*p=='0') {
-			base = 8;
-			if (p[1]=='x' || p[1]=='X') {
-				base = 16;
-				p++;
-			}
-			p++;
-		}
-		for (;; p++) {
-			if ((i = digit(*p)) < 0)
-				break;
-			if (i>=base)
-				error(WARNING,
-				  "Bad digit in number %t", tp);
-			n *= base;
-			n += i;
-		}
-		if (n>=0x80000000 && base!=10)
-			v.type = UNS;
-		for (; *p; p++) {
-			if (*p=='u' || *p=='U')
-				v.type = UNS;
-			else if (*p=='l' || *p=='L')
-				;
-			else {
-				error(ERROR,
-				  "Bad number %t in #if/#elsif", tp);
-				break;
-			}
-		}
-		v.val = n;
-		tp->t[tp->len] = c;
-		break;
-
-	case CCON:
-		n = 0;
-		p = tp->t;
-		if (*p=='L') {
-			p += 1;
-			error(WARNING, "Wide char constant value undefined");
-		}
-		p += 1;
-		if (*p=='\\') {
-			p += 1;
-			if ((i = digit(*p))>=0 && i<=7) {
-				n = i;
-				p += 1;
-				if ((i = digit(*p))>=0 && i<=7) {
-					p += 1;
-					n <<= 3;
-					n += i;
-					if ((i = digit(*p))>=0 && i<=7) {
-						p += 1;
-						n <<= 3;
-						n += i;
-					}
-				}
-			} else if (*p=='x') {
-				p += 1;
-				while ((i = digit(*p))>=0 && i<=15) {
-					p += 1;
-					n <<= 4;
-					n += i;
-				}
-			} else {
-				static char cvcon[]
-				  = "b\bf\fn\nr\rt\tv\v''\"\"??\\\\";
-				for (i=0; i<sizeof(cvcon); i+=2) {
-					if (*p == cvcon[i]) {
-						n = cvcon[i+1];
-						break;
-					}
-				}
-				p += 1;
-				if (i>=sizeof(cvcon))
-					error(WARNING,
-					 "Undefined escape in character constant");
-			}
-		} else if (*p=='\'')
-			error(ERROR, "Empty character constant");
-		else
-			n = *p++;
-		if (*p!='\'')
-			error(WARNING, "Multibyte character constant undefined");
-		else if (n>127)
-			error(WARNING, "Character constant taken as not signed");
-		v.val = n;
-		break;
-
-	case STRING:
-		error(ERROR, "String in #if/#elsif");
-		break;
-	}
-	return v;
-}
-
-int
-digit(int i)
-{
-	if ('0'<=i && i<='9')
-		i -= '0';
-	else if ('a'<=i && i<='f')
-		i -= 'a'-10;
-	else if ('A'<=i && i<='F')
-		i -= 'A'-10;
-	else
-		i = -1;
-	return i;
-}
diff --git a/lcc/cpp/getopt.c b/lcc/cpp/getopt.c
deleted file mode 100644
index abcb35f..0000000
--- a/lcc/cpp/getopt.c
+++ /dev/null
@@ -1,53 +0,0 @@
-#include	<stdio.h>
-#include	<string.h>
-#define EPR                 fprintf(stderr,
-#define ERR(str, chr)       if(opterr){EPR "%s%c\n", str, chr);}
-int     opterr = 1;
-int     optind = 1;
-int	optopt;
-char    *optarg;
-
-int
-getopt (int argc, char *const argv[], const char *opts)
-{
-	static int sp = 1;
-	int c;
-	char *cp;
-
-	if (sp == 1) {
-		if (optind >= argc ||
-		   argv[optind][0] != '-' || argv[optind][1] == '\0')
-			return -1;
-		else if (strcmp(argv[optind], "--") == 0) {
-			optind++;
-			return -1;
-		}
-	}
-	optopt = c = argv[optind][sp];
-	if (c == ':' || (cp=strchr(opts, c)) == 0) {
-		ERR (": illegal option -- ", c);
-		if (argv[optind][++sp] == '\0') {
-			optind++;
-			sp = 1;
-		}
-		return '?';
-	}
-	if (*++cp == ':') {
-		if (argv[optind][sp+1] != '\0')
-			optarg = &argv[optind++][sp+1];
-		else if (++optind >= argc) {
-			ERR (": option requires an argument -- ", c);
-			sp = 1;
-			return '?';
-		} else
-			optarg = argv[optind++];
-		sp = 1;
-	} else {
-		if (argv[optind][++sp] == '\0') {
-			sp = 1;
-			optind++;
-		}
-		optarg = 0;
-	}
-	return c;
-}
diff --git a/lcc/cpp/hideset.c b/lcc/cpp/hideset.c
deleted file mode 100644
index bd2540d..0000000
--- a/lcc/cpp/hideset.c
+++ /dev/null
@@ -1,112 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "cpp.h"
-
-/*
- * A hideset is a null-terminated array of Nlist pointers.
- * They are referred to by indices in the hidesets array.
- * Hideset 0 is empty.
- */
-
-#define	HSSIZ	32
-typedef	Nlist	**Hideset;
-Hideset	*hidesets;
-int	nhidesets = 0;
-int	maxhidesets = 3;
-int	inserths(Hideset, Hideset, Nlist *);
-
-/*
- * Test for membership in a hideset
- */
-int
-checkhideset(int hs, Nlist *np)
-{
-	Hideset hsp;
-
-	if (hs>=nhidesets)
-		abort();
-	for (hsp = hidesets[hs]; *hsp; hsp++) {
-		if (*hsp == np)
-			return 1;
-	}
-	return 0;
-}
-
-/*
- * Return the (possibly new) hideset obtained by adding np to hs.
- */
-int
-newhideset(int hs, Nlist *np)
-{
-	int i, len;
-	Nlist *nhs[HSSIZ+3];
-	Hideset hs1, hs2;
-
-	len = inserths(nhs, hidesets[hs], np);
-	for (i=0; i<nhidesets; i++) {
-		for (hs1=nhs, hs2=hidesets[i]; *hs1==*hs2; hs1++, hs2++)
-			if (*hs1 == NULL)
-				return i;
-	}
-	if (len>=HSSIZ)
-		return hs;
-	if (nhidesets >= maxhidesets) {
-		maxhidesets = 3*maxhidesets/2+1;
-		hidesets = (Hideset *)realloc(hidesets, (sizeof (Hideset *))*maxhidesets);
-		if (hidesets == NULL)
-			error(FATAL, "Out of memory from realloc");
-	}
-	hs1 = (Hideset)domalloc(len*sizeof(Hideset));
-	memmove(hs1, nhs, len*sizeof(Hideset));
-	hidesets[nhidesets] = hs1;
-	return nhidesets++;
-}
-
-int
-inserths(Hideset dhs, Hideset shs, Nlist *np)
-{
-	Hideset odhs = dhs;
-
-	while (*shs && *shs < np)
-		*dhs++ = *shs++;
-	if (*shs != np)
-		*dhs++ = np;
-	do {
-		*dhs++ = *shs;
-	} while (*shs++);
-	return dhs - odhs;
-}
-
-/*
- * Hideset union
- */
-int
-unionhideset(int hs1, int hs2)
-{
-	Hideset hp;
-
-	for (hp = hidesets[hs2]; *hp; hp++)
-		hs1 = newhideset(hs1, *hp);
-	return hs1;
-}
-
-void
-iniths(void)
-{
-	hidesets = (Hideset *)domalloc(maxhidesets*sizeof(Hideset *));
-	hidesets[0] = (Hideset)domalloc(sizeof(Hideset));
-	*hidesets[0] = NULL;
-	nhidesets++;
-}
-
-void
-prhideset(int hs)
-{
-	Hideset np;
-
-	for (np = hidesets[hs]; *np; np++) {
-		fprintf(stderr, (char*)(*np)->name, (*np)->len);
-		fprintf(stderr, " ");
-	}
-}
diff --git a/lcc/cpp/include.c b/lcc/cpp/include.c
deleted file mode 100644
index b3757e8..0000000
--- a/lcc/cpp/include.c
+++ /dev/null
@@ -1,122 +0,0 @@
-#include <stdlib.h>
-#include <string.h>
-#include "cpp.h"
-
-Includelist	includelist[NINCLUDE];
-
-extern char	*objname;
-
-void
-doinclude(Tokenrow *trp)
-{
-	char fname[256], iname[256];
-	Includelist *ip;
-	int angled, len, fd, i;
-
-	trp->tp += 1;
-	if (trp->tp>=trp->lp)
-		goto syntax;
-	if (trp->tp->type!=STRING && trp->tp->type!=LT) {
-		len = trp->tp - trp->bp;
-		expandrow(trp, "<include>");
-		trp->tp = trp->bp+len;
-	}
-	if (trp->tp->type==STRING) {
-		len = trp->tp->len-2;
-		if (len > sizeof(fname) - 1)
-			len = sizeof(fname) - 1;
-		strncpy(fname, (char*)trp->tp->t+1, len);
-		angled = 0;
-	} else if (trp->tp->type==LT) {
-		len = 0;
-		trp->tp++;
-		while (trp->tp->type!=GT) {
-			if (trp->tp>trp->lp || len+trp->tp->len+2 >= sizeof(fname))
-				goto syntax;
-			strncpy(fname+len, (char*)trp->tp->t, trp->tp->len);
-			len += trp->tp->len;
-			trp->tp++;
-		}
-		angled = 1;
-	} else
-		goto syntax;
-	trp->tp += 2;
-	if (trp->tp < trp->lp || len==0)
-		goto syntax;
-	fname[len] = '\0';
-	if (fname[0]=='/') {
-		fd = open(fname, 0);
-		strcpy(iname, fname);
-	} else for (fd = -1,i=NINCLUDE-1; i>=0; i--) {
-		ip = &includelist[i];
-		if (ip->file==NULL || ip->deleted || (angled && ip->always==0))
-			continue;
-		if (strlen(fname)+strlen(ip->file)+2 > sizeof(iname))
-			continue;
-		strcpy(iname, ip->file);
-		strcat(iname, "/");
-		strcat(iname, fname);
-		if ((fd = open(iname, 0)) >= 0)
-			break;
-	}
-	if ( Mflag>1 || (!angled&&Mflag==1) ) {
-		write(1,objname,strlen(objname));
-		write(1,iname,strlen(iname));
-		write(1,"\n",1);
-	}
-	if (fd >= 0) {
-		if (++incdepth > 10)
-			error(FATAL, "#include too deeply nested");
-		setsource((char*)newstring((uchar*)iname, strlen(iname), 0), fd, NULL);
-		genline();
-	} else {
-		trp->tp = trp->bp+2;
-		error(ERROR, "Could not find include file %r", trp);
-	}
-	return;
-syntax:
-	error(ERROR, "Syntax error in #include");
-	return;
-}
-
-/*
- * Generate a line directive for cursource
- */
-void
-genline(void)
-{
-	static Token ta = { UNCLASS };
-	static Tokenrow tr = { &ta, &ta, &ta+1, 1 };
-	uchar *p;
-
-	ta.t = p = (uchar*)outp;
-	strcpy((char*)p, "#line ");
-	p += sizeof("#line ")-1;
-	p = (uchar*)outnum((char*)p, cursource->line);
-	*p++ = ' '; *p++ = '"';
-	if (cursource->filename[0]!='/' && wd[0]) {
-		strcpy((char*)p, wd);
-		p += strlen(wd);
-		*p++ = '/';
-	}
-	strcpy((char*)p, cursource->filename);
-	p += strlen((char*)p);
-	*p++ = '"'; *p++ = '\n';
-	ta.len = (char*)p-outp;
-	outp = (char*)p;
-	tr.tp = tr.bp;
-	puttokens(&tr);
-}
-
-void
-setobjname(char *f)
-{
-	int n = strlen(f);
-	objname = (char*)domalloc(n+5);
-	strcpy(objname,f);
-	if(objname[n-2]=='.'){
-		strcpy(objname+n-1,"$O: ");
-	}else{
-		strcpy(objname+n,"$O: ");
-	}
-}
diff --git a/lcc/cpp/lex.c b/lcc/cpp/lex.c
deleted file mode 100644
index 8030354..0000000
--- a/lcc/cpp/lex.c
+++ /dev/null
@@ -1,580 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "cpp.h"
-
-/*
- * lexical FSM encoding
- *   when in state state, and one of the characters
- *   in ch arrives, enter nextstate.
- *   States >= S_SELF are either final, or at least require special action.
- *   In 'fsm' there is a line for each state X charset X nextstate.
- *   List chars that overwrite previous entries later (e.g. C_ALPH
- *   can be overridden by '_' by a later entry; and C_XX is the
- *   the universal set, and should always be first.
- *   States above S_SELF are represented in the big table as negative values.
- *   S_SELF and S_SELFB encode the resulting token type in the upper bits.
- *   These actions differ in that S_SELF doesn't have a lookahead char,
- *   S_SELFB does.
- *
- *   The encoding is blown out into a big table for time-efficiency.
- *   Entries have
- *      nextstate: 6 bits; ?\ marker: 1 bit; tokentype: 9 bits.
- */
-
-#define	MAXSTATE 32
-#define	ACT(tok,act)	((tok<<7)+act)
-#define	QBSBIT	0100
-#define	GETACT(st)	(st>>7)&0x1ff
-
-/* character classes */
-#define	C_WS	1
-#define	C_ALPH	2
-#define	C_NUM	3
-#define	C_EOF	4
-#define	C_XX	5
-
-enum state {
-	START=0, NUM1, NUM2, NUM3, ID1, ST1, ST2, ST3, COM1, COM2, COM3, COM4,
-	CC1, CC2, WS1, PLUS1, MINUS1, STAR1, SLASH1, PCT1, SHARP1,
-	CIRC1, GT1, GT2, LT1, LT2, OR1, AND1, ASG1, NOT1, DOTS1,
-	S_SELF=MAXSTATE, S_SELFB, S_EOF, S_NL, S_EOFSTR,
-	S_STNL, S_COMNL, S_EOFCOM, S_COMMENT, S_EOB, S_WS, S_NAME
-};
-
-int	tottok;
-int	tokkind[256];
-struct	fsm {
-	int	state;		/* if in this state */
-	uchar	ch[4];		/* and see one of these characters */
-	int	nextstate;	/* enter this state if +ve */
-};
-
-/*const*/ struct fsm fsm[] = {
-	/* start state */
-	{START,	{ C_XX },	ACT(UNCLASS,S_SELF)},
-	{START,	{ ' ', '\t', '\v' },	WS1},
-	{START,	{ C_NUM },	NUM1},
-	{START,	{ '.' },	NUM3},
-	{START,	{ C_ALPH },	ID1},
-	{START,	{ 'L' },	ST1},
-	{START,	{ '"' },	ST2},
-	{START,	{ '\'' },	CC1},
-	{START,	{ '/' },	COM1},
-	{START,	{ EOFC },	S_EOF},
-	{START,	{ '\n' },	S_NL},
-	{START,	{ '-' },	MINUS1},
-	{START,	{ '+' },	PLUS1},
-	{START,	{ '<' },	LT1},
-	{START,	{ '>' },	GT1},
-	{START,	{ '=' },	ASG1},
-	{START,	{ '!' },	NOT1},
-	{START,	{ '&' },	AND1},
-	{START,	{ '|' },	OR1},
-	{START,	{ '#' },	SHARP1},
-	{START,	{ '%' },	PCT1},
-	{START,	{ '[' },	ACT(SBRA,S_SELF)},
-	{START,	{ ']' },	ACT(SKET,S_SELF)},
-	{START,	{ '(' },	ACT(LP,S_SELF)},
-	{START,	{ ')' },	ACT(RP,S_SELF)},
-	{START,	{ '*' },	STAR1},
-	{START,	{ ',' },	ACT(COMMA,S_SELF)},
-	{START,	{ '?' },	ACT(QUEST,S_SELF)},
-	{START,	{ ':' },	ACT(COLON,S_SELF)},
-	{START,	{ ';' },	ACT(SEMIC,S_SELF)},
-	{START,	{ '{' },	ACT(CBRA,S_SELF)},
-	{START,	{ '}' },	ACT(CKET,S_SELF)},
-	{START,	{ '~' },	ACT(TILDE,S_SELF)},
-	{START,	{ '^' },	CIRC1},
-
-	/* saw a digit */
-	{NUM1,	{ C_XX },	ACT(NUMBER,S_SELFB)},
-	{NUM1,	{ C_NUM, C_ALPH, '.' },	NUM1},
-	{NUM1,	{ 'E', 'e' },	NUM2},
-	{NUM1,	{ '_' },	ACT(NUMBER,S_SELFB)},
-
-	/* saw possible start of exponent, digits-e */
-	{NUM2,	{ C_XX },	ACT(NUMBER,S_SELFB)},
-	{NUM2,	{ '+', '-' },	NUM1},
-	{NUM2,	{ C_NUM, C_ALPH },	NUM1},
-	{NUM2,	{ '_' },	ACT(NUMBER,S_SELFB)},
-
-	/* saw a '.', which could be a number or an operator */
-	{NUM3,	{ C_XX },	ACT(DOT,S_SELFB)},
-	{NUM3,	{ '.' },	DOTS1},
-	{NUM3,	{ C_NUM },	NUM1},
-
-	{DOTS1,	{ C_XX },	ACT(UNCLASS, S_SELFB)},
-	{DOTS1,	{ C_NUM },	NUM1},
-	{DOTS1,	{ '.' },	ACT(ELLIPS, S_SELF)},
-
-	/* saw a letter or _ */
-	{ID1,	{ C_XX },	ACT(NAME,S_NAME)},
-	{ID1,	{ C_ALPH, C_NUM },	ID1},
-
-	/* saw L (start of wide string?) */
-	{ST1,	{ C_XX },	ACT(NAME,S_NAME)},
-	{ST1,	{ C_ALPH, C_NUM },	ID1},
-	{ST1,	{ '"' },	ST2},
-	{ST1,	{ '\'' },	CC1},
-
-	/* saw " beginning string */
-	{ST2,	{ C_XX },	ST2},
-	{ST2,	{ '"' },	ACT(STRING, S_SELF)},
-	{ST2,	{ '\\' },	ST3},
-	{ST2,	{ '\n' },	S_STNL},
-	{ST2,	{ EOFC },	S_EOFSTR},
-
-	/* saw \ in string */
-	{ST3,	{ C_XX },	ST2},
-	{ST3,	{ '\n' },	S_STNL},
-	{ST3,	{ EOFC },	S_EOFSTR},
-
-	/* saw ' beginning character const */
-	{CC1,	{ C_XX },	CC1},
-	{CC1,	{ '\'' },	ACT(CCON, S_SELF)},
-	{CC1,	{ '\\' },	CC2},
-	{CC1,	{ '\n' },	S_STNL},
-	{CC1,	{ EOFC },	S_EOFSTR},
-
-	/* saw \ in ccon */
-	{CC2,	{ C_XX },	CC1},
-	{CC2,	{ '\n' },	S_STNL},
-	{CC2,	{ EOFC },	S_EOFSTR},
-
-	/* saw /, perhaps start of comment */
-	{COM1,	{ C_XX },	ACT(SLASH, S_SELFB)},
-	{COM1,	{ '=' },	ACT(ASSLASH, S_SELF)},
-	{COM1,	{ '*' },	COM2},
-	{COM1,	{ '/' },	COM4},
-
-	/* saw / then *, start of comment */
-	{COM2,	{ C_XX },	COM2},
-	{COM2,	{ '\n' },	S_COMNL},
-	{COM2,	{ '*' },	COM3},
-	{COM2,	{ EOFC },	S_EOFCOM},
-
-	/* saw the * possibly ending a comment */
-	{COM3,	{ C_XX },	COM2},
-	{COM3,	{ '\n' },	S_COMNL},
-	{COM3,	{ '*' },	COM3},
-	{COM3,	{ '/' },	S_COMMENT},
-
-	/* // comment */
-	{COM4,	{ C_XX },	COM4},
-	{COM4,	{ '\n' },	S_NL},
-	{COM4,	{ EOFC },	S_EOFCOM},
-
-	/* saw white space, eat it up */
-	{WS1,	{ C_XX },	S_WS},
-	{WS1,	{ ' ', '\t', '\v' },	WS1},
-
-	/* saw -, check --, -=, -> */
-	{MINUS1,	{ C_XX },	ACT(MINUS, S_SELFB)},
-	{MINUS1,	{ '-' },	ACT(MMINUS, S_SELF)},
-	{MINUS1,	{ '=' },	ACT(ASMINUS,S_SELF)},
-	{MINUS1,	{ '>' },	ACT(ARROW,S_SELF)},
-
-	/* saw +, check ++, += */
-	{PLUS1,	{ C_XX },	ACT(PLUS, S_SELFB)},
-	{PLUS1,	{ '+' },	ACT(PPLUS, S_SELF)},
-	{PLUS1,	{ '=' },	ACT(ASPLUS, S_SELF)},
-
-	/* saw <, check <<, <<=, <= */
-	{LT1,	{ C_XX },	ACT(LT, S_SELFB)},
-	{LT1,	{ '<' },	LT2},
-	{LT1,	{ '=' },	ACT(LEQ, S_SELF)},
-	{LT2,	{ C_XX },	ACT(LSH, S_SELFB)},
-	{LT2,	{ '=' },	ACT(ASLSH, S_SELF)},
-
-	/* saw >, check >>, >>=, >= */
-	{GT1,	{ C_XX },	ACT(GT, S_SELFB)},
-	{GT1,	{ '>' },	GT2},
-	{GT1,	{ '=' },	ACT(GEQ, S_SELF)},
-	{GT2,	{ C_XX },	ACT(RSH, S_SELFB)},
-	{GT2,	{ '=' },	ACT(ASRSH, S_SELF)},
-
-	/* = */
-	{ASG1,	{ C_XX },	ACT(ASGN, S_SELFB)},
-	{ASG1,	{ '=' },	ACT(EQ, S_SELF)},
-
-	/* ! */
-	{NOT1,	{ C_XX },	ACT(NOT, S_SELFB)},
-	{NOT1,	{ '=' },	ACT(NEQ, S_SELF)},
-
-	/* & */
-	{AND1,	{ C_XX },	ACT(AND, S_SELFB)},
-	{AND1,	{ '&' },	ACT(LAND, S_SELF)},
-	{AND1,	{ '=' },	ACT(ASAND, S_SELF)},
-
-	/* | */
-	{OR1,	{ C_XX },	ACT(OR, S_SELFB)},
-	{OR1,	{ '|' },	ACT(LOR, S_SELF)},
-	{OR1,	{ '=' },	ACT(ASOR, S_SELF)},
-
-	/* # */
-	{SHARP1,	{ C_XX },	ACT(SHARP, S_SELFB)},
-	{SHARP1,	{ '#' },	ACT(DSHARP, S_SELF)},
-
-	/* % */
-	{PCT1,	{ C_XX },	ACT(PCT, S_SELFB)},
-	{PCT1,	{ '=' },	ACT(ASPCT, S_SELF)},
-
-	/* * */
-	{STAR1,	{ C_XX },	ACT(STAR, S_SELFB)},
-	{STAR1,	{ '=' },	ACT(ASSTAR, S_SELF)},
-
-	/* ^ */
-	{CIRC1,	{ C_XX },	ACT(CIRC, S_SELFB)},
-	{CIRC1,	{ '=' },	ACT(ASCIRC, S_SELF)},
-
-	{-1}
-};
-
-/* first index is char, second is state */
-/* increase #states to power of 2 to encourage use of shift */
-short	bigfsm[256][MAXSTATE];
-
-void
-expandlex(void)
-{
-	/*const*/ struct fsm *fp;
-	int i, j, nstate;
-
-	for (fp = fsm; fp->state>=0; fp++) {
-		for (i=0; fp->ch[i]; i++) {
-			nstate = fp->nextstate;
-			if (nstate >= S_SELF)
-				nstate = ~nstate;
-			switch (fp->ch[i]) {
-
-			case C_XX:		/* random characters */
-				for (j=0; j<256; j++)
-					bigfsm[j][fp->state] = nstate;
-				continue;
-			case C_ALPH:
-				for (j=0; j<=256; j++)
-					if (('a'<=j&&j<='z') || ('A'<=j&&j<='Z')
-					  || j=='_')
-						bigfsm[j][fp->state] = nstate;
-				continue;
-			case C_NUM:
-				for (j='0'; j<='9'; j++)
-					bigfsm[j][fp->state] = nstate;
-				continue;
-			default:
-				bigfsm[fp->ch[i]][fp->state] = nstate;
-			}
-		}
-	}
-	/* install special cases for ? (trigraphs),  \ (splicing), runes, and EOB */
-	for (i=0; i<MAXSTATE; i++) {
-		for (j=0; j<0xFF; j++)
-			if (j=='?' || j=='\\') {
-				if (bigfsm[j][i]>0)
-					bigfsm[j][i] = ~bigfsm[j][i];
-				bigfsm[j][i] &= ~QBSBIT;
-			}
-		bigfsm[EOB][i] = ~S_EOB;
-		if (bigfsm[EOFC][i]>=0)
-			bigfsm[EOFC][i] = ~S_EOF;
-	}
-}
-
-void
-fixlex(void)
-{
-	/* do C++ comments? */
-	if (Cplusplus==0)
-		bigfsm['/'][COM1] = bigfsm['x'][COM1];
-}
-
-/*
- * fill in a row of tokens from input, terminated by NL or END
- * First token is put at trp->lp.
- * Reset is non-zero when the input buffer can be "rewound."
- * The value is a flag indicating that possible macros have
- * been seen in the row.
- */
-int
-gettokens(Tokenrow *trp, int reset)
-{
-	register int c, state, oldstate;
-	register uchar *ip;
-	register Token *tp, *maxp;
-	int runelen;
-	Source *s = cursource;
-	int nmac = 0;
-
-	tp = trp->lp;
-	ip = s->inp;
-	if (reset) {
-		s->lineinc = 0;
-		if (ip>=s->inl) {		/* nothing in buffer */
-			s->inl = s->inb;
-			fillbuf(s);
-			ip = s->inp = s->inb;
-		} else if (ip >= s->inb+(3*INS/4)) {
-			memmove(s->inb, ip, 4+s->inl-ip);
-			s->inl = s->inb+(s->inl-ip);
-			ip = s->inp = s->inb;
-		}
-	}
-	maxp = &trp->bp[trp->max];
-	runelen = 1;
-	for (;;) {
-	   continue2:
-		if (tp>=maxp) {
-			trp->lp = tp;
-			tp = growtokenrow(trp);
-			maxp = &trp->bp[trp->max];
-		}
-		tp->type = UNCLASS;
-		tp->hideset = 0;
-		tp->t = ip;
-		tp->wslen = 0;
-		tp->flag = 0;
-		state = START;
-		for (;;) {
-			oldstate = state;
-			c = *ip;
-			if ((state = bigfsm[c][state]) >= 0) {
-				ip += runelen;
-				runelen = 1;
-				continue;
-			}
-			state = ~state;
-		reswitch:
-			switch (state&0177) {
-			case S_SELF:
-				ip += runelen;
-				runelen = 1;
-			case S_SELFB:
-				tp->type = GETACT(state);
-				tp->len = ip - tp->t;
-				tp++;
-				goto continue2;
-
-			case S_NAME:	/* like S_SELFB but with nmac check */
-				tp->type = NAME;
-				tp->len = ip - tp->t;
-				nmac |= quicklook(tp->t[0], tp->len>1?tp->t[1]:0);
-				tp++;
-				goto continue2;
-
-			case S_WS:
-				tp->wslen = ip - tp->t;
-				tp->t = ip;
-				state = START;
-				continue;
-
-			default:
-				if ((state&QBSBIT)==0) {
-					ip += runelen;
-					runelen = 1;
-					continue;
-				}
-				state &= ~QBSBIT;
-				s->inp = ip;
-				if (c=='?') { 	/* check trigraph */
-					if (trigraph(s)) {
-						state = oldstate;
-						continue;
-					}
-					goto reswitch;
-				}
-				if (c=='\\') { /* line-folding */
-					if (foldline(s)) {
-						s->lineinc++;
-						state = oldstate;
-						continue;
-					}
-					goto reswitch;
-				}
-				error(WARNING, "Lexical botch in cpp");
-				ip += runelen;
-				runelen = 1;
-				continue;
-
-			case S_EOB:
-				s->inp = ip;
-				fillbuf(cursource);
-				state = oldstate;
-				continue;
-
-			case S_EOF:
-				tp->type = END;
-				tp->len = 0;
-				s->inp = ip;
-				if (tp!=trp->bp && (tp-1)->type!=NL && cursource->fd!=-1)
-					error(WARNING,"No newline at end of file");
-				trp->lp = tp+1;
-				return nmac;
-
-			case S_STNL:
-				error(ERROR, "Unterminated string or char const");
-			case S_NL:
-				tp->t = ip;
-				tp->type = NL;
-				tp->len = 1;
-				tp->wslen = 0;
-				s->lineinc++;
-				s->inp = ip+1;
-				trp->lp = tp+1;
-				return nmac;
-
-			case S_EOFSTR:
-				error(FATAL, "EOF in string or char constant");
-				break;
-
-			case S_COMNL:
-				s->lineinc++;
-				state = COM2;
-				ip += runelen;
-				runelen = 1;
-				if (ip >= s->inb+(7*INS/8)) { /* very long comment */
-					memmove(tp->t, ip, 4+s->inl-ip);
-					s->inl -= ip-tp->t;
-					ip = tp->t+1;
-				}
-				continue;
-
-			case S_EOFCOM:
-				error(WARNING, "EOF inside comment");
-				--ip;
-			case S_COMMENT:
-				++ip;
-				tp->t = ip;
-				tp->t[-1] = ' ';
-				tp->wslen = 1;
-				state = START;
-				continue;
-			}
-			break;
-		}
-		ip += runelen;
-		runelen = 1;
-		tp->len = ip - tp->t;
-		tp++;
-	}
-}
-
-/* have seen ?; handle the trigraph it starts (if any) else 0 */
-int
-trigraph(Source *s)
-{
-	int c;
-
-	while (s->inp+2 >= s->inl && fillbuf(s)!=EOF)
-		;
-	if (s->inp[1]!='?')
-		return 0;
-	c = 0;
-	switch(s->inp[2]) {
-	case '=':
-		c = '#'; break;
-	case '(':
-		c = '['; break;
-	case '/':
-		c = '\\'; break;
-	case ')':
-		c = ']'; break;
-	case '\'':
-		c = '^'; break;
-	case '<':
-		c = '{'; break;
-	case '!':
-		c = '|'; break;
-	case '>':
-		c = '}'; break;
-	case '-':
-		c = '~'; break;
-	}
-	if (c) {
-		*s->inp = c;
-		memmove(s->inp+1, s->inp+3, s->inl-s->inp+2);
-		s->inl -= 2;
-	}
-	return c;
-}
-
-int
-foldline(Source *s)
-{
-	while (s->inp+1 >= s->inl && fillbuf(s)!=EOF)
-		;
-	if (s->inp[1] == '\n') {
-		memmove(s->inp, s->inp+2, s->inl-s->inp+3);
-		s->inl -= 2;
-		return 1;
-	}
-	return 0;
-}
-
-int
-fillbuf(Source *s)
-{
-	int n, nr;
-
-	nr = INS/8;
-	if ((char *)s->inl+nr > (char *)s->inb+INS)
-		error(FATAL, "Input buffer overflow");
-	if (s->fd<0 || (n=read(s->fd, (char *)s->inl, INS/8)) <= 0)
-		n = 0;
-	if ((*s->inp&0xff) == EOB) /* sentinel character appears in input */
-		*s->inp = EOFC;
-	s->inl += n;
-	s->inl[0] = s->inl[1]= s->inl[2]= s->inl[3] = EOB;
-	if (n==0) {
-		s->inl[0] = s->inl[1]= s->inl[2]= s->inl[3] = EOFC;
-		return EOF;
-	}
-	return 0;
-}
-
-/*
- * Push down to new source of characters.
- * If fd>0 and str==NULL, then from a file `name';
- * if fd==-1 and str, then from the string.
- */
-Source *
-setsource(char *name, int fd, char *str)
-{
-	Source *s = new(Source);
-	int len;
-
-	s->line = 1;
-	s->lineinc = 0;
-	s->fd = fd;
-	s->filename = name;
-	s->next = cursource;
-	s->ifdepth = 0;
-	cursource = s;
-	/* slop at right for EOB */
-	if (str) {
-		len = strlen(str);
-		s->inb = domalloc(len+4);
-		s->inp = s->inb;
-		strncpy((char *)s->inp, str, len);
-	} else {
-		s->inb = domalloc(INS+4);
-		s->inp = s->inb;
-		len = 0;
-	}
-	s->inl = s->inp+len;
-	s->inl[0] = s->inl[1] = EOB;
-	return s;
-}
-
-void
-unsetsource(void)
-{
-	Source *s = cursource;
-
-	if (s->fd>=0) {
-		close(s->fd);
-		dofree(s->inb);
-	}
-	cursource = s->next;
-	dofree(s);
-}
diff --git a/lcc/cpp/macro.c b/lcc/cpp/macro.c
deleted file mode 100644
index 49d1129..0000000
--- a/lcc/cpp/macro.c
+++ /dev/null
@@ -1,515 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "cpp.h"
-
-/*
- * do a macro definition.  tp points to the name being defined in the line
- */
-void
-dodefine(Tokenrow *trp)
-{
-	Token *tp;
-	Nlist *np;
-	Tokenrow *def, *args;
-
-	tp = trp->tp+1;
-	if (tp>=trp->lp || tp->type!=NAME) {
-		error(ERROR, "#defined token is not a name");
-		return;
-	}
-	np = lookup(tp, 1);
-	if (np->flag&ISUNCHANGE) {
-		error(ERROR, "#defined token %t can't be redefined", tp);
-		return;
-	}
-	/* collect arguments */
-	tp += 1;
-	args = NULL;
-	if (tp<trp->lp && tp->type==LP && tp->wslen==0) {
-		/* macro with args */
-		int narg = 0;
-		tp += 1;
-		args = new(Tokenrow);
-		maketokenrow(2, args);
-		if (tp->type!=RP) {
-			int err = 0;
-			for (;;) {
-				Token *atp;
-				if (tp->type!=NAME) {
-					err++;
-					break;
-				}
-				if (narg>=args->max)
-					growtokenrow(args);
-				for (atp=args->bp; atp<args->lp; atp++)
-					if (atp->len==tp->len
-					 && strncmp((char*)atp->t, (char*)tp->t, tp->len)==0)
-						error(ERROR, "Duplicate macro argument");
-				*args->lp++ = *tp;
-				narg++;
-				tp += 1;
-				if (tp->type==RP)
-					break;
-				if (tp->type!=COMMA) {
-					err++;
-					break;
-				}
-				tp += 1;
-			}
-			if (err) {
-				error(ERROR, "Syntax error in macro parameters");
-				return;
-			}
-		}
-		tp += 1;
-	}
-	trp->tp = tp;
-	if (((trp->lp)-1)->type==NL)
-		trp->lp -= 1;
-	def = normtokenrow(trp);
-	if (np->flag&ISDEFINED) {
-		if (comparetokens(def, np->vp)
-		 || (np->ap==NULL) != (args==NULL)
-		 || (np->ap && comparetokens(args, np->ap)))
-			error(ERROR, "Macro redefinition of %t", trp->bp+2);
-	}
-	if (args) {
-		Tokenrow *tap;
-		tap = normtokenrow(args);
-		dofree(args->bp);
-		args = tap;
-	}
-	np->ap = args;
-	np->vp = def;
-	np->flag |= ISDEFINED;
-}
-
-/*
- * Definition received via -D or -U
- */
-void
-doadefine(Tokenrow *trp, int type)
-{
-	Nlist *np;
-	static Token onetoken[1] = {{ NUMBER, 0, 0, 0, 1, (uchar*)"1" }};
-	static Tokenrow onetr = { onetoken, onetoken, onetoken+1, 1 };
-
-	trp->tp = trp->bp;
-	if (type=='U') {
-		if (trp->lp-trp->tp != 2 || trp->tp->type!=NAME)
-			goto syntax;
-		if ((np = lookup(trp->tp, 0)) == NULL)
-			return;
-		np->flag &= ~ISDEFINED;
-		return;
-	}
-	if (trp->tp >= trp->lp || trp->tp->type!=NAME)
-		goto syntax;
-	np = lookup(trp->tp, 1);
-	np->flag |= ISDEFINED;
-	trp->tp += 1;
-	if (trp->tp >= trp->lp || trp->tp->type==END) {
-		np->vp = &onetr;
-		return;
-	}
-	if (trp->tp->type!=ASGN)
-		goto syntax;
-	trp->tp += 1;
-	if ((trp->lp-1)->type == END)
-		trp->lp -= 1;
-	np->vp = normtokenrow(trp);
-	return;
-syntax:
-	error(FATAL, "Illegal -D or -U argument %r", trp);
-}
-			
-/*
- * Do macro expansion in a row of tokens.
- * Flag is NULL if more input can be gathered.
- */
-void
-expandrow(Tokenrow *trp, char *flag)
-{
-	Token *tp;
-	Nlist *np;
-
-	if (flag)
-		setsource(flag, -1, "");
-	for (tp = trp->tp; tp<trp->lp; ) {
-		if (tp->type!=NAME
-		 || quicklook(tp->t[0], tp->len>1?tp->t[1]:0)==0
-		 || (np = lookup(tp, 0))==NULL
-		 || (np->flag&(ISDEFINED|ISMAC))==0
-		 || (tp->hideset && checkhideset(tp->hideset, np))) {
-			tp++;
-			continue;
-		}
-		trp->tp = tp;
-		if (np->val==KDEFINED) {
-			tp->type = DEFINED;
-			if ((tp+1)<trp->lp && (tp+1)->type==NAME)
-				(tp+1)->type = NAME1;
-			else if ((tp+3)<trp->lp && (tp+1)->type==LP
-			 && (tp+2)->type==NAME && (tp+3)->type==RP)
-				(tp+2)->type = NAME1;
-			else
-				error(ERROR, "Incorrect syntax for `defined'");
-			tp++;
-			continue;
-		}
-		if (np->flag&ISMAC)
-			builtin(trp, np->val);
-		else {
-			expand(trp, np);
-		}
-		tp = trp->tp;
-	}
-	if (flag)
-		unsetsource();
-}
-
-/*
- * Expand the macro whose name is np, at token trp->tp, in the tokenrow.
- * Return trp->tp at the first token next to be expanded
- * (ordinarily the beginning of the expansion)
- */
-void
-expand(Tokenrow *trp, Nlist *np)
-{
-	Tokenrow ntr;
-	int ntokc, narg, i;
-	Token *tp;
-	Tokenrow *atr[NARG+1];
-	int hs;
-
-	copytokenrow(&ntr, np->vp);		/* copy macro value */
-	if (np->ap==NULL)			/* parameterless */
-		ntokc = 1;
-	else {
-		ntokc = gatherargs(trp, atr, &narg);
-		if (narg<0) {			/* not actually a call (no '(') */
-			trp->tp++;
-			return;
-		}
-		if (narg != rowlen(np->ap)) {
-			error(ERROR, "Disagreement in number of macro arguments");
-			trp->tp->hideset = newhideset(trp->tp->hideset, np);
-			trp->tp += ntokc;
-			return;
-		}
-		substargs(np, &ntr, atr);	/* put args into replacement */
-		for (i=0; i<narg; i++) {
-			dofree(atr[i]->bp);
-			dofree(atr[i]);
-		}
-	}
-	doconcat(&ntr);				/* execute ## operators */
-	hs = newhideset(trp->tp->hideset, np);
-	for (tp=ntr.bp; tp<ntr.lp; tp++) {	/* distribute hidesets */
-		if (tp->type==NAME) {
-			if (tp->hideset==0)
-				tp->hideset = hs;
-			else
-				tp->hideset = unionhideset(tp->hideset, hs);
-		}
-	}
-	ntr.tp = ntr.bp;
-	insertrow(trp, ntokc, &ntr);
-	trp->tp -= rowlen(&ntr);
-	dofree(ntr.bp);
-	return;
-}	
-
-/*
- * Gather an arglist, starting in trp with tp pointing at the macro name.
- * Return total number of tokens passed, stash number of args found.
- * trp->tp is not changed relative to the tokenrow.
- */
-int
-gatherargs(Tokenrow *trp, Tokenrow **atr, int *narg)
-{
-	int parens = 1;
-	int ntok = 0;
-	Token *bp, *lp;
-	Tokenrow ttr;
-	int ntokp;
-	int needspace;
-
-	*narg = -1;			/* means that there is no macro call */
-	/* look for the ( */
-	for (;;) {
-		trp->tp++;
-		ntok++;
-		if (trp->tp >= trp->lp) {
-			gettokens(trp, 0);
-			if ((trp->lp-1)->type==END) {
-				trp->lp -= 1;
-				trp->tp -= ntok;
-				return ntok;
-			}
-		}
-		if (trp->tp->type==LP)
-			break;
-		if (trp->tp->type!=NL)
-			return ntok;
-	}
-	*narg = 0;
-	ntok++;
-	ntokp = ntok;
-	trp->tp++;
-	/* search for the terminating ), possibly extending the row */
-	needspace = 0;
-	while (parens>0) {
-		if (trp->tp >= trp->lp)
-			gettokens(trp, 0);
-		if (needspace) {
-			needspace = 0;
-			makespace(trp);
-		}
-		if (trp->tp->type==END) {
-			trp->lp -= 1;
-			trp->tp -= ntok;
-			error(ERROR, "EOF in macro arglist");
-			return ntok;
-		}
-		if (trp->tp->type==NL) {
-			trp->tp += 1;
-			adjustrow(trp, -1);
-			trp->tp -= 1;
-			makespace(trp);
-			needspace = 1;
-			continue;
-		}
-		if (trp->tp->type==LP)
-			parens++;
-		else if (trp->tp->type==RP)
-			parens--;
-		trp->tp++;
-		ntok++;
-	}
-	trp->tp -= ntok;
-	/* Now trp->tp won't move underneath us */
-	lp = bp = trp->tp+ntokp;
-	for (; parens>=0; lp++) {
-		if (lp->type == LP) {
-			parens++;
-			continue;
-		}
-		if (lp->type==RP)
-			parens--;
-		if (lp->type==DSHARP)
-			lp->type = DSHARP1;	/* ## not special in arg */
-		if ((lp->type==COMMA && parens==0) || (parens<0 && (lp-1)->type!=LP)) {
-			if (*narg>=NARG-1)
-				error(FATAL, "Sorry, too many macro arguments");
-			ttr.bp = ttr.tp = bp;
-			ttr.lp = lp;
-			atr[(*narg)++] = normtokenrow(&ttr);
-			bp = lp+1;
-		}
-	}
-	return ntok;
-}
-
-/*
- * substitute the argument list into the replacement string
- *  This would be simple except for ## and #
- */
-void
-substargs(Nlist *np, Tokenrow *rtr, Tokenrow **atr)
-{
-	Tokenrow tatr;
-	Token *tp;
-	int ntok, argno;
-
-	for (rtr->tp=rtr->bp; rtr->tp<rtr->lp; ) {
-		if (rtr->tp->type==SHARP) {	/* string operator */
-			tp = rtr->tp;
-			rtr->tp += 1;
-			if ((argno = lookuparg(np, rtr->tp))<0) {
-				error(ERROR, "# not followed by macro parameter");
-				continue;
-			}
-			ntok = 1 + (rtr->tp - tp);
-			rtr->tp = tp;
-			insertrow(rtr, ntok, stringify(atr[argno]));
-			continue;
-		}
-		if (rtr->tp->type==NAME
-		 && (argno = lookuparg(np, rtr->tp)) >= 0) {
-			if ((rtr->tp+1)->type==DSHARP
-			 || (rtr->tp!=rtr->bp && (rtr->tp-1)->type==DSHARP))
-				insertrow(rtr, 1, atr[argno]);
-			else {
-				copytokenrow(&tatr, atr[argno]);
-				expandrow(&tatr, "<macro>");
-				insertrow(rtr, 1, &tatr);
-				dofree(tatr.bp);
-			}
-			continue;
-		}
-		rtr->tp++;
-	}
-}
-
-/*
- * Evaluate the ## operators in a tokenrow
- */
-void
-doconcat(Tokenrow *trp)
-{
-	Token *ltp, *ntp;
-	Tokenrow ntr;
-	int len;
-
-	for (trp->tp=trp->bp; trp->tp<trp->lp; trp->tp++) {
-		if (trp->tp->type==DSHARP1)
-			trp->tp->type = DSHARP;
-		else if (trp->tp->type==DSHARP) {
-			char tt[128];
-			ltp = trp->tp-1;
-			ntp = trp->tp+1;
-			if (ltp<trp->bp || ntp>=trp->lp) {
-				error(ERROR, "## occurs at border of replacement");
-				continue;
-			}
-			len = ltp->len + ntp->len;
-			strncpy((char*)tt, (char*)ltp->t, ltp->len);
-			strncpy((char*)tt+ltp->len, (char*)ntp->t, ntp->len);
-			tt[len] = '\0';
-			setsource("<##>", -1, tt);
-			maketokenrow(3, &ntr);
-			gettokens(&ntr, 1);
-			unsetsource();
-			if (ntr.lp-ntr.bp!=2 || ntr.bp->type==UNCLASS)
-				error(WARNING, "Bad token %r produced by ##", &ntr);
-			ntr.lp = ntr.bp+1;
-			trp->tp = ltp;
-			makespace(&ntr);
-			insertrow(trp, (ntp-ltp)+1, &ntr);
-			dofree(ntr.bp);
-			trp->tp--;
-		}
-	}
-}
-
-/*
- * tp is a potential parameter name of macro mac;
- * look it up in mac's arglist, and if found, return the
- * corresponding index in the argname array.  Return -1 if not found.
- */
-int
-lookuparg(Nlist *mac, Token *tp)
-{
-	Token *ap;
-
-	if (tp->type!=NAME || mac->ap==NULL)
-		return -1;
-	for (ap=mac->ap->bp; ap<mac->ap->lp; ap++) {
-		if (ap->len==tp->len && strncmp((char*)ap->t,(char*)tp->t,ap->len)==0)
-			return ap - mac->ap->bp;
-	}
-	return -1;
-}
-
-/*
- * Return a quoted version of the tokenrow (from # arg)
- */
-#define	STRLEN	512
-Tokenrow *
-stringify(Tokenrow *vp)
-{
-	static Token t = { STRING };
-	static Tokenrow tr = { &t, &t, &t+1, 1 };
-	Token *tp;
-	uchar s[STRLEN];
-	uchar *sp = s, *cp;
-	int i, instring;
-
-	*sp++ = '"';
-	for (tp = vp->bp; tp < vp->lp; tp++) {
-		instring = tp->type==STRING || tp->type==CCON;
-		if (sp+2*tp->len >= &s[STRLEN-10]) {
-			error(ERROR, "Stringified macro arg is too long");
-			break;
-		}
-		if (tp->wslen && (tp->flag&XPWS)==0)
-			*sp++ = ' ';
-		for (i=0, cp=tp->t; i<tp->len; i++) {	
-			if (instring && (*cp=='"' || *cp=='\\'))
-				*sp++ = '\\';
-			*sp++ = *cp++;
-		}
-	}
-	*sp++ = '"';
-	*sp = '\0';
-	sp = s;
-	t.len = strlen((char*)sp);
-	t.t = newstring(sp, t.len, 0);
-	return &tr;
-}
-
-/*
- * expand a builtin name
- */
-void
-builtin(Tokenrow *trp, int biname)
-{
-	char *op;
-	Token *tp;
-	Source *s;
-
-	tp = trp->tp;
-	trp->tp++;
-	/* need to find the real source */
-	s = cursource;
-	while (s && s->fd==-1)
-		s = s->next;
-	if (s==NULL)
-		s = cursource;
-	/* most are strings */
-	tp->type = STRING;
-	if (tp->wslen) {
-		*outp++ = ' ';
-		tp->wslen = 1;
-	}
-	op = outp;
-	*op++ = '"';
-	switch (biname) {
-
-	case KLINENO:
-		tp->type = NUMBER;
-		op = outnum(op-1, s->line);
-		break;
-
-	case KFILE: {
-		char *src = s->filename;
-		while ((*op++ = *src++) != 0)
-			if (src[-1] == '\\')
-				*op++ = '\\';
-		op--;
-		break;
-		}
-
-	case KDATE:
-		strncpy(op, curtime+4, 7);
-		strncpy(op+7, curtime+20, 4);
-		op += 11;
-		break;
-
-	case KTIME:
-		strncpy(op, curtime+11, 8);
-		op += 8;
-		break;
-
-	default:
-		error(ERROR, "cpp botch: unknown internal macro");
-		return;
-	}
-	if (tp->type==STRING)
-		*op++ = '"';
-	tp->t = (uchar*)outp;
-	tp->len = op - outp;
-	outp = op;
-}
diff --git a/lcc/cpp/nlist.c b/lcc/cpp/nlist.c
deleted file mode 100644
index d857dfa..0000000
--- a/lcc/cpp/nlist.c
+++ /dev/null
@@ -1,104 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "cpp.h"
-
-extern	int getopt(int, char *const *, const char *);
-extern	char	*optarg;
-extern	int	optind;
-extern	int	verbose;
-extern	int	Cplusplus;
-Nlist	*kwdefined;
-char	wd[128];
-
-#define	NLSIZE	128
-
-static Nlist	*nlist[NLSIZE];
-
-struct	kwtab {
-	char	*kw;
-	int	val;
-	int	flag;
-} kwtab[] = {
-	{"if",		KIF,		ISKW},
-	{"ifdef",	KIFDEF,		ISKW},
-	{"ifndef",	KIFNDEF,	ISKW},
-	{"elif",		KELIF,		ISKW},
-	{"else",		KELSE,		ISKW},
-	{"endif",	KENDIF,		ISKW},
-	{"include",	KINCLUDE,	ISKW},
-	{"define",	KDEFINE,	ISKW},
-	{"undef",	KUNDEF,		ISKW},
-	{"line",		KLINE,		ISKW},
-	{"error",	KERROR,		ISKW},
-	{"pragma",	KPRAGMA,	ISKW},
-	{"eval",		KEVAL,		ISKW},
-	{"defined",	KDEFINED,	ISDEFINED+ISUNCHANGE},
-	{"__LINE__",	KLINENO,	ISMAC+ISUNCHANGE},
-	{"__FILE__",	KFILE,		ISMAC+ISUNCHANGE},
-	{"__DATE__",	KDATE,		ISMAC+ISUNCHANGE},
-	{"__TIME__",	KTIME,		ISMAC+ISUNCHANGE},
-	{"__STDC__",	KSTDC,		ISUNCHANGE},
-	{NULL}
-};
-
-unsigned long	namebit[077+1];
-Nlist 	*np;
-
-void
-setup_kwtab(void)
-{
-	struct kwtab *kp;
-	Nlist *np;
-	Token t;
-	static Token deftoken[1] = {{ NAME, 0, 0, 0, 7, (uchar*)"defined" }};
-	static Tokenrow deftr = { deftoken, deftoken, deftoken+1, 1 };
-
-	for (kp=kwtab; kp->kw; kp++) {
-		t.t = (uchar*)kp->kw;
-		t.len = strlen(kp->kw);
-		np = lookup(&t, 1);
-		np->flag = kp->flag;
-		np->val = kp->val;
-		if (np->val == KDEFINED) {
-			kwdefined = np;
-			np->val = NAME;
-			np->vp = &deftr;
-			np->ap = 0;
-		}
-	}
-}
-
-Nlist *
-lookup(Token *tp, int install)
-{
-	unsigned int h;
-	Nlist *np;
-	uchar *cp, *cpe;
-
-	h = 0;
-	for (cp=tp->t, cpe=cp+tp->len; cp<cpe; )
-		h += *cp++;
-	h %= NLSIZE;
-	np = nlist[h];
-	while (np) {
-		if (*tp->t==*np->name && tp->len==np->len 
-		 && strncmp((char*)tp->t, (char*)np->name, tp->len)==0)
-			return np;
-		np = np->next;
-	}
-	if (install) {
-		np = new(Nlist);
-		np->vp = NULL;
-		np->ap = NULL;
-		np->flag = 0;
-		np->val = 0;
-		np->len = tp->len;
-		np->name = newstring(tp->t, tp->len, 0);
-		np->next = nlist[h];
-		nlist[h] = np;
-		quickset(tp->t[0], tp->len>1? tp->t[1]:0);
-		return np;
-	}
-	return NULL;
-}
diff --git a/lcc/cpp/tokens.c b/lcc/cpp/tokens.c
deleted file mode 100644
index 147569b..0000000
--- a/lcc/cpp/tokens.c
+++ /dev/null
@@ -1,370 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "cpp.h"
-
-static char wbuf[2*OBS];
-static char *wbp = wbuf;
-
-/*
- * 1 for tokens that don't need whitespace when they get inserted
- * by macro expansion
- */
-static const char wstab[] = {
-	0,	/* END */
-	0,	/* UNCLASS */
-	0,	/* NAME */
-	0,	/* NUMBER */
-	0,	/* STRING */
-	0,	/* CCON */
-	1,	/* NL */
-	0,	/* WS */
-	0,	/* DSHARP */
-	0,	/* EQ */
-	0,	/* NEQ */
-	0,	/* LEQ */
-	0,	/* GEQ */
-	0,	/* LSH */
-	0,	/* RSH */
-	0,	/* LAND */
-	0,	/* LOR */
-	0,	/* PPLUS */
-	0,	/* MMINUS */
-	0,	/* ARROW */
-	1,	/* SBRA */
-	1,	/* SKET */
-	1,	/* LP */
-	1,	/* RP */
-	0,	/* DOT */
-	0,	/* AND */
-	0,	/* STAR */
-	0,	/* PLUS */
-	0,	/* MINUS */
-	0,	/* TILDE */
-	0,	/* NOT */
-	0,	/* SLASH */
-	0,	/* PCT */
-	0,	/* LT */
-	0,	/* GT */
-	0,	/* CIRC */
-	0,	/* OR */
-	0,	/* QUEST */
-	0,	/* COLON */
-	0,	/* ASGN */
-	1,	/* COMMA */
-	0,	/* SHARP */
-	1,	/* SEMIC */
-	1,	/* CBRA */
-	1,	/* CKET */
-	0,	/* ASPLUS */
- 	0,	/* ASMINUS */
- 	0,	/* ASSTAR */
- 	0,	/* ASSLASH */
- 	0,	/* ASPCT */
- 	0,	/* ASCIRC */
- 	0,	/* ASLSH */
-	0,	/* ASRSH */
- 	0,	/* ASOR */
- 	0,	/* ASAND */
-	0,	/* ELLIPS */
-	0,	/* DSHARP1 */
-	0,	/* NAME1 */
-	0,	/* DEFINED */
-	0,	/* UMINUS */
-};
-
-void
-maketokenrow(int size, Tokenrow *trp)
-{
-	trp->max = size;
-	if (size>0)
-		trp->bp = (Token *)domalloc(size*sizeof(Token));
-	else
-		trp->bp = NULL;
-	trp->tp = trp->bp;
-	trp->lp = trp->bp;
-}
-
-Token *
-growtokenrow(Tokenrow *trp)
-{
-	int ncur = trp->tp - trp->bp;
-	int nlast = trp->lp - trp->bp;
-
-	trp->max = 3*trp->max/2 + 1;
-	trp->bp = (Token *)realloc(trp->bp, trp->max*sizeof(Token));
-	if (trp->bp == NULL)
-		error(FATAL, "Out of memory from realloc");
-	trp->lp = &trp->bp[nlast];
-	trp->tp = &trp->bp[ncur];
-	return trp->lp;
-}
-
-/*
- * Compare a row of tokens, ignoring the content of WS; return !=0 if different
- */
-int
-comparetokens(Tokenrow *tr1, Tokenrow *tr2)
-{
-	Token *tp1, *tp2;
-
-	tp1 = tr1->tp;
-	tp2 = tr2->tp;
-	if (tr1->lp-tp1 != tr2->lp-tp2)
-		return 1;
-	for (; tp1<tr1->lp ; tp1++, tp2++) {
-		if (tp1->type != tp2->type
-		 || (tp1->wslen==0) != (tp2->wslen==0)
-		 || tp1->len != tp2->len
-		 || strncmp((char*)tp1->t, (char*)tp2->t, tp1->len)!=0)
-			return 1;
-	}
-	return 0;
-}
-
-/*
- * replace ntok tokens starting at dtr->tp with the contents of str.
- * tp ends up pointing just beyond the replacement.
- * Canonical whitespace is assured on each side.
- */
-void
-insertrow(Tokenrow *dtr, int ntok, Tokenrow *str)
-{
-	int nrtok = rowlen(str);
-
-	dtr->tp += ntok;
-	adjustrow(dtr, nrtok-ntok);
-	dtr->tp -= ntok;
-	movetokenrow(dtr, str);
-	makespace(dtr);
-	dtr->tp += nrtok;
-	makespace(dtr);
-}
-
-/*
- * make sure there is WS before trp->tp, if tokens might merge in the output
- */
-void
-makespace(Tokenrow *trp)
-{
-	uchar *tt;
-	Token *tp = trp->tp;
-
-	if (tp >= trp->lp)
-		return;
-	if (tp->wslen) {
-		if (tp->flag&XPWS
-		 && (wstab[tp->type] || (trp->tp>trp->bp && wstab[(tp-1)->type]))) {
-			tp->wslen = 0;
-			return;
-		}
-		tp->t[-1] = ' ';
-		return;
-	}
-	if (wstab[tp->type] || (trp->tp>trp->bp && wstab[(tp-1)->type]))
-		return;
-	tt = newstring(tp->t, tp->len, 1);
-	*tt++ = ' ';
-	tp->t = tt;
-	tp->wslen = 1;
-	tp->flag |= XPWS;
-}
-
-/*
- * Copy an entire tokenrow into another, at tp.
- * It is assumed that there is enough space.
- *  Not strictly conforming.
- */
-void
-movetokenrow(Tokenrow *dtr, Tokenrow *str)
-{
-	int nby;
-
-	/* nby = sizeof(Token) * (str->lp - str->bp); */
-	nby = (char *)str->lp - (char *)str->bp;
-	memmove(dtr->tp, str->bp, nby);
-}
-
-/*
- * Move the tokens in a row, starting at tr->tp, rightward by nt tokens;
- * nt may be negative (left move).
- * The row may need to be grown.
- * Non-strictly conforming because of the (char *), but easily fixed
- */
-void
-adjustrow(Tokenrow *trp, int nt)
-{
-	int nby, size;
-
-	if (nt==0)
-		return;
-	size = (trp->lp - trp->bp) + nt;
-	while (size > trp->max)
-		growtokenrow(trp);
-	/* nby = sizeof(Token) * (trp->lp - trp->tp); */
-	nby = (char *)trp->lp - (char *)trp->tp;
-	if (nby)
-		memmove(trp->tp+nt, trp->tp, nby);
-	trp->lp += nt;
-}
-
-/*
- * Copy a row of tokens into the destination holder, allocating
- * the space for the contents.  Return the destination.
- */
-Tokenrow *
-copytokenrow(Tokenrow *dtr, Tokenrow *str)
-{
-	int len = rowlen(str);
-
-	maketokenrow(len, dtr);
-	movetokenrow(dtr, str);
-	dtr->lp += len;
-	return dtr;
-}
-
-/*
- * Produce a copy of a row of tokens.  Start at trp->tp.
- * The value strings are copied as well.  The first token
- * has WS available.
- */
-Tokenrow *
-normtokenrow(Tokenrow *trp)
-{
-	Token *tp;
-	Tokenrow *ntrp = new(Tokenrow);
-	int len;
-
-	len = trp->lp - trp->tp;
-	if (len<=0)
-		len = 1;
-	maketokenrow(len, ntrp);
-	for (tp=trp->tp; tp < trp->lp; tp++) {
-		*ntrp->lp = *tp;
-		if (tp->len) {
-			ntrp->lp->t = newstring(tp->t, tp->len, 1);
-			*ntrp->lp->t++ = ' ';
-			if (tp->wslen)
-				ntrp->lp->wslen = 1;
-		}
-		ntrp->lp++;
-	}
-	if (ntrp->lp > ntrp->bp)
-		ntrp->bp->wslen = 0;
-	return ntrp;
-}
-
-/*
- * Debugging
- */
-void
-peektokens(Tokenrow *trp, char *str)
-{
-	Token *tp;
-
-	tp = trp->tp;
-	flushout();
-	if (str)
-		fprintf(stderr, "%s ", str);
-	if (tp<trp->bp || tp>trp->lp)
-		fprintf(stderr, "(tp offset %d) ", tp-trp->bp);
-	for (tp=trp->bp; tp<trp->lp && tp<trp->bp+32; tp++) {
-		if (tp->type!=NL) {
-			int c = tp->t[tp->len];
-			tp->t[tp->len] = 0;
-			fprintf(stderr, "%s", tp->t);
-			tp->t[tp->len] = c;
-		}
-		if (tp->type==NAME) {
-			fprintf(stderr, tp==trp->tp?"{*":"{");
-			prhideset(tp->hideset);
-			fprintf(stderr, "} ");
-		} else
-			fprintf(stderr, tp==trp->tp?"{%x*} ":"{%x} ", tp->type);
-	}
-	fprintf(stderr, "\n");
-	fflush(stderr);
-}
-
-void
-puttokens(Tokenrow *trp)
-{
-	Token *tp;
-	int len;
-	uchar *p;
-
-	if (verbose)
-		peektokens(trp, "");
-	tp = trp->bp;
-	for (; tp<trp->lp; tp++) {
-		len = tp->len+tp->wslen;
-		p = tp->t-tp->wslen;
-		while (tp<trp->lp-1 && p+len == (tp+1)->t - (tp+1)->wslen) {
-			tp++;
-			len += tp->wslen+tp->len;
-		}
-		if (len>OBS/2) {		/* handle giant token */
-			if (wbp > wbuf)
-				write(1, wbuf, wbp-wbuf);
-			write(1, (char *)p, len);
-			wbp = wbuf;
-		} else {	
-			memcpy(wbp, p, len);
-			wbp += len;
-		}
-		if (wbp >= &wbuf[OBS]) {
-			write(1, wbuf, OBS);
-			if (wbp > &wbuf[OBS])
-				memcpy(wbuf, wbuf+OBS, wbp - &wbuf[OBS]);
-			wbp -= OBS;
-		}
-	}
-	trp->tp = tp;
-	if (cursource->fd==0)
-		flushout();
-}
-
-void
-flushout(void)
-{
-	if (wbp>wbuf) {
-		write(1, wbuf, wbp-wbuf);
-		wbp = wbuf;
-	}
-}
-
-/*
- * turn a row into just a newline
- */
-void
-setempty(Tokenrow *trp)
-{
-	trp->tp = trp->bp;
-	trp->lp = trp->bp+1;
-	*trp->bp = nltoken;
-}
-
-/*
- * generate a number
- */
-char *
-outnum(char *p, int n)
-{
-	if (n>=10)
-		p = outnum(p, n/10);
-	*p++ = n%10 + '0';
-	return p;
-}
-
-/*
- * allocate and initialize a new string from s, of length l, at offset o
- * Null terminated.
- */
-uchar *
-newstring(uchar *s, int l, int o)
-{
-	uchar *ns = (uchar *)domalloc(l+o+1);
-
-	ns[l+o] = '\0';
-	return (uchar*)strncpy((char*)ns+o, (char*)s, l) - o;
-}
diff --git a/lcc/cpp/unix.c b/lcc/cpp/unix.c
deleted file mode 100644
index a845a60..0000000
--- a/lcc/cpp/unix.c
+++ /dev/null
@@ -1,116 +0,0 @@
-#include <stdio.h>
-#include <stddef.h>
-#include <stdlib.h>
-#include <string.h>
-#include "cpp.h"
-
-extern	int getopt(int, char *const *, const char *);
-extern	char	*optarg, rcsid[];
-extern	int	optind;
-int	verbose;
-int	Mflag;	/* only print active include files */
-char	*objname; /* "src.$O: " */
-int	Cplusplus = 1;
-
-void
-setup(int argc, char **argv)
-{
-	int c, fd, i;
-	char *fp, *dp;
-	Tokenrow tr;
-	extern void setup_kwtab(void);
-
-	setup_kwtab();
-	while ((c = getopt(argc, argv, "MNOVv+I:D:U:F:lg")) != -1)
-		switch (c) {
-		case 'N':
-			for (i=0; i<NINCLUDE; i++)
-				if (includelist[i].always==1)
-					includelist[i].deleted = 1;
-			break;
-		case 'I':
-			for (i=NINCLUDE-2; i>=0; i--) {
-				if (includelist[i].file==NULL) {
-					includelist[i].always = 1;
-					includelist[i].file = optarg;
-					break;
-				}
-			}
-			if (i<0)
-				error(FATAL, "Too many -I directives");
-			break;
-		case 'D':
-		case 'U':
-			setsource("<cmdarg>", -1, optarg);
-			maketokenrow(3, &tr);
-			gettokens(&tr, 1);
-			doadefine(&tr, c);
-			unsetsource();
-			break;
-		case 'M':
-			Mflag++;
-			break;
-		case 'v':
-			fprintf(stderr, "%s %s\n", argv[0], rcsid);
-			break;
-		case 'V':
-			verbose++;
-			break;
-		case '+':
-			Cplusplus++;
-			break;
-		default:
-			break;
-		}
-	dp = ".";
-	fp = "<stdin>";
-	fd = 0;
-	if (optind<argc) {
-		if ((fp = strrchr(argv[optind], '/')) != NULL) {
-			int len = fp - argv[optind];
-			dp = (char*)newstring((uchar*)argv[optind], len+1, 0);
-			dp[len] = '\0';
-		}
-		fp = (char*)newstring((uchar*)argv[optind], strlen(argv[optind]), 0);
-		if ((fd = open(fp, 0)) <= 0)
-			error(FATAL, "Can't open input file %s", fp);
-	}
-	if (optind+1<argc) {
-		int fdo = creat(argv[optind+1], 0666);
-		if (fdo<0)
-			error(FATAL, "Can't open output file %s", argv[optind+1]);
-		dup2(fdo, 1);
-	}
-	if(Mflag)
-		setobjname(fp);
-	includelist[NINCLUDE-1].always = 0;
-	includelist[NINCLUDE-1].file = dp;
-	setsource(fp, fd, NULL);
-}
-
-
-
-/* memmove is defined here because some vendors don't provide it at
-   all and others do a terrible job (like calling malloc) */
-void *
-memmove(void *dp, const void *sp, size_t n)
-{
-	unsigned char *cdp, *csp;
-
-	if (n<=0)
-		return 0;
-	cdp = dp;
-	csp = (unsigned char *)sp;
-	if (cdp < csp) {
-		do {
-			*cdp++ = *csp++;
-		} while (--n);
-	} else {
-		cdp += n;
-		csp += n;
-		do {
-			*--cdp = *--csp;
-		} while (--n);
-	}
-	return 0;
-}