shithub: scc

Info  •  Files  •  Log  •  Branches

[scc] Move cc1 cc2 and driver to cmd/scc

--- a/src/cmd/Makefile

+++ b/src/cmd/Makefile

@@ -13,9 +13,13 @@

          $(BINDIR)/addr2line \

 LIBS   = -lmach

+DIRS   = as ld scc

-all: $(TARGET) as ld cc1 cc2

+all: $(TARGET) $(DIRS)

+$(DIRS): FORCE

+	@+cd $@ && $(MAKE)

+

 $(TARGET): $(LIBDIR)/libmach.a

 $(BINDIR)/nm: nm.o

@@ -43,5 +47,8 @@

 	$(CC) $(SCC_LDFLAGS) ar.o $(DRIVER).o -o $@

 dep: inc-dep

+

+clean:

+	$(FORALL)

 include deps.mk

--- a/src/cmd/cc1/Makefile

+++ /dev/null

@@ -1,38 +1,0 @@

-.POSIX:

-

-PROJECTDIR = ../../..

-include $(PROJECTDIR)/scripts/rules.mk

-

-OBJS = types.o \

-       decl.o \

-       lex.o \

-       error.o \

-       symbol.o \

-       main.o \

-       expr.o \

-       code.o \

-       stmt.o \

-       cpp.o \

-       fold.o \

-       init.o \

-       builtin.o \

-

-TARGET   = $(LIBEXEC)/cc1-amd64-sysv \

-           $(LIBEXEC)/cc1-arm64-sysv \

-           $(LIBEXEC)/cc1-i386-sysv \

-           $(LIBEXEC)/cc1-z80-scc \

-

-all: $(TARGET)

-

-$(TARGET): $(LIBDIR)/libscc.a

-

-dep: inc-dep

-

-clean:

-	rm -f target/*/*.o

-

-include target/amd64-sysv/arch.mk

-include target/arm64-sysv/arch.mk

-include target/i386-sysv/arch.mk

-include target/z80-scc/arch.mk

-include deps.mk

--- a/src/cmd/cc1/TODO

+++ /dev/null

@@ -1,14 +1,0 @@

-* Implement bitfields

-* Rewrite error recovery code, and ensure correct state after recovery

-* Parse correctly all integer and float constants

-* Add C99 features (almost all the new features of C99 are missed)

-* Add correct emit for any kind of constant

-* Add warning when some ANSI limit is violated.

-* Free memory in emit after some error happened.

-* Rewrite initializers to deal with the idea of  "current object"

-* Add some test about pointer airthmetic.

-* Merge all the definitions of the same string

-* Do not assign identifierss until symbols are emitted. This change will

-  avoid identifiers that are not emitted.

-* Fix assignation abbreviations. They fail whe lhs type is smaller than

-  the type in rhs

--- a/src/cmd/cc1/builtin.c

+++ /dev/null

@@ -1,121 +1,0 @@

-static char sccsid[] = "@(#) ./cc1/builtin.c";

-

-#include <stdio.h>

-

-#include <scc/scc.h>

-#include "cc1.h"

-

-static Node *

-builtin_va_arg(Symbol *sym)

-{

-	Node *np, *ap;

-	Type *tp;

-

-	ap = assign();

-	expect(',');

-	tp = typename();

-

-	if (!valid_va_list(ap->type)) {

-		errorp("incorrect parameters for va_arg");

-		goto error;

-	}

-	if (tp == booltype ||

-	    tp == chartype || tp == uchartype || tp == schartype ||

-	    tp == shortype || tp == ushortype) {

-		warn("bool, char and short are promoted to int when passed through '...'");

-		tp = (tp->prop & TSIGNED) ? inttype : uinttype;

-	}

-

-	np = node(OBUILTIN, tp, ap, NULL);

-	np->sym = sym;

-	return np;

-

-error:

-	return constnode(zero);

-}

-

-static Node *

-builtin_va_copy(Symbol *sym)

-{

-	Node *np, *src, *dst;

-

-	dst = assign();

-	expect(',');

-	src = assign();

-

-	if (!valid_va_list(dst->type) || !valid_va_list(src->type)) {

-		errorp("incorrect parameters for va_copy");

-		return constnode(zero);

-	}

-

-	np = node(OBUILTIN, voidtype, dst, src);

-	np->sym = sym;

-	return np;

-}

-

-static Node *

-builtin_va_start(Symbol *sym)

-{

-	Node *np, *ap, *last;

-	Symbol **p;

-	Type *tp;

-

-	ap = assign();

-	expect(',');

-	last = assign();

-	if (last->op != OSYM)

-		goto error;

-

-	if (!valid_va_list(ap->type) || !(last->sym->flags&SDECLARED))

-		 goto error;

-

-	for (p = curfun->u.pars; p && *p != last->sym; ++p)

-		;

-	if (!p || *p == NULL || p[1] == NULL || p[1]->type != ellipsistype)

-		warn("second parameter of 'va_start' not last named argument");

-

-	tp = last->type;

-	if (tp == booltype ||

-	    tp == chartype || tp == uchartype || tp == schartype ||

-	    tp == shortype || tp == ushortype) {

-		warn("last parameter before '...' must not be bool, char or short");

-	}

-

-	np = node(OBUILTIN, voidtype, ap, last);

-	np->sym = sym;

-	return np;

-

-error:

-	errorp("incorrect parameters for va_start");

-	return constnode(zero);

-}

-

-static Node *

-builtin_va_end(Symbol *sym)

-{

-	Node *ap, *np;

-

-	ap = assign();

-

-	if (!valid_va_list(ap->type)) {

-		errorp("incorrect parameters for va_end");

-		return constnode(zero);

-	}

-

-	np = node(OBUILTIN, voidtype, ap, NULL);

-	np->sym = sym;

-	return np;

-}

-

-void

-ibuilts(void)

-{

-	struct builtin built[] = {

-		{"__builtin_va_arg", builtin_va_arg},

-		{"__builtin_va_copy", builtin_va_copy},

-		{"__builtin_va_start", builtin_va_start},

-		{"__builtin_va_end", builtin_va_end},

-		{NULL}

-	};

-	builtins(built);

-}

--- a/src/cmd/cc1/cc1.h

+++ /dev/null

@@ -1,496 +1,0 @@

-#define INPUTSIZ LINESIZ

-

-#define GLOBALCTX 0

-#define PARAMCTX  1

-

-#define NR_USWITCHES 20

-

-/*

- * Definition of enumerations

- */

-enum {

-	NOALLOC,

-	ALLOC

-};

-

-enum typeprops {

-	TDEFINED = 1 << 0,    /* type defined */

-	TSIGNED  = 1 << 1,    /* signedness of the type */

-	TINTEGER = 1 << 2,    /* the type is INT of enum */

-	TARITH   = 1 << 3,    /* the type is INT, ENUM or FLOAT */

-	TAGGREG  = 1 << 4,    /* the type is struct or union */

-	TK_R     = 1 << 5,    /* this is a K&R-function */

-	TELLIPSIS= 1 << 6,    /* this function has an ellipsis par */

-	TFUNDEF  = 1 << 7,    /* function definition */

-};

-

-enum inputtype {

-	IMACRO = 1 << 0,      /* macro expansion type */

-	IFILE  = 1 << 1,      /* input file type */

-	ISTDIN = 1 << 2,      /* stdin type */

-	IEOF   = 1 << 3,      /* EOF mark */

-	ITYPE  = IMACRO | IFILE | ISTDIN,

-};

-

-/* data type letters */

-enum ns {

-	L_INT8      = 'C',

-	L_INT16     = 'I',

-	L_INT32     = 'W',

-	L_INT64     = 'Q',

-	L_UINT8     = 'K',

-	L_UINT16    = 'N',

-	L_UINT32    = 'Z',

-	L_UINT64    = 'O',

-	L_BOOL      = 'B',

-

-	L_FLOAT     = 'J',

-	L_DOUBLE    = 'D',

-	L_LDOUBLE   = 'H',

-

-	L_ELLIPSIS  = 'E',

-	L_VOID      = '0',

-	L_POINTER   = 'P',

-	L_FUNCTION  = 'F',

-	L_ARRAY     = 'V',

-	L_UNION     = 'U',

-	L_STRUCT    = 'S',

-	L_VA_ARG    = '1',

-};

-

-/* recovery points */

-enum {

-	END_DECL,

-	END_LDECL,

-	END_COMP,

-	END_COND

-};

-

-/* type constructors */

-enum typeop {

-	FTN = 1,

-	PTR,

-	ARY,

-	KRFTN

-};

-

-/* namespaces */

-enum namespaces {

-	NS_DUMMY,

-	NS_IDEN,

-	NS_TAG,

-	NS_LABEL,

-	NS_CPP,

-	NS_KEYWORD,

-	NS_CPPCLAUSES,

-	NS_STRUCTS

-};

-

-/* symbol flags */

-enum {

-	SAUTO     = 1 << 0,

-	SREGISTER = 1 << 1,

-	SDECLARED = 1 << 2,

-	SFIELD    = 1 << 3,

-	SEXTERN   = 1 << 4,

-	SUSED     = 1 << 5,

-	SCONSTANT = 1 << 6,

-	SGLOBAL   = 1 << 7,

-	SPRIVATE  = 1 << 8,

-	SLOCAL    = 1 << 9,

-	SEMITTED  = 1 << 10,

-	SDEFINED  = 1 << 11,

-	SSTRING   = 1 << 12,

-	STYPEDEF  = 1 << 13,

-	SINITLST  = 1 << 14,

-	SHASINIT  = 1 << 15

-};

-

-/* node flags */

-enum {

-	NLVAL   = 1 << 0,

-	NCONST  = 1 << 1,

-	NEFFECT = 1 << 2

-};

-

-/* lexer mode, compiler or preprocessor directive */

-enum {

-	CCMODE,

-	CPPMODE

-};

-

-/* input tokens */

-enum tokens {

-	CONST      = 1 << 0,      /* type qualifier tokens are used as flags */

-	RESTRICT   = 1 << 1,

-	VOLATILE   = 1 << 2,

-	INLINE     = 1 << 3,

-	TQUALIFIER = 1 << 7,      /* this value is picked outside of ASCII range */

-	TYPE,

-	IDEN,

-	SCLASS,

-	CONSTANT,

-	STRING,

-	SIZEOF,

-	INDIR,

-	INC,

-	DEC,

-	SHL,

-	SHR,

-	LE,

-	GE,

-	EQ,

-	NE,

-	AND,

-	OR,

-	MUL_EQ,

-	DIV_EQ,

-	MOD_EQ,

-	ADD_EQ,

-	SUB_EQ,

-	AND_EQ,

-	XOR_EQ,

-	OR_EQ,

-	SHL_EQ,

-	SHR_EQ,

-	ELLIPSIS,

-	CASE,

-	DEFAULT,

-	IF,

-	ELSE,

-	SWITCH,

-	WHILE,

-	DO,

-	FOR,

-	GOTO,

-	VOID,

-	FLOAT,

-	INT,

-	BOOL,

-	VA_LIST,

-	STRUCT,

-	UNION,

-	CHAR,

-	DOUBLE,

-	SHORT,

-	LONG,

-	LLONG,

-	COMPLEX,

-	TYPEDEF,

-	EXTERN,

-	STATIC,

-	AUTO,

-	REGISTER,

-	ENUM,

-	TYPEIDEN,

-	UNSIGNED,

-	SIGNED,

-	CONTINUE,

-	BREAK,

-	RETURN,

-	DEFINE,

-	INCLUDE,

-	LINE,

-	PRAGMA,

-	ERROR,

-	IFDEF,

-	ELIF,

-	IFNDEF,

-	UNDEF,

-	ENDIF,

-	BUILTIN,

-	EOFTOK

-};

-

-/* operations */

-enum op {

-	OADD,

-	OMUL,

-	OSUB,

-	OINC,

-	ODEC,

-	ODIV,

-	OMOD,

-	OSHL,

-	OSHR,

-	OBAND,

-	OBXOR,

-	OBOR,

-	OSNEG,

-	ONEG,

-	OCPL,

-	OAND,

-	OOR,

-	OEQ,

-	ONE,

-	OLT,

-	OGE,

-	OLE,

-	OGT,

-	OASSIGN,

-	OA_MUL,

-	OA_DIV,

-	OA_MOD,

-	OA_ADD,

-	OA_SUB,

-	OA_SHL,

-	OA_SHR,

-	OA_AND,

-	OA_XOR,

-	OA_OR,

-	OADDR,

-	OCOMMA,

-	OCAST,

-	OPTR,

-	OSYM,

-	OASK,

-	OCOLON,

-	OFIELD,

-	OLABEL,

-	ODEFAULT,

-	OCASE,

-	OJUMP,

-	OBRANCH,

-	OEXPR,

-	OEFUN,

-	OELOOP,

-	OBLOOP,

-	OFUN,

-	OPAR,

-	OCALL,

-	OCALLE,

-	ORET,

-	ODECL,

-	OBSWITCH,

-	OESWITCH,

-	OINIT,

-	OBUILTIN,

-	OTYP,

-};

-

-/*

- * Definition of structures

- */

-typedef struct type Type;

-typedef struct symbol Symbol;

-typedef struct swtch Switch;

-typedef struct node Node;

-typedef struct input Input;

-

-struct limits {

-	union {

-		TUINT i;

-		TFLOAT f;

-	} max;

-	union {

-		TUINT i;

-		TFLOAT f;

-	} min;

-};

-

-struct builtin {

-	char *str;

-	Node *(*fun)(Symbol *);

-};

-

-struct keyword {

-	char *str;

-	unsigned char token, value;

-};

-

-struct type {

-	unsigned char op;           /* type builder operator */

-	unsigned char ns;           /* namespace for struct members */

-	short id;                   /* type id, used in dcls */

-	char letter;                /* letter of the type */

-	unsigned char prop;         /* type properties */

-	unsigned char align;        /* align of the type */

-	unsigned long size;         /* sizeof the type */

-	Type *type;                 /* base type */

-	Symbol *tag;                /* symbol of the strug tag */

-	union {

-		Type **pars;            /* Function type parameters */

-		Symbol **fields;        /* fields of aggregate type */

-	} p;

-	union {

-		unsigned char rank;     /* convertion rank */

-		TINT elem;              /* number of type parameters */

-	} n;

-	Type *next;                 /* local list pointer */

-	Type *h_next;               /* hash collision list */

-};

-

-struct symbol {

-	unsigned char ctx;

-	unsigned char hide;

-	char ns;

-	unsigned short id;

-	unsigned short flags;

-	char *name;

-	Type *type;

-	unsigned char token;

-	union {

-		TINT i;

-		TUINT u;

-		TFLOAT f;

-		char *s;

-		unsigned char token;

-		Node **init;

-		Symbol **pars;

-		Node *(*fun)(Symbol *);

-	} u;

-	struct symbol *next;

-	struct symbol *hash;

-};

-

-struct node {

-	unsigned char op;

-	unsigned char flags;

-	Type *type;

-	Symbol *sym;

-	struct node *left, *right;

-};

-

-struct swtch {

-	short nr;

-	char hasdef;

-};

-

-struct yystype {

-	Symbol *sym;

-	unsigned char token;

-};

-

-#ifdef stdin

-struct input {

-	char flags;

-	unsigned lineno;

-	char *filenam;

-	FILE *fp;

-	Symbol *hide;

-	char *line, *begin, *p;

-	struct input *next;

-};

-#endif

-

-/* error.c */

-extern void error(char *fmt, ...);

-extern void warn(char *fmt, ...);

-extern void unexpected(void);

-extern void errorp(char *fmt, ...);

-extern void cpperror(char *fmt, ...);

-extern Type *deftype(Type *tp);

-

-/* types.c */

-extern int eqtype(Type *tp1, Type *tp2, int eqflag);

-extern Type *ctype(int type, int sign, int size);

-extern Type *mktype(Type *tp, int op, TINT nelem, Type *data[]);

-extern Type *duptype(Type *base);

-extern struct limits *getlimits(Type *tp);

-extern void typesize(Type *tp);

-extern void flushtypes(void);

-

-/* symbol.c */

-extern void dumpstab(Symbol **tbl, char *msg);

-extern Symbol *lookup(int ns, char *name, int alloc);

-extern Symbol *nextsym(Symbol *sym, int ns);

-extern Symbol *install(int ns, Symbol *sym);

-extern Symbol *newsym(int ns, char *name);

-extern void pushctx(void), popctx(void);

-extern void killsym(Symbol *sym);

-extern Symbol *newlabel(void);

-extern void keywords(struct keyword *key, int ns);

-extern void builtins(struct builtin *builts);

-extern Symbol *newstring(char *s, size_t len);

-extern unsigned newid(void);

-

-/* stmt.c */

-extern void compound(Symbol *lbreak, Symbol *lcont, Switch *sw);

-

-/* decl.c */

-extern Type *typename(void);

-extern void decl(void);

-

-/* lex.c */

-extern int ahead(void);

-extern int next(void);

-extern void expect(int tok);

-extern void discard(void);

-extern void addinput(char *fname, Symbol *hide, char *buffer);

-extern void delinput(void);

-extern void setsafe(int type);

-extern void ilex(void);

-extern void setloc(char *fname, unsigned line);

-#define accept(t) ((yytoken == (t)) ? next() : 0)

-

-/* code.c */

-extern void prtree(Node *np);

-extern void emit(int, void *);

-extern Node *node(int op, Type *tp, Node *left, Node *rigth);

-extern Node *varnode(Symbol *sym);

-extern Node *constnode(Symbol *sym);

-extern Node *sizeofnode(Type *tp);

-extern void freetree(Node *np);

-extern void icode(void);

-#define BTYPE(np) ((np)->type->op)

-

-/* fold.c */

-extern Node *simplify(Node *np);

-extern TUINT ones(int nbytes);

-

-/* expr.c */

-extern Node *decay(Node *), *negate(Node *np), *assign(void);

-extern Node *convert(Node *np, Type *tp1, int iscast);

-extern Node *constexpr(void), *condexpr(int neg), *expr(void);

-extern int isnodecmp(int op);

-extern int negop(int op);

-extern int cmpnode(Node *np, TUINT val);

-

-/* init.c */

-extern void initializer(Symbol *sym, Type *tp);

-extern Node *initlist(Type *tp);

-

-/* cpp.c */

-extern void icpp(void);

-extern int cpp(void);

-extern int expand(char *begin, Symbol *sym);

-extern void incdir(char *dir);

-extern void outcpp(void);

-extern void defdefine(char *macro, char *val, char *source);

-extern void undefmacro(char *s);

-extern void ppragmaln(void);

-

-/* builtin.c */

-extern void ibuilts(void);

-

-/* arch.c */

-extern void iarch(void);

-extern int valid_va_list(Type *tp);

-

-/*

- * Definition of global variables

- */

-extern struct yystype yylval;

-extern char yytext[];

-extern int yytoken;

-extern unsigned short yylen;

-extern int disexpand;

-extern unsigned cppctx;

-extern Input *input;

-extern int lexmode, namespace;

-extern int onlycpp, onlyheader;

-extern unsigned curctx;

-extern Symbol *curfun, *zero, *one;

-extern char *infile;

-extern unsigned lineno;

-extern char filenam[];

-

-extern Type *voidtype, *pvoidtype, *booltype,

-            *uchartype,   *chartype, *schartype,

-            *uinttype,    *inttype,

-            *sizettype, *pdifftype,

-            *ushortype,   *shortype,

-            *longtype,    *ulongtype,

-            *ullongtype,  *llongtype,

-            *floattype,   *doubletype,  *ldoubletype,

-            *ellipsistype, *va_list_type, *va_type;

--- a/src/cmd/cc1/code.c

+++ /dev/null

@@ -1,550 +1,0 @@

-static char sccsid[] = "@(#) ./cc1/code.c";

-#include <ctype.h>

-#include <stdio.h>

-#include <stdlib.h>

-#include <stdarg.h>

-

-#include <scc/scc.h>

-#include "cc1.h"

-

-static void emitbin(int, void *),

-            emitcast(int, void *),

-            emitsym(int, void *),

-            emitexp(int, void *),

-            emitsymid(int, void *),

-            emittext(int, void *),

-            emitfun(int, void *),

-            emitdcl(int, void *),

-            emitinit(int, void *),

-            emittype(int, void *),

-            emitbuilt(int, void *);

-

-char *optxt[] = {

-	[OADD] = "+",

-	[OSUB] = "-",

-	[OMUL] = "*",

-	[OINC] = ":i",

-	[ODEC] =  ":d",

-	[OPTR] = "@",

-	[OMOD] = "%",

-	[ODIV] = "/",

-	[OSHL] = "l",

-	[OSHR]  = "r",

-	[OLT] = "<",

-	[OGT] = ">",

-	[OGE] = "]",

-	[OLE] =  "[",

-	[OEQ] = "=",

-	[ONE] = "!",

-	[OBAND] = "&",

-	[OBXOR]  = "^",

-	[OBOR] = "|",

-	[OASSIGN] = ":",

-	[OA_MUL] = ":*",

-	[OA_DIV] = ":/",

-	[OA_MOD] = ":%",

-	[OA_ADD] = ":+",

-	[OA_SUB] = ":-",

-	[OA_SHL] = ":l",

-	[OA_SHR] = ":r",

-	[OA_AND] = ":&",

-	[OA_XOR] = ":^",

-	[OA_OR] = ":|",

-	[OADDR] = "'",

-	[OSNEG] = "_",

-	[ONEG] = "n",

-	[OCPL] = "~",

-	[OAND] = "a",

-	[OOR] = "o",

-	[OASK] = "?",

-	[OCOMMA] = ",",

-	[OLABEL] = "L%d\n",

-	[ODEFAULT] = "\tf\tL%d\n",

-	[OBSWITCH] = "\ts",

-	[OESWITCH] = "\tt\tL%d\n",

-	[OCASE] = "\tv\tL%d",

-	[OJUMP] = "\tj\tL%d\n",

-	[OBRANCH] = "\ty\tL%d",

-	[OEFUN] = "}\n",

-	[OELOOP] = "\tb\n",

-	[OBLOOP] = "\te\n",

-	[ORET] = "\th",

-	[OPAR] = "p",

-	[OCALL] = "c",

-	[OCALLE] = "z",

-	[OFIELD] = "."

-};

-

-void (*opcode[])(int, void *) = {

-	[OADD] = emitbin,

-	[OSUB] = emitbin,

-	[OMUL] = emitbin,

-	[OINC] = emitbin,

-	[ODEC] =  emitbin,

-	[OPTR] = emitbin,

-	[OMOD] = emitbin,

-	[ODIV] = emitbin,

-	[OSHL] = emitbin,

-	[OSHR]  = emitbin,

-	[OLT] = emitbin,

-	[OGT] = emitbin,

-	[OGE] = emitbin,

-	[OLE] =  emitbin,

-	[OEQ] = emitbin,

-	[ONE] = emitbin,

-	[OBAND] = emitbin,

-	[OBXOR]  = emitbin,

-	[OBOR] = emitbin,

-	[OASSIGN] = emitbin,

-	[OA_MUL] = emitbin,

-	[OA_DIV] = emitbin,

-	[OA_MOD] = emitbin,

-	[OA_ADD] = emitbin,

-	[OA_SUB] = emitbin,

-	[OA_SHL] = emitbin,

-	[OA_SHR] = emitbin,

-	[OA_AND] = emitbin,

-	[OA_XOR] = emitbin,

-	[OA_OR] = emitbin,

-	[OADDR] = emitbin,

-	[OSNEG] = emitbin,

-	[ONEG] = emitbin,

-	[OCPL] = emitbin,

-	[OAND] = emitbin,

-	[OOR] = emitbin,

-	[OCOMMA] = emitbin,

-	[OCAST] = emitcast,

-	[OSYM] = emitsym,

-	[OASK] = emitbin,

-	[OCOLON] = emitbin,

-	[OFIELD]= emitbin,

-	[OEXPR] = emitexp,

-	[OLABEL] = emitsymid,

-	[ODEFAULT] = emitsymid,

-	[OCASE] = emitsymid,

-	[OJUMP] = emitsymid,

-	[OBRANCH] = emitsymid,

-	[OEFUN] = emittext,

-	[OELOOP] = emittext,

-	[OBLOOP] = emittext,

-	[OFUN] = emitfun,

-	[ORET] = emittext,

-	[ODECL] = emitdcl,

-	[OBSWITCH] = emittext,

-	[OESWITCH] = emitsymid,

-	[OPAR] = emitbin,

-	[OCALL] = emitbin,

-	[OCALLE] = emitbin,

-	[OINIT] = emitinit,

-	[OBUILTIN] = emitbuilt,

-	[OTYP] = emittype,

-};

-

-static FILE *outfp;

-

-void

-icode(void)

-{

-	outfp = stdout;

-}

-

-void

-freetree(Node *np)

-{

-	if (!np)

-		return;

-	freetree(np->left);

-	freetree(np->right);

-	free(np);

-}

-

-static void

-emitnode(Node *np)

-{

-	if (np)

-		(*opcode[np->op])(np->op, np);

-}

-

-void

-prtree(Node *np)

-{

-	outfp = stderr;

-	fputs("DBG prtree", outfp);

-	emitnode(np);

-	putc('\n', outfp);

-	outfp = stdout;

-}

-

-void

-emit(int op, void *arg)

-{

-	extern int failure;

-

-	if (failure || onlycpp || onlyheader)

-		return;

-	(*opcode[op])(op, arg);

-}

-

-static void

-emitvar(Symbol *sym)

-{

-	int c;

-	short flags = sym->flags;

-

-	if (flags & SLOCAL)

-		c = 'T';

-	else if (flags & SPRIVATE)

-		c =  'Y';

-	else if (flags & SGLOBAL)

-		c = 'G';

-	else if (flags & SREGISTER)

-		c = 'R';

-	else if (flags & SFIELD)

-		c = 'M';

-	else if (flags & SEXTERN)

-		c = 'X';

-	else

-		c = 'A';

-	fprintf(outfp, "%c%u", c, sym->id);

-}

-

-static void

-emitconst(Node *np)

-{

-	Symbol *sym = np->sym;

-	Type *tp = np->type;

-	TUINT u;

-

-	switch (tp->op) {

-	case PTR:

-	case INT:

-	case ENUM:

-		u = (tp->prop & TSIGNED) ? (TUINT) sym->u.i : sym->u.u;

-		fprintf(outfp,

-		        "#%c%llX",

-		        np->type->letter,

-		        (long long) u & ones(tp->size));

-		break;

-	default:

-		abort();

-	}

-}

-

-static void

-emitsym(int op, void *arg)

-{

-	Node *np = arg;

-

-	if ((np->sym->flags & SINITLST) == 0) {

-		/*

-		 * When we have a compound literal we are going

-		 * to call to emitnode for every element of it,

-		 * and it means that we will have two '\t'

-		 * for the first element

-		 */

-		putc('\t', outfp);

-	}

-	(np->flags & NCONST) ? emitconst(np) : emitvar(np->sym);

-}

-

-static void

-emitletter(Type *tp)

-{

-	int letter;

-

-	letter = (tp->prop&TELLIPSIS) ? 'E' : tp->letter;

-	putc(letter, outfp);

-	switch (tp->op) {

-	case ARY:

-	case STRUCT:

-	case UNION:

-		fprintf(outfp, "%u", tp->id);

-	}

-}

-

-static void

-emittype(int op, void *arg)

-{

-	TINT n;

-	Symbol **sp;

-	char *tag;

-	Type *tp = arg;

-

-	if (!(tp->prop & TDEFINED))

-		return;

-

-	switch (tp->op) {

-	case ARY:

-		emitletter(tp);

-		putc('\t', outfp);

-		emitletter(tp->type);

-		fprintf(outfp,

-		        "\t#%c%llX\n",

-		        sizettype->letter, (long long) tp->n.elem);

-		return;

-	case UNION:

-	case STRUCT:

-		emitletter(tp);

-		tag = tp->tag->name;

-		fprintf(outfp,

-		       "\t\"%s\t#%c%lX\t#%c%X\n",

-		       (tag) ? tag : "",

-		       sizettype->letter,

-		       tp->size,

-		       sizettype->letter,

-		       tp->align);

-		n = tp->n.elem;

-		for (sp = tp->p.fields; n-- > 0; ++sp)

-			emit(ODECL, *sp);

-		break;

-	case PTR:

-	case FTN:

-	case ENUM:

-		return;

-	default:

-		abort();

-	}

-}

-

-static void

-emitstring(Symbol *sym, Type *tp)

-{

-	char *bp, *s, *lim;

-	int n;

-

-	bp = sym->u.s;

-	lim = &sym->u.s[tp->n.elem];

-	while (bp < lim) {

-		s = bp;

-		while (bp < lim && isprint(*bp))

-			++bp;

-		if ((n = bp - s) > 1)

-			fprintf(outfp, "\t#\"%.*s\n", n, s);

-		else

-			bp = s;

-		if (bp == lim)

-			break;

-		do {

-			fprintf(outfp,

-			        "\t#%c%02X\n",

-			        chartype->letter, (*bp++) & 0xFF);

-		} while (bp < lim && !isprint(*bp));

-	}

-}

-

-static void

-emitdesig(Node *np, Type *tp)

-{

-	Symbol *sym;

-	size_t n; /* TODO: This should be SIZET */

-	Node *aux;

-	Type *p;

-

-	if (!np) {

-		sym = NULL;

-	} else {

-		if (!np->sym)

-			goto emit_expression;

-		sym = np->sym;

-		if (sym->flags & SSTRING) {

-			emitstring(sym, tp);

-			return;

-		}

-		if ((sym->flags & SINITLST) == 0)

-			goto emit_expression;

-	}

-

-	switch (tp->op) {

-	case PTR:

-	case INT:

-	case ENUM:

-		aux = (sym) ? *sym->u.init : convert(constnode(zero), tp, 0);

-		emitexp(OEXPR, aux);

-		break;

-	case UNION:

-		n = tp->n.elem-1;

-		aux = (sym) ? sym->u.init[0] : NULL;

-		emitdesig(aux, aux->type);

-		break;

-	case STRUCT:

-	case ARY:

-		for (n = 0; n < tp->n.elem; ++n) {

-			aux = (sym) ? sym->u.init[n] : NULL;

-			p = (tp->op == ARY) ? tp->type : tp->p.fields[n]->type;

-			emitdesig(aux, p);

-		}

-		break;

-	default:

-		abort();

-	}

-

-	if (sym) {

-		free(sym->u.init);

-		sym->u.init = NULL;

-	}

-	freetree(np);

-	return;

-

-emit_expression:

-	emitexp(OEXPR, np);

-}

-

-static void

-emitinit(int op, void *arg)

-{

-	Node *np = arg;

-

-	fputs("\t(\n", outfp);

-	emitdesig(np, np->type);

-	fputs(")\n", outfp);

-}

-

-static void

-emitdcl(int op, void *arg)

-{

-	Symbol *sym = arg;

-

-	if (sym->flags & SEMITTED)

-		return;

-	emitvar(sym);

-	putc('\t', outfp);

-	if (sym->type->op == FTN) {

-		emitletter(sym->type->type);

-		putc('\t', outfp);

-	}

-	emitletter(sym->type);

-	fprintf(outfp, "\t\"%s", (sym->name) ? sym->name : "");

-	if (sym->flags & SFIELD)

-		fprintf(outfp, "\t#%c%llX", sizettype->letter, sym->u.i);

-	sym->flags |= SEMITTED;

-	if ((sym->flags & SHASINIT) == 0)

-		putc('\n', outfp);

-}

-

-static void

-emitcast(int op, void *arg)

-{

-	Node *np = arg, *lp = np->left;

-

-	emitnode(lp);

-	if (np->type != voidtype)

-		fprintf(outfp, "\tg%c", np->type->letter);

-}

-

-static void

-emitbin(int op, void *arg)

-{

-	Node *np = arg;

-	char *s;

-

-	emitnode(np->left);

-	emitnode(np->right);

-	if ((s = optxt[op]) != NULL)  {      /* do not print in OCOLON case */

-		fprintf(outfp, "\t%s", s);

-		emitletter(np->type);

-	}

-}

-

-static void

-emitbuilt(int op, void *arg)

-{

-	Node *np = arg;

-

-	emitnode(np->left);

-	emitnode(np->right);

-	fprintf(outfp, "\t\"%s\tm", np->sym->name);

-	emitletter(np->type);

-}

-

-

-static void

-emitexp(int op, void *arg)

-{

-	Node *np = arg;

-

-	emitnode(np);

-	putc('\n', outfp);

-	freetree(np);

-}

-

-static void

-emitfun(int op, void *arg)

-{

-	Symbol *sym = arg, **sp;

-

-	emitdcl(op, arg);

-	fputs("{\n", outfp);

-

-	for (sp = sym->u.pars; sp && *sp; ++sp)

-		emit(ODECL, *sp);

-	fputs("\\\n", outfp);

-}

-

-static void

-emittext(int op, void *arg)

-{

-	fputs(optxt[op], outfp);

-}

-

-static void

-emitsymid(int op, void *arg)

-{

-	Symbol *sym = arg;

-	fprintf(outfp, optxt[op], sym->id);

-}

-

-Node *

-node(int op, Type *tp, Node *lp, Node *rp)

-{

-	Node *np;

-

-	np = xmalloc(sizeof(*np));

-	np->op = op;

-	np->type = tp;

-	np->sym = NULL;

-	np->flags = 0;

-	np->left = lp;

-	np->right = rp;

-

-	if (lp)

-		np->flags |= lp->flags & NEFFECT;

-	if (rp)

-		np->flags |= rp->flags & NEFFECT;

-	return np;

-}

-

-Node *

-varnode(Symbol *sym)

-{

-	Node *np;

-	Type *tp = sym->type;

-

-	np = node(OSYM, sym->type, NULL, NULL);

-	np->type = sym->type;

-	np->flags = (tp->op != FTN && tp->op != ARY) ? NLVAL : 0;

-	np->sym = sym;

-	return np;

-}

-

-Node *

-constnode(Symbol *sym)

-{

-	Node *np;

-

-	np = node(OSYM, sym->type, NULL, NULL);

-	np->type = sym->type;

-	np->flags = NCONST;

-	np->sym = sym;

-	return np;

-}

-

-Node *

-sizeofnode(Type *tp)

-{

-	Symbol *sym;

-

-	sym = newsym(NS_IDEN, NULL);

-	sym->type = sizettype;

-	sym->u.i = tp->size;

-	return constnode(sym);

-}

--- a/src/cmd/cc1/cpp.c

+++ /dev/null

@@ -1,839 +1,0 @@

-static char sccsid[] = "@(#) ./cc1/cpp.c";

-#include <ctype.h>

-#include <limits.h>

-#include <stdio.h>

-#include <stdlib.h>

-#include <string.h>

-#include <time.h>

-

-#include <scc/cstd.h>

-#include <scc/scc.h>

-#include "cc1.h"

-

-static char *argp, *macroname;

-static unsigned arglen;

-static unsigned ncmdlines;

-static Symbol *symline, *symfile;

-static unsigned char ifstatus[NR_COND];

-static int cppoff;

-static struct items dirinclude;

-

-unsigned cppctx;

-int disexpand;

-

-void

-defdefine(char *macro, char *val, char *source)

-{

-	char *def, *fmt = "#define %s %s\n";

-	Symbol dummy = {.flags = SDECLARED};

-

-	if (!val)

-		val = "";

-	def = xmalloc(strlen(fmt) + strlen(macro) + strlen(val));

-

-	sprintf(def, fmt, macro, val);

-	lineno = ++ncmdlines;

-	addinput(source, &dummy, def);

-	cpp();

-	delinput();

-}

-

-void

-undefmacro(char *s)

-{

-	killsym(lookup(NS_CPP, s, NOALLOC));

-}

-

-void

-icpp(void)

-{

-	static char sdate[14], stime[11];

-	struct tm *tm;

-	time_t t;

-	static char **bp, *list[] = {

-		"__STDC__",

-		"__STDC_HOSTED__",

-		"__SCC__",

-		NULL

-	};

-	static struct keyword keys[] = {

-		{"define", DEFINE, DEFINE},

-		{"include", INCLUDE, INCLUDE},

-		{"line", LINE, LINE},

-		{"ifdef", IFDEF, IFDEF},

-		{"if", IF, IF},

-		{"elif", ELIF, ELIF},

-		{"else", ELSE, ELSE},

-		{"ifndef", IFNDEF, IFNDEF},

-		{"endif", ENDIF, ENDIF},

-		{"undef", UNDEF, UNDEF},

-		{"pragma", PRAGMA, PRAGMA},

-		{"error", ERROR, ERROR},

-		{NULL, 0, 0}

-	};

-

-	keywords(keys, NS_CPPCLAUSES);

-

-	t = time(NULL);

-	tm = localtime(&t);

-	strftime(sdate, sizeof(sdate), "\"%b %d %Y\"", tm);

-	strftime(stime, sizeof(stime), "\"%H:%M:%S\"", tm);

-	defdefine("__DATE__", sdate, "built-in");

-	defdefine("__TIME__", stime, "built-in");

-	defdefine("__STDC_VERSION__", STDC_VERSION, "built-in");

-	defdefine("__LINE__", NULL, "built-in");

-	defdefine("__FILE__", NULL, "built-in");

-

-	symline = lookup(NS_CPP, "__LINE__", ALLOC);

-	symfile = lookup(NS_CPP, "__FILE__", ALLOC);

-

-	for (bp = list; *bp; ++bp)

-		defdefine(*bp, "1", "built-in");

-

-	ncmdlines = 0;

-}

-

-static void

-nextcpp(void)

-{

-	next();

-	if (yytoken == EOFTOK)

-		error("unterminated argument list invoking macro \"%s\"",

-		      macroname);

-	if (yylen + 1 > arglen)

-		error("argument overflow invoking macro \"%s\"",

-		      macroname);

-	if (yytoken == IDEN)

-		yylval.sym->flags |= SUSED;

-	memcpy(argp, yytext, yylen);

-	argp += yylen;

-	*argp++ = ' ';

-	arglen -= yylen + 1;

-}

-

-static void

-paren(void)

-{

-	for (;;) {

-		nextcpp();

-		switch (yytoken) {

-		case ')':

-			return;

-		case '(':

-			paren();

-			break;

-		}

-	}

-}

-

-static void

-parameter(void)

-{

-	for (;;) {

-		nextcpp();

-		switch (yytoken) {

-		case ')':

-		case ',':

-			argp -= 3;  /* remove " , "  or " ) "*/

-			*argp++ = '\0';

-			return;

-		case '(':

-			paren();

-			break;

-		}

-	}

-}

-

-static int

-parsepars(char *buffer, char **listp, int nargs)

-{

-	int n;

-

-	if (nargs == -1)

-		return -1;

-	if (ahead() != '(' && nargs > 0)

-		return 0;

-

-	disexpand = 1;

-	next();

-	n = 0;

-	argp = buffer;

-	arglen = INPUTSIZ;

-	if (ahead() == ')') {

-		next();

-	} else {

-		do {

-			*listp++ = argp;

-			parameter();

-		} while (++n < NR_MACROARG && yytoken == ',');

-	}

-	if (yytoken != ')')

-		error("incorrect macro function-alike invocation");

-	disexpand = 0;

-

-	if (n == NR_MACROARG)

-		error("too many parameters in macro \"%s\"", macroname);

-	if (n != nargs) {

-		error("macro \"%s\" received %d arguments, but it takes %d",

-		      macroname, n, nargs);

-	}

-

-	return 1;

-}

-

-static size_t

-copymacro(char *buffer, char *s, size_t bufsiz, char *arglist[])

-{

-	int delim, prevc, c;

-	char *p, *arg, *bp = buffer;

-	size_t size;

-

-	for (prevc = '\0'; c = *s; prevc = c, ++s) {

-		switch (c) {

-		case '$':

-			while (bp[-1] == ' ')

-				--bp, ++bufsiz;

-			while (s[1] == ' ')

-				++s;

-		case '#':

-			break;

-		case '\'':

-			delim = '\'';

-			goto search_delim;

-		case '\"':

-			delim = '"';

-		search_delim:

-			for (p = s; *++s != delim; )

-				;

-			size = s - p + 1;

-			if (size > bufsiz)

-				goto expansion_too_long;

-			memcpy(bp, p, size);

-			bufsiz -= size;

-			bp += size;

-			break;

-		case '@':

-			if (prevc == '#')

-				bufsiz -= 2;

-			arg = arglist[atoi(++s)];

-			size = strlen(arg);

-			if (size > bufsiz)

-				goto expansion_too_long;

-			if (prevc == '#')

-				*bp++ = '"';

-			memcpy(bp, arg, size);

-			bp += size;

-			if (prevc == '#')

-				*bp++ = '"';

-			bufsiz -= size;

-			s += 2;

-			break;

-		default:

-			if (bufsiz-- == 0)

-				goto expansion_too_long;

-			*bp++ = c;

-			break;

-		}

-	}

-	*bp = '\0';

-

-	return bp - buffer;

-

-expansion_too_long:

-	error("macro expansion of \"%s\" too long", macroname);

-}

-

-int

-expand(char *begin, Symbol *sym)

-{

-	size_t elen;

-	int n, i;

-	char *s = sym->u.s;

-	char *arglist[NR_MACROARG], arguments[INPUTSIZ], buffer[INPUTSIZ];

-

-	macroname = sym->name;

-	if (sym == symfile) {

-		elen = sprintf(buffer, "\"%s\" ", filenam);

-		goto substitute;

-	}

-	if (sym == symline) {

-		elen = sprintf(buffer, "%d ", lineno);

-		goto substitute;

-	}

-	if (!s)

-		return 1;

-

-	n = atoi(s);

-	if (!parsepars(arguments, arglist, n))

-		return 0;

-	for (i = 0; i < n; ++i)

-		DBG("MACRO par%d:%s", i, arglist[i]);

-

-	elen = copymacro(buffer, s+3, INPUTSIZ-1, arglist);

-

-substitute:

-	DBG("MACRO '%s' expanded to :'%s'", macroname, buffer);

-	buffer[elen] = '\0';

-	addinput(filenam, sym, xstrdup(buffer));

-

-	return 1;

-}

-

-static int

-getpars(Symbol *args[NR_MACROARG])

-{

-	int n, c;

-	Symbol *sym;

-

-	c = *input->p;

-	next();

-	if (c != '(')

-		return -1;

-	next(); /* skip the '(' */

-	if (accept(')'))

-		return 0;

-

-	n = 0;

-	do {

-		if (n == NR_MACROARG) {

-			cpperror("too many parameters in macro");

-			return NR_MACROARG;

-		}

-		if (accept(ELLIPSIS)) {

-			args[n++] = NULL;

-			break;

-		}

-		if (yytoken != IDEN) {

-			cpperror("macro arguments must be identifiers");

-			return NR_MACROARG;

-		}

-		sym = install(NS_IDEN, yylval.sym);

-		sym->flags |= SUSED;

-		args[n++] = sym;

-		next();

-	} while (accept(','));

-	expect(')');

-

-	return n;

-}

-

-static int

-getdefs(Symbol *args[NR_MACROARG], int nargs, char *bp, size_t bufsiz)

-{

-	Symbol **argp;

-	size_t len;

-	int prevc = 0, ispar;

-

-	if (yytoken == '$') {

-		cpperror("'##' cannot appear at either ends of a macro expansion");

-		return 0;

-	}

-

-	for (;;) {

-		ispar = 0;

-		if (yytoken == IDEN && nargs >= 0) {

-			for (argp = args; argp < &args[nargs]; ++argp) {

-				if (*argp == yylval.sym)

-					break;

-			}

-			if (argp != &args[nargs]) {

-				sprintf(yytext, "@%02d@", (int) (argp - args));

-				ispar = 1;

-			}

-		}

-		if (prevc == '#' && !ispar) {

-			cpperror("'#' is not followed by a macro parameter");

-			return 0;

-		}

-		if (yytoken == '\n')

-			break;

-

-		if ((len = strlen(yytext)) >= bufsiz) {

-			cpperror("macro too long");

-			return 0;

-		}

-		if (yytoken == '$') {

-			*bp++ = '$';

-			 --bufsiz;

-		} else {

-			memcpy(bp, yytext, len);

-			bp += len;

-			bufsiz -= len;

-		}

-		if ((prevc = yytoken) != '#') {

-			*bp++ = ' ';

-			--bufsiz;

-		}

-		next();

-	}

-	*bp = '\0';

-	return 1;

-}

-

-static void

-define(void)

-{

-	Symbol *sym,*args[NR_MACROARG];

-	char buff[LINESIZ+1];

-	int n;

-

-	if (cppoff)

-		return;

-

-	namespace = NS_CPP;

-	next();

-

-	if (yytoken != IDEN) {

-		cpperror("macro names must be identifiers");

-		return;

-	}

-	sym = yylval.sym;

-	if (sym->flags & SDECLARED) {

-		warn("'%s' redefined", yytext);

-		free(sym->u.s);

-	} else {

-		sym = install(NS_CPP, sym);

-		sym->flags |= SDECLARED|SSTRING;

-	}

-

-	namespace = NS_IDEN;       /* Avoid polution in NS_CPP */

-	if ((n = getpars(args)) == NR_MACROARG)

-		goto delete;

-	if (n > 0 && !args[n-1])  /* it is a variadic function */

-		--n;

-	sprintf(buff, "%02d#", n);

-	if (!getdefs(args, n, buff+3, LINESIZ-3))

-		goto delete;

-	sym->u.s = xstrdup(buff);

-	DBG("MACRO '%s' defined as '%s'", sym->name, buff);

-	return;

-

-delete:

-	killsym(sym);

-}

-

-void

-incdir(char *dir)

-{

-	if (!dir || *dir == '\0')

-		die("cc1: incorrect -I flag");

-	newitem(&dirinclude, dir);

-}

-

-static int

-includefile(char *dir, char *file, size_t filelen)

-{

-	size_t dirlen;

-	char path[FILENAME_MAX];

-

-	if (!dir) {

-		dirlen = 0;

-		if (filelen > FILENAME_MAX-1)

-			return 0;

-	} else {

-		dirlen = strlen(dir);

-		if (dirlen + filelen > FILENAME_MAX-2)

-			return 0;

-		memcpy(path, dir, dirlen);

-		if (dir[dirlen-1] != '/')

-			path[dirlen++] = '/';

-	}

-	memcpy(path+dirlen, file, filelen);

-	path[dirlen + filelen] = '\0';

-

-	addinput(path, NULL, NULL);

-	return 1;

-}

-

-static char *

-cwd(char *buf)

-{

-	char *p, *s = filenam;

-	size_t len;

-

-	if ((p = strrchr(s, '/')) == NULL)

-		return NULL;

-	if ((len = p - s) >= FILENAME_MAX)

-		die("cc1: current work directory too long");

-	memcpy(buf, s, len);

-	buf[len] = '\0';

-	return buf;

-}

-

-static void

-include(void)

-{

-	char dir[FILENAME_MAX], file[FILENAME_MAX], *p, **bp;

-	size_t filelen;

-	int n;

-

-	if (cppoff)

-		return;

-

-	namespace = NS_IDEN;

-	next();

-

-	switch (*yytext) {

-	case '<':

-		if ((p = strchr(input->begin, '>')) == NULL || p[-1] == '<')

-			goto bad_include;

-		filelen = p - input->begin;

-		if (filelen >= FILENAME_MAX)

-			goto too_long;

-		memcpy(file, input->begin, filelen);

-		file[filelen] = '\0';

-

-		input->begin = input->p = p+1;

-		if (next() != '\n')

-			goto trailing_characters;

-

-		break;

-	case '"':

-		if (yylen < 3)

-			goto bad_include;

-		filelen = yylen-2;

-		if (filelen >= FILENAME_MAX)

-			goto too_long;

-		memcpy(file, yytext+1, filelen);

-		file[filelen] = '\0';

-

-		if (next() != '\n')

-			goto trailing_characters;

-

-		if (includefile(cwd(dir), file, filelen))

-			goto its_done;

-		break;

-	default:

-		goto bad_include;

-	}

-

-	n = dirinclude.n;

-	for (bp = dirinclude.s; n--; ++bp) {

-		if (includefile(*bp, file, filelen))

-			goto its_done;

-	}

-	cpperror("included file '%s' not found", file);

-

-its_done:

-	return;

-

-trailing_characters:

-	cpperror("trailing characters after preprocessor directive");

-	return;

-

-too_long:

-	cpperror("too long file name in #include");

-	return;

-

-bad_include:

-	cpperror("#include expects \"FILENAME\" or <FILENAME>");

-	return;

-}

-

-static void

-line(void)

-{

-	long n;

-	char *endp, *fname;

-

-	if (cppoff)

-		return;

-

-	disexpand = 0;

-	next();

-	n = strtol(yytext, &endp, 10);

-	if (n <= 0 || n > USHRT_MAX || *endp != '\0') {

-		cpperror("first parameter of #line is not a positive integer");

-		return;

-	}

-

-	next();

-	if (yytoken == '\n') {

-		fname = NULL;

-	} else {

-		if (*yytext != '\"' || yylen == 1) {

-			cpperror("second parameter of #line is not a valid filename");

-			return;

-		}

-		fname = yylval.sym->u.s;

-	}

-	setloc(fname, n - 1);

-	if (yytoken != '\n')

-		next();

-}

-

-static void

-pragma(void)

-{

-	if (cppoff)

-		return;

-	next();

-	warn("ignoring pragma '%s'", yytext);

-	*input->p = '\0';

-	next();

-}

-

-static void

-usererr(void)

-{

-	if (cppoff)

-		return;

-	cpperror("#error %s", input->p);

-	*input->p = '\0';

-	next();

-}

-

-static void

-ifclause(int negate, int isifdef)

-{

-	Symbol *sym;

-	unsigned n;

-	int status;

-	Node *expr;

-

-	if (cppctx == NR_COND-1)

-		error("too many nesting levels of conditional inclusion");

-

-	n = cppctx++;

-	namespace = NS_CPP;

-	next();

-

-	if (isifdef) {

-		if (yytoken != IDEN) {

-			cpperror("no macro name given in #%s directive",

-			         (negate) ? "ifndef" : "ifdef");

-			return;

-		}

-		sym = yylval.sym;

-		next();

-		status = (sym->flags & SDECLARED) != 0;

-		if (!status)

-			killsym(sym);

-	} else {

-		/* TODO: catch recovery here */

-		if ((expr = constexpr()) == NULL) {

-			cpperror("parameter of #if is not an integer constant expression");

-			return;

-		}

-		status = expr->sym->u.i != 0;

-		freetree(expr);

-	}

-

-	if (negate)

-		status = !status;

-	if ((ifstatus[n] = status) == 0)

-		++cppoff;

-}

-

-static void

-cppif(void)

-{

-	disexpand = 0;

-	ifclause(0, 0);

-}

-

-static void

-ifdef(void)

-{

-	ifclause(0, 1);

-}

-

-static void

-ifndef(void)

-{

-	ifclause(1, 1);

-}

-

-static void

-elseclause(void)

-{

-	int status;

-

-	if (cppctx == 0) {

-		cpperror("#else without #ifdef/ifndef");

-		return;

-	}

-

-	status = ifstatus[cppctx-1];

-	ifstatus[cppctx-1] = !status;

-	cppoff += (status) ? 1 : -1;

-}

-

-static void

-cppelse(void)

-{

-	elseclause();

-	next();

-}

-

-static void

-elif(void)

-{

-	elseclause();

-	if (ifstatus[cppctx-1]) {

-		--cppctx;

-		cppif();

-	}

-}

-

-static void

-endif(void)

-{

-	if (cppctx == 0)

-		error("#endif without #if");

-	if (!ifstatus[--cppctx])

-		--cppoff;

-	next();

-}

-

-static void

-undef(void)

-{

-	if (cppoff)

-		return;

-

-	namespace = NS_CPP;

-	next();

-	if (yytoken != IDEN) {

-		error("no macro name given in #undef directive");

-		return;

-	}

-	killsym(yylval.sym);

-	next();

-}

-

-int

-cpp(void)

-{

-	static struct {

-		unsigned char token;

-		void (*fun)(void);

-	} *bp, clauses [] = {

-		{DEFINE, define},

-		{INCLUDE, include},

-		{LINE, line},

-		{IFDEF, ifdef},

-		{IF, cppif},

-		{ELIF, elif},

-		{IFNDEF, ifndef},

-		{ELSE, cppelse},

-		{ENDIF, endif},

-		{UNDEF, undef},

-		{PRAGMA, pragma},

-		{ERROR, usererr},

-		{0, NULL}

-	};

-	int ns;

-	char *p;

-

-	for (p = input->p; isspace(*p); ++p)

-		;

-

-	if (*p != '#')

-		return cppoff;

-	input->p = p+1;

-

-	disexpand = 1;

-	lexmode = CPPMODE;

-	ns = namespace;

-	namespace = NS_CPPCLAUSES;

-	next();

-	namespace = NS_IDEN;

-

-	for (bp = clauses; bp->token && bp->token != yytoken; ++bp)

-		;

-	if (!bp->token) {

-		errorp("incorrect preprocessor directive '%s'", yytext);

-		goto error;

-	}

-

-	DBG("CPP %s", yytext);

-

-	pushctx();              /* create a new context to avoid polish */

-	(*bp->fun)();           /* the current context, and to get all  */

-	popctx();               /* the symbols freed at the  end        */

-

-	/*

-	 * #include changes the content of input->line, so the correctness

-	 * of the line must be checked in the own include(), and we have

-	 * to skip this tests. For the same reason include() is the only

-	 * function which does not prepare the next token

-	 */

-	if (yytoken != '\n' && !cppoff && bp->token != INCLUDE)

-		errorp("trailing characters after preprocessor directive");

-

-error:

-	disexpand = 0;

-	lexmode = CCMODE;

-	namespace = ns;

-

-	return 1;

-}

-

-void

-ppragmaln(void)

-{

-	static char file[FILENAME_MAX];

-	static unsigned nline;

-	char *s;

-

-	putchar('\n');

-	if (strcmp(file, filenam)) {

-		strcpy(file, filenam);

-		s = "#line %u \"%s\"\n";

-	} else if (nline+1 != lineno) {

-		s = "#line %u\n";

-	} else {

-		s = "";

-	}

-	nline = lineno;

-	printf(s, nline, file);

-}

-

-void

-outcpp(void)

-{

-	int c;

-	char *s, *t;

-

-	for (next(); yytoken != EOFTOK; next()) {

-		if (onlyheader)

-			continue;

-		if (yytoken != STRING) {

-			printf("%s ", yytext);

-			continue;

-		}

-		for (s = yytext; c = *s; ++s) {

-			switch (c) {

-			case '\n':

-				t = "\\n";

-				goto print_str;

-			case '\v':

-				t = "\\v";

-				goto print_str;

-			case '\b':

-				t = "\\b";

-				goto print_str;

-			case '\t':

-				t = "\\t";

-				goto print_str;

-			case '\a':

-				t = "\\a";

-			print_str:

-				fputs(t, stdout);

-				break;

-			case '\\':

-				putchar('\\');

-			default:

-				if (!isprint(c))

-					printf("\\x%x", c);

-				else

-					putchar(c);

-				break;

-			}

-		}

-		putchar(' ');

-	}

-	putchar('\n');

-}

-

--- a/src/cmd/cc1/decl.c

+++ /dev/null

@@ -1,967 +1,0 @@

-static char sccsid[] = "@(#) ./cc1/decl.c";

-#include <stdarg.h>

-#include <stdlib.h>

-#include <string.h>

-

-#include <scc/cstd.h>

-#include <scc/scc.h>

-#include "cc1.h"

-

-#define NOSCLASS  0

-

-#define NOREP 0

-#define REP 1

-#define QUIET   1

-#define NOQUIET 0

-

-#define NR_DCL_TYP (NR_DECLARATORS+NR_FUNPARAM)

-#define NR_DCL_SYM (NR_DECLARATORS+NR_FUNPARAM+1)

-

-struct declarators {

-	unsigned nr;

-	unsigned ns;

-	struct decl *dcl;

-	unsigned nr_types;

-	Type **tpars;

-	Symbol **pars;

-	struct declarator {

-		unsigned char op;

-		TINT  nelem;

-		Symbol *sym;

-		Type **tpars;

-		Symbol **pars;

-	} d [NR_DECLARATORS];

-};

-

-struct decl {

-	unsigned ns;

-	int sclass;

-	int qualifier;

-	Symbol *sym;

-	Type *type;

-	Type *parent;

-	Symbol **pars;

-	Symbol *bufpars[NR_DCL_SYM];

-	Type *buftpars[NR_DCL_TYP];

-};

-

-

-static void

-endfundcl(Type *tp, Symbol **pars)

-{

-	if (tp->prop&TK_R && *pars)

-		warn("parameter names (without types) in function declaration");

-	/*

-	 * avoid non used warnings in prototypes

-	 */

-	while (*pars)

-		(*pars++)->flags |= SUSED;

-	popctx();

-}

-

-static void

-push(struct declarators *dp, int op, ...)

-{

-	va_list va;

-	unsigned n;

-	struct declarator *p;

-

-	va_start(va, op);

-	if ((n = dp->nr++) == NR_DECLARATORS)

-		error("too many declarators");

-

-	p = &dp->d[n];

-	p->op = op;

-	p->tpars = NULL;

-

-	switch (op) {

-	case ARY:

-		p->nelem = va_arg(va, TINT);

-		break;

-	case KRFTN:

-	case FTN:

-		p->nelem = va_arg(va, unsigned);

-		p->tpars = va_arg(va, Type **);

-		p->pars = va_arg(va, Symbol **);

-		break;

-	case IDEN:

-		p->sym = va_arg(va, Symbol *);

-		break;

-	}

-	va_end(va);

-}

-

-static int

-pop(struct declarators *dp, struct decl *dcl)

-{

-	struct declarator *p;

-

-	if (dp->nr == 0)

-		return 0;

-

-	p = &dp->d[--dp->nr];

-	if (p->op == IDEN) {

-		dcl->sym = p->sym;

-		return 1;

-	}

-

-	if (dcl->type->op == FTN)

-		endfundcl(dcl->type, dcl->pars);

-	dcl->pars = p->pars;

-

-	dcl->type = mktype(dcl->type, p->op, p->nelem, p->tpars);

-	return 1;

-}

-

-static void

-arydcl(struct declarators *dp)

-{

-	Node *np = NULL;

-	TINT n = 0;

-

-	expect('[');

-	if (yytoken != ']') {

-		if ((np = constexpr()) == NULL) {

-			errorp("invalid storage size");

-		} else {

-			if ((n = np->sym->u.i) <= 0) {

-				errorp("array size is not a positive number");

-				n = 1;

-			}

-			freetree(np);

-		}

-	}

-	expect(']');

-

-	push(dp, ARY, n);

-}

-

-static int

-empty(Symbol *sym, Type *tp, int param)

-{

-	if (!sym->name) {

-		sym->type = tp;

-		switch (tp->op) {

-		default:

-			 /* warn if it is not a parameter */

-			if (!param)

-				warn("empty declaration");

-		case STRUCT:

-		case UNION:

-		case ENUM:

-			return 1;

-		}

-	}

-	return 0;

-}

-

-static void

-bad_storage(Type *tp, char *name)

-{

-	if (tp->op != FTN)

-		errorp("incorrect storage class for file-scope declaration");

-	else

-		errorp("invalid storage class for function '%s'", name);

-}

-

-static Symbol *

-redcl(Symbol *sym, Type *tp, int sclass)

-{

-	int flags;

-	char *name = sym->name;

-

-	if (!eqtype(sym->type, tp, 1)) {

-		errorp("conflicting types for '%s'", name);

-		return sym;

-	}

-

-	if (sym->token == TYPEIDEN && sclass != TYPEDEF ||

-	    sym->token != TYPEIDEN && sclass == TYPEDEF) {

-		goto redeclaration;

-	}

-	if (curctx != GLOBALCTX && tp->op != FTN) {

-		/* is it the redeclaration of a local variable? */

-		if ((sym->flags & SEXTERN) && sclass == EXTERN)

-			return sym;

-		goto redeclaration;

-	}

-

-	flags = sym->flags;

-	switch (sclass) {

-	case REGISTER:

-	case AUTO:

-		bad_storage(tp, name);

-		break;

-	case NOSCLASS:

-		if ((flags & SPRIVATE) == 0) {

-			if (flags & SEXTERN)

-				flags &= ~(SEXTERN|SEMITTED);

-			flags |= SGLOBAL;

-			break;

-		}

-		errorp("non-static declaration of '%s' follows static declaration",

-		       name);

-		break;

-	case TYPEDEF:

-		/* Only C11 allows multiple definitions of a typedef. */

-		goto redeclaration;

-	case EXTERN:

-		break;

-	case STATIC:

-		if ((flags & (SGLOBAL|SEXTERN)) == 0) {

-			flags |= SPRIVATE;

-			break;

-		}

-		errorp("static declaration of '%s' follows non-static declaration",

-		       name);

-		break;

-	}

-	sym->flags = flags;

-

-	return sym;

-

-redeclaration:

-	errorp("redeclaration of '%s'", name);

-	return sym;

-}

-

-static Symbol *

-identifier(struct decl *dcl)

-{

-	Symbol *sym = dcl->sym;

-	Type *tp = dcl->type;

-	int sclass = dcl->sclass;

-	char *name = sym->name;

-

-	if (empty(sym, tp, 0))

-		return sym;

-

-	/* TODO: Add warning about ANSI limits */

-	if (!(tp->prop & TDEFINED)                &&

-	    sclass != EXTERN && sclass != TYPEDEF &&

-	    !(tp->op == ARY && yytoken == '=')) {

-		errorp("declared variable '%s' of incomplete type", name);

-	}

-

-	if (tp->op == FTN) {

-		if (sclass == NOSCLASS)

-			sclass = EXTERN;

-		if (!strcmp(name, "main") && tp->type != inttype) {

-			errorp("main shall be defined with a return type of int");

-			errorp("please contact __20h__ on irc.freenode.net (#bitreich-en) via IRC");

-		}

-	}

-

-	if (sym->flags & SDECLARED) {

-		sym = redcl(dcl->sym, tp, sclass);

-	} else {

-		int flags = sym->flags | SDECLARED;

-

-		sym->type = tp;

-

-		switch (sclass) {

-		case REGISTER:

-		case AUTO:

-			if (curctx != GLOBALCTX && tp->op != FTN) {

-				flags |= (sclass == REGISTER) ? SREGISTER : SAUTO;

-				break;

-			}

-			bad_storage(tp, name);

-		case NOSCLASS:

-			if (tp->op == FTN)

-				flags |= SEXTERN;

-			else

-				flags |= (curctx == GLOBALCTX) ? SGLOBAL : SAUTO;

-			break;

-		case EXTERN:

-			flags |= SEXTERN;

-			break;

-		case STATIC:

-			flags |= (curctx == GLOBALCTX) ? SPRIVATE : SLOCAL;

-			break;

-		case TYPEDEF:

-			flags |= STYPEDEF;

-			sym->u.token = sym->token = TYPEIDEN;

-			break;

-		}

-		sym->flags = flags;

-	}

-

-	if (accept('='))

-		initializer(sym, sym->type);

-	if (!(sym->flags & (SGLOBAL|SEXTERN)) && tp->op != FTN)

-		sym->flags |= SDEFINED;

-	if (sym->token == IDEN && tp->op != FTN)

-		emit(ODECL, sym);

-	return sym;

-}

-

-static Symbol *

-parameter(struct decl *dcl)

-{

-	Symbol *sym = dcl->sym;

-	Type *funtp = dcl->parent, *tp = dcl->type;

-	char *name = sym->name;

-	int flags;

-

-	flags = 0;

-	switch (dcl->sclass) {

-	case STATIC:

-	case EXTERN:

-	case AUTO:

-		errorp("bad storage class in function parameter");

-		break;

-	case REGISTER:

-		flags |= SREGISTER;

-		break;

-	case NOSCLASS:

-		flags |= SAUTO;

-		break;

-	}

-

-	switch (tp->op) {

-	case VOID:

-		funtp->n.elem = 1;

-		if (dcl->sclass)

-			errorp("void as unique parameter may not be qualified");

-		return NULL;

-	case ARY:

-		tp = mktype(tp->type, PTR, 0, NULL);

-		break;

-	case FTN:

-		errorp("incorrect function type for a function parameter");

-		return NULL;

-	}

-	if (!empty(sym, tp, 1)) {

-		int isdcl = sym->flags&SDECLARED, isk_r = funtp->prop & TK_R;

-		if (isdcl && !isk_r) {

-			errorp("redefinition of parameter '%s'", name);

-			return NULL;

-		}

-		if (!isdcl && isk_r) {

-			errorp("declaration for parameter '%s' but no such parameter",

-			       sym->name);

-			return NULL;

-		}

-		sym->flags |= SDECLARED;

-	}

-

-	sym->type = tp;

-	sym->flags &= ~(SAUTO|SREGISTER);

-	sym->flags |= flags;

-	return sym;

-}

-

-static Symbol *dodcl(int rep,

-                     Symbol *(*fun)(struct decl *),

-                     unsigned ns,

-                     Type *type);

-

-static int

-krpars(struct declarators *dp)

-{

-	Symbol *sym;

-	int toomany = 0;

-	unsigned npars = 0;

-

-	do {

-		sym = yylval.sym;

-		expect(IDEN);

-		sym->flags |= SAUTO;

-		if ((sym = install(NS_IDEN, sym)) == NULL) {

-			errorp("redefinition of parameter '%s'",

-			       yylval.sym->name);

-			continue;

-		}

-		if (npars < NR_FUNPARAM) {

-			++npars;

-			*dp->pars++ = sym;

-			continue;

-		}

-		if (!toomany)

-		toomany = 1;

-	} while (accept(','));

-

-	return toomany;

-}

-

-static unsigned

-krfun(struct declarators *dp)

-{

-	int toomany = 0;

-

-

-	if (yytoken != ')')

-		toomany = krpars(dp);

-

-	if (dp->nr_types == NR_DCL_TYP) {

-		toomany = 1;

-	} else {

-		++dp->nr_types;

-		*dp->tpars++ = ellipsistype;

-	}

-

-	if (toomany)

-		errorp("too many parameters in function definition");

-	return 1;

-}

-

-static unsigned

-ansifun(struct declarators *dp)

-{

-	Symbol *sym;

-	unsigned npars, ntype, toomany, distoomany, voidpar;

-	Type type, *tp;

-

-	type.n.elem = 0;

-	type.prop = 0;

-	npars = ntype = toomany = distoomany = voidpar = 0;

-

-	do {

-		if (accept(ELLIPSIS)) {

-			if (ntype < 1)

-				errorp("a named argument is requiered before '...'");

-			if (yytoken != ')')

-				errorp("... must be the last parameter");

-			sym = NULL;

-			tp = ellipsistype;

-		} else if ((sym = dodcl(NOREP, parameter, NS_IDEN, &type)) == NULL) {

-			if (type.n.elem == 1 && ntype > 1)

-				voidpar = 1;

-			sym = NULL;

-			tp = NULL;

-		} else {

-			tp = sym->type;

-		}

-

-		if (sym) {

-			if (npars == NR_FUNPARAM) {

-				toomany = 1;

-			} else {

-				npars++;

-				*dp->pars++ = sym;

-			}

-		}

-

-		if (tp) {

-			if (dp->nr_types == NR_DCL_TYP) {

-				toomany = 1;

-			} else {

-				ntype++;

-				dp->nr_types++;

-				*dp->tpars++ = tp;

-			}

-		}

-

-	} while (accept(','));

-

-	if (toomany == 1)

-		errorp("too many parameters in function definition");

-	if (voidpar && ntype > 1)

-		errorp("'void' must be the only parameter");

-	return ntype;

-}

-

-static int

-funbody(Symbol *sym, Symbol *pars[])

-{

-	Type *tp;

-	Symbol **bp, *p;

-

-	if (!sym)

-		return 0;

-	tp = sym->type;

-	if (tp->op != FTN)

-		return 0;

-

-	switch (yytoken) {

-	case '{':

-	case TYPE:

-	case TYPEIDEN:

-		if (curctx != PARAMCTX)

-			errorp("nested function declaration");

-		if (sym && sym->ns == NS_IDEN)

-			break;

-	default:

-		emit(ODECL, sym);

-		endfundcl(tp, pars);

-		return  0;

-	}

-

-	tp->prop |= TFUNDEF;

-	curfun = sym;

-	if (sym->type->prop & TK_R) {

-		while (yytoken != '{') {

-			dodcl(REP, parameter, NS_IDEN, sym->type);

-			expect(';');

-		}

-		for (bp = pars; p = *bp; ++bp) {

-			if (p->type == NULL) {

-				warn("type of '%s' defaults to int", p->name);

-				p->type = inttype;

-			}

-		}

-	}

-	if (sym->flags & STYPEDEF)

-		errorp("function definition declared 'typedef'");

-	if (sym->flags & SDEFINED)

-		errorp("redefinition of '%s'", sym->name);

-	if (sym->flags & SEXTERN) {

-		sym->flags &= ~SEXTERN;

-		sym->flags |= SGLOBAL;

-	}

-	sym->flags |= SDEFINED;

-	sym->flags &= ~SEMITTED;

-	sym->u.pars = pars;

-	emit(OFUN, sym);

-	compound(NULL, NULL, NULL);

-	emit(OEFUN, NULL);

-	popctx();

-	flushtypes();

-	curfun = NULL;

-	return 1;

-}

-

-static void

-fundcl(struct declarators *dp)

-{

-	Type **types = dp->tpars;

-	unsigned ntypes, typefun;

-	Symbol **pars = dp->pars;

-	unsigned (*fun)(struct declarators *);

-

-	pushctx();

-	expect('(');

-	if (yytoken == ')' || yytoken == IDEN) {

-		typefun = KRFTN;

-		fun = krfun;

-	} else {

-		typefun = FTN;

-		fun = ansifun;

-	}

-	ntypes = (*fun)(dp);

-	*dp->pars++= NULL;

-	expect(')');

-

-	push(dp, typefun, ntypes, types, pars);

-}

-

-static void declarator(struct declarators *dp);

-

-static void

-directdcl(struct declarators *dp)

-{

-	Symbol *p, *sym;

-	static int nested;

-

-	if (accept('(')) {

-		if (nested == NR_SUBTYPE)

-			error("too many declarators nested by parentheses");

-		++nested;

-		declarator(dp);

-		--nested;

-		expect(')');

-	} else {

-		if (yytoken == IDEN || yytoken == TYPEIDEN) {

-			sym = yylval.sym;

-			if (p = install(dp->ns, sym)) {

-				sym = p;

-				sym->flags &= ~SDECLARED;

-			}

-			next();

-		} else {

-			sym = newsym(dp->ns, NULL);

-		}

-		push(dp, IDEN, sym);

-	}

-

-	for (;;) {

-		switch (yytoken) {

-		case '(':  fundcl(dp); break;

-		case '[':  arydcl(dp); break;

-		default:   return;

-		}

-	}

-}

-

-static void

-declarator(struct declarators *dp)

-{

-	unsigned  n;

-

-	for (n = 0; accept('*'); ++n) {

-		while (accept(TQUALIFIER))

-			;

-	}

-

-	directdcl(dp);

-

-	while (n--)

-		push(dp, PTR);

-}

-

-static Type *structdcl(void), *enumdcl(void);

-

-static Type *

-specifier(int *sclass, int *qualifier)

-{

-	Type *tp = NULL;

-	unsigned spec, qlf, sign, type, cls, size;

-

-	spec = qlf = sign = type = cls = size = 0;

-

-	for (;;) {

-		unsigned *p = NULL;

-		Type *(*dcl)(void) = NULL;

-

-		switch (yytoken) {

-		case SCLASS:

-			p = &cls;

-			break;

-		case TQUALIFIER:

-			qlf |= yylval.token;

-			next();

-			continue;

-		case TYPEIDEN:

-			if (type)

-				goto return_type;

-			tp = yylval.sym->type;

-			p = &type;

-			break;

-		case TYPE:

-			switch (yylval.token) {

-			case ENUM:

-				dcl = enumdcl;

-				p = &type;

-				break;

-			case STRUCT:

-			case UNION:

-				dcl = structdcl;

-				p = &type;

-				break;

-			case VA_LIST:

-			case VOID:

-			case BOOL:

-			case CHAR:

-			case INT:

-			case FLOAT:

-			case DOUBLE:

-				p = &type;

-				break;

-			case SIGNED:

-			case UNSIGNED:

-				p = &sign;

-				break;

-			case LONG:

-				if (size == LONG) {

-					yylval.token = LLONG;

-					size = 0;

-				}

-			case SHORT:

-				p = &size;

-				break;

-			}

-			break;

-		default:

-			goto return_type;

-		}

-		if (*p)

-			errorp("invalid type specification");

-		*p = yylval.token;

-		if (dcl) {

-			if (size || sign)

-				errorp("invalid type specification");

-			tp = (*dcl)();

-			goto return_type;

-		} else {

-			next();

-		}

-		spec = 1;

-	}

-

-return_type:

-	*sclass = cls;

-	*qualifier = qlf;

-	if (!tp) {

-		if (spec) {

-			tp = ctype(type, sign, size);

-		} else {

-			if (curctx != GLOBALCTX)

-				unexpected();

-			warn("type defaults to 'int' in declaration");

-			tp = inttype;

-		}

-	}

-	return tp;

-}

-

-static Symbol *

-newtag(void)

-{

-	Symbol *sym;

-	int ns, op, tag = yylval.token;

-	static unsigned tpns = NS_STRUCTS;

-

-	ns = namespace;

-	namespace = NS_TAG;

-	next();

-	namespace = ns;

-

-	switch (yytoken) {

-	case IDEN:

-	case TYPEIDEN:

-		sym = yylval.sym;

-		if ((sym->flags & SDECLARED) == 0)

-			install(NS_TAG, yylval.sym);

-		next();

-		break;

-	default:

-		sym = newsym(NS_TAG, NULL);

-		break;

-	}

-	if (!sym->type) {

-		Type *tp;

-

-		if (tpns == NS_STRUCTS + NR_MAXSTRUCTS)

-			error("too many tags declared");

-		tp = mktype(NULL, tag, 0, NULL);

-		tp->ns = tpns++;

-		sym->type = tp;

-		tp->tag = sym;

-		DBG("declared tag '%s' with ns = %d\n",

-		    (sym->name) ? sym->name : "anonymous", tp->ns);

-	}

-

-	if ((op = sym->type->op) != tag &&  op != INT)

-		error("'%s' defined as wrong kind of tag", sym->name);

-	return sym;

-}

-

-static void fieldlist(Type *tp);

-

-static Type *

-structdcl(void)

-{

-	Symbol *sym;

-	Type *tp;

-	static int nested;

-	int ns;

-

-	sym = newtag();

-	tp = sym->type;

-

-	if (!accept('{'))

-		return tp;

-

-	ns = namespace;

-	namespace = tp->ns;

-

-	if (tp->prop & TDEFINED && sym->ctx == curctx)

-		error("redefinition of struct/union '%s'", sym->name);

-

-	if (nested == NR_STRUCT_LEVEL)

-		error("too many levels of nested structure or union definitions");

-

-	++nested;

-	while (yytoken != '}') {

-		fieldlist(tp);

-	}

-	--nested;

-

-	deftype(tp);

-	namespace = ns;

-	expect('}');

-	return tp;

-}

-

-static Type *

-enumdcl(void)

-{

-	Type *tp;

-	Symbol *sym, *tagsym;

-	int ns, val, toomany;

-	unsigned nctes;

-

-	ns = namespace;

-	tagsym = newtag();

-	tp = tagsym->type;

-

-	if (!accept('{'))

-		goto restore_name;

-	if (tp->prop & TDEFINED)

-		errorp("redefinition of enumeration '%s'", tagsym->name);

-	deftype(tp);

-	namespace = NS_IDEN;

-

-	/* TODO: check incorrect values in val */

-	for (nctes = val = 0; yytoken != '}'; ++nctes, ++val) {

-		if (yytoken != IDEN)

-			unexpected();

-		sym = yylval.sym;

-		next();

-		if (nctes == NR_ENUM_CTES && !toomany) {

-			errorp("too many enum constants in a single enum");

-			toomany = 1;

-		}

-		if (accept('=')) {

-			Node *np = constexpr();

-

-			if (np == NULL)

-				errorp("invalid enumeration value");

-			else

-				val = np->sym->u.i;

-			freetree(np);

-		}

-		if ((sym = install(NS_IDEN, sym)) == NULL) {

-			errorp("'%s' redeclared as different kind of symbol",

-			       yytext);

-		} else {

-			sym->u.i = val;

-			sym->flags |= SCONSTANT;

-			sym->type = inttype;

-		}

-		if (!accept(','))

-			break;

-	}

-	expect('}');

-

-restore_name:

-	namespace = ns;

-	return tp;

-}

-

-static Symbol *

-type(struct decl *dcl)

-{

-	Symbol *sym = dcl->sym;

-

-	if (dcl->sclass)

-		error("class storage in type name");

-	if (sym->name)

-		error("unexpected identifier in type name");

-	sym->type = dcl->type;

-

-	return sym;

-}

-

-static Symbol *

-field(struct decl *dcl)

-{

-	static char *anon = "<anonymous>";

-	Symbol *sym = dcl->sym;

-	char *name = (sym->name) ? sym->name : anon;

-	Type *structp = dcl->parent, *tp = dcl->type;

-	TINT n = structp->n.elem;

-	int err = 0;

-

-	if (accept(':')) {

-		Node *np;

-		TINT n;

-

-		if ((np = constexpr()) == NULL) {

-			unexpected();

-			n = 0;

-		} else {

-			n = np->sym->u.i;

-			freetree(np);

-		}

-		if (n == 0 && name != anon)

-			errorp("zero width for bit-field '%s'", name);

-		if (tp != booltype && tp != inttype && tp != uinttype)

-			errorp("bit-field '%s' has invalid type", name);

-		if (n < 0)

-			errorp("negative width in bit-field '%s'", name);

-		else if (n > tp->size*8)

-			errorp("width of '%s' exceeds its type", name);

-	} else if (empty(sym, tp, 0)) {

-		return sym;

-	}

-

-	if (tp->op == FTN) {

-		errorp("invalid type '%s' in struct/union", name);

-		err = 1;

-	}

-	if (dcl->sclass) {

-		errorp("storage class in struct/union field '%s'", name);

-		err = 1;

-	}

-	if (!(tp->prop & TDEFINED)) {

-		error("field '%s' has incomplete type", name);

-		err = 1;

-	}

-	if (err)

-		return sym;

-

-	if (sym->flags & SDECLARED)

-		error("duplicated member '%s'", name);

-	sym->flags |= SFIELD|SDECLARED;

-	sym->type = tp;

-

-	if (n == NR_FIELDS)

-		error("too many fields in struct/union");

-	DBG("New field '%s' in namespace %d\n", name, structp->ns);

-	structp->p.fields = xrealloc(structp->p.fields, ++n * sizeof(*sym));

-	structp->p.fields[n-1] = sym;

-	structp->n.elem = n;

-

-	return sym;

-}

-

-static Symbol *

-dodcl(int rep, Symbol *(*fun)(struct decl *), unsigned ns, Type *parent)

-{

-	Symbol *sym;

-	Type *base;

-	struct decl dcl;

-	struct declarators stack;

-

-	dcl.ns = ns;

-	dcl.parent = parent;

-	base = specifier(&dcl.sclass, &dcl.qualifier);

-

-	do {

-		dcl.type = base;

-		stack.nr_types = stack.nr = 0;

-		stack.tpars = dcl.buftpars;

-		stack.pars = dcl.bufpars;

-		stack.dcl = &dcl;

-		stack.ns = ns;

-

-		declarator(&stack);

-

-		while (pop(&stack, &dcl))

-			;

-		sym = (*fun)(&dcl);

-		if (funbody(sym, dcl.pars))

-			return sym;

-	} while (rep && accept(','));

-

-	return sym;

-}

-

-void

-decl(void)

-{

-	Symbol *sym;

-

-	if (accept(';'))

-		return;

-	sym = dodcl(REP, identifier, NS_IDEN, NULL);

-	if (sym->type->prop & TFUNDEF)

-		return;

-	expect(';');

-}

-

-static void

-fieldlist(Type *tp)

-{

-	if (yytoken != ';')

-		dodcl(REP, field, tp->ns, tp);

-	expect(';');

-}

-

-Type *

-typename(void)

-{

-	return dodcl(NOREP, type, NS_DUMMY, NULL)->type;

-}

--- a/src/cmd/cc1/deps.mk

+++ /dev/null

@@ -1,44 +1,0 @@

-#deps

-builtin.o: $(INCDIR)/scc/scc/scc.h

-builtin.o: cc1.h

-code.o: $(INCDIR)/scc/scc/scc.h

-code.o: cc1.h

-cpp.o: $(INCDIR)/scc/scc/cstd.h

-cpp.o: $(INCDIR)/scc/scc/scc.h

-cpp.o: cc1.h

-decl.o: $(INCDIR)/scc/scc/cstd.h

-decl.o: $(INCDIR)/scc/scc/scc.h

-decl.o: cc1.h

-error.o: $(INCDIR)/scc/scc/scc.h

-error.o: cc1.h

-expr.o: $(INCDIR)/scc/scc/cstd.h

-expr.o: $(INCDIR)/scc/scc/scc.h

-expr.o: cc1.h

-fold.o: $(INCDIR)/scc/scc/scc.h

-fold.o: cc1.h

-init.o: $(INCDIR)/scc/scc/cstd.h

-init.o: $(INCDIR)/scc/scc/scc.h

-init.o: cc1.h

-lex.o: $(INCDIR)/scc/scc/cstd.h

-lex.o: $(INCDIR)/scc/scc/scc.h

-lex.o: cc1.h

-main.o: $(INCDIR)/scc/scc/arg.h

-main.o: $(INCDIR)/scc/scc/scc.h

-main.o: cc1.h

-stmt.o: $(INCDIR)/scc/scc/cstd.h

-stmt.o: $(INCDIR)/scc/scc/scc.h

-stmt.o: cc1.h

-symbol.o: $(INCDIR)/scc/scc/cstd.h

-symbol.o: $(INCDIR)/scc/scc/scc.h

-symbol.o: cc1.h

-target/amd64-sysv/arch.o: $(INCDIR)/scc/scc/scc.h

-target/amd64-sysv/arch.o: target/amd64-sysv/../../cc1.h

-target/arm64-sysv/arch.o: $(INCDIR)/scc/scc/scc.h

-target/arm64-sysv/arch.o: target/arm64-sysv/../../cc1.h

-target/i386-sysv/arch.o: $(INCDIR)/scc/scc/scc.h

-target/i386-sysv/arch.o: target/i386-sysv/../../cc1.h

-target/z80-scc/arch.o: $(INCDIR)/scc/scc/scc.h

-target/z80-scc/arch.o: target/z80-scc/../../cc1.h

-types.o: $(INCDIR)/scc/scc/cstd.h

-types.o: $(INCDIR)/scc/scc/scc.h

-types.o: cc1.h

--- a/src/cmd/cc1/error.c

+++ /dev/null

@@ -1,85 +1,0 @@

-static char sccsid[] = "@(#) ./cc1/error.c";

-#include <stdarg.h>

-#include <stdio.h>

-#include <stdlib.h>

-

-#include <scc/scc.h>

-#include "cc1.h"

-

-#define MAXERRNUM 10

-

-extern int failure;

-static unsigned nerrors;

-

-static void

-warn_error(int flag, char *fmt, va_list va)

-{

-	if (flag == 0)

-		return;

-	fprintf(stderr, "%s:%u: %s: ",

-	       filenam, lineno,

-	       (flag < 0) ? "error" : "warning");

-	vfprintf(stderr, fmt, va);

-	putc('\n', stderr);

-

-	if (flag < 0) {

-		if (!failure)

-			fclose(stdout);

-		failure = 1;

-		if (++nerrors == MAXERRNUM) {

-			fputs("too many errors\n", stderr);

-			exit(1);

-		}

-	}

-}

-

-void

-warn(char *fmt, ...)

-{

-	extern int warnings;

-

-	va_list va;

-	va_start(va, fmt);

-	warn_error(warnings, fmt, va);

-	va_end(va);

-}

-

-void

-error(char *fmt, ...)

-{

-	va_list va;

-

-	va_start(va, fmt);

-	warn_error(-1, fmt, va);

-	va_end(va);

-	exit(1);

-	discard();

-}

-

-void

-errorp(char *fmt, ...)

-{

-	va_list va;

-	va_start(va, fmt);

-	warn_error(-1, fmt, va);

-	va_end(va);

-}

-

-void

-cpperror(char *fmt, ...)

-{

-	va_list va;

-	va_start(va, fmt);

-	warn_error(-1, fmt, va);

-	va_end(va);

-

-	/* discard input until the end of the line */

-	*input->p = '\0';

-	next();

-}

-

-void

-unexpected(void)

-{

-	error("unexpected '%s'", yytext);

-}

--- a/src/cmd/cc1/expr.c

+++ /dev/null

@@ -1,1185 +1,0 @@

-static char sccsid[] = "@(#) ./cc1/expr.c";

-#include <assert.h>

-#include <stdlib.h>

-#include <string.h>

-

-#include <scc/cstd.h>

-#include <scc/scc.h>

-#include "cc1.h"

-

-#define XCHG(lp, rp, np) (np = lp, lp = rp, rp = np)

-

-static Node *xexpr(void), *xassign(void);

-

-int

-cmpnode(Node *np, TUINT val)

-{

-	Symbol *sym;

-	Type *tp;

-	TUINT mask, nodeval;

-

-	if (!np || !(np->flags & NCONST) || !np->sym)

-		return 0;

-	sym = np->sym;

-	tp = sym->type;

-

-	switch (tp->op) {

-	case PTR:

-	case INT:

-		mask = (val > 1) ? ones(np->type->size) : -1;

-		nodeval = (tp->prop & TSIGNED) ? sym->u.i : sym->u.u;

-		return (nodeval & mask) == (val & mask);

-	case FLOAT:

-		return sym->u.f == val;

-	}

-	return 0;

-}

-

-static Node *

-promote(Node *np)

-{

-	Type *tp;

-	Node *new;

-	struct limits *lim, *ilim;

-

-	tp = np->type;

-

-	switch (tp->op) {

-	case ENUM:

-	case INT:

-		if (tp->n.rank >= inttype->n.rank)

-			return np;

-		lim = getlimits(tp);

-		ilim = getlimits(inttype);

-		tp = (lim->max.i <= ilim->max.i) ? inttype : uinttype;

-		break;

-	case FLOAT:

-		/* TODO: Add support for C99 float math */

-		tp = doubletype;

-		break;

-	default:

-		abort();

-	}

-	if ((new = convert(np, tp, 1)) != NULL)

-		return new;

-	return np;

-}

-

-static void

-arithconv(Node **p1, Node **p2)

-{

-	int to = 0, s1, s2;

-	unsigned r1, r2;

-	Type *tp1, *tp2;

-	Node *np1, *np2;

-	struct limits *lp1, *lp2;

-

-	np1 = promote(*p1);

-	np2 = promote(*p2);

-

-	tp1 = np1->type;

-	tp2 = np2->type;

-

-	if (tp1 == tp2)

-		goto set_p1_p2;

-

-	s1 = (tp1->prop & TSIGNED) != 0;

-	r1 = tp1->n.rank;

-	lp1 = getlimits(tp1);

-

-	s2 = (tp2->prop & TSIGNED) != 0;

-	r2 = tp2->n.rank;

-	lp2 = getlimits(tp2);

-

-	if (s1 == s2 || tp1->op == FLOAT || tp2->op == FLOAT) {

-		to = r1 - r2;

-	} else if (!s1) {

-		if (r1 >= r2 || lp1->max.i >= lp2->max.i)

-			to = 1;

-		else

-			to = -1;

-	} else {

-		if (r2 >= r1 || lp2->max.i >= lp1->max.i)

-			to = -1;

-		else

-			to = 1;

-	}

-

-	if (to > 0)

-		np2 = convert(np2, tp1, 1);

-	else if (to < 0)

-		np1 = convert(np1, tp2, 1);

-		

-set_p1_p2:

-	*p1 = np1;

-	*p2 = np2;

-}

-

-static int

-null(Node *np)

-{

-	if (np->type != pvoidtype || np->op != OCAST)

-		return 0;

-

-	np = np->left;

-	if (np->type != inttype)

-		return 0;

-

-	return cmpnode(np, 0);

-}

-

-static Node *

-chkternary(Node *yes, Node *no)

-{

-	/*

-	 * FIXME:

-	 * We are ignoring type qualifiers here,

-	 * but the standard has strong rules about this.

-	 * take a look to 6.5.15

-	 */

-

-	if (!eqtype(yes->type, no->type, 1)) {

-		if ((yes->type->prop & TARITH) && (no->type->prop & TARITH)) {

-			arithconv(&yes, &no);

-		} else if (yes->type->op != PTR && no->type->op != PTR) {

-			goto wrong_type;

-		} else {

-			/* convert integer 0 to NULL */

-			if ((yes->type->prop & TINTEGER) && cmpnode(yes, 0))

-				yes = convert(yes, pvoidtype, 0);

-			if ((no->type->prop & TINTEGER) && cmpnode(no, 0))

-				no = convert(no, pvoidtype, 0);

-			/*

-			 * At this point the type of both should be

-			 * a pointer to something, or we have don't

-			 * compatible types

-			 */

-			if (yes->type->op != PTR || no->type->op != PTR)

-				goto wrong_type;

-			/*

-			 * If we have a null pointer constant then

-			 * convert to the another type

-			 */

-			if (null(yes))

-				yes = convert(yes, no->type, 0);

-			if (null(no))

-				no = convert(no, yes->type, 0);

-

-			if (!eqtype(yes->type, no->type, 1))

-				goto wrong_type;

-		}

-	}

-	return node(OCOLON, yes->type, yes, no);

-

-wrong_type:

-	errorp("type mismatch in conditional expression");

-	freetree(yes);

-	freetree(no);

-	return constnode(zero);

-}

-

-static void

-chklvalue(Node *np)

-{

-	if (!(np->flags & NLVAL))

-		errorp("lvalue required in operation");

-	if (np->type == voidtype)

-		errorp("invalid use of void expression");

-}

-

-Node *

-decay(Node *np)

-{

-	Node *new;

-	Type *tp = np->type;

-

-	switch (tp->op) {

-	case ARY:

-		tp = tp->type;

-		if (np->op == OPTR) {

-			new = np->left;

-			free(np);

-			new->type = mktype(tp, PTR, 0, NULL);

-			return new;

-		}

-	case FTN:

-		new = node(OADDR, mktype(tp, PTR, 0, NULL), np, NULL);

-		if (np->sym && np->sym->flags & (SGLOBAL|SLOCAL|SPRIVATE))

-			new->flags |= NCONST;

-		return new;

-	default:

-		return np;

-	}

-}

-

-static Node *

-integerop(int op, Node *lp, Node *rp)

-{

-	if (!(lp->type->prop & TINTEGER) || !(rp->type->prop & TINTEGER))

-		error("operator requires integer operands");

-	arithconv(&lp, &rp);

-	return node(op, lp->type, lp, rp);

-}

-

-static Node *

-integeruop(int op, Node *np)

-{

-	if (!(np->type->prop & TINTEGER))

-		error("unary operator requires integer operand");

-	np = promote(np);

-	return node(op, np->type, np, NULL);

-}

-

-static Node *

-numericaluop(int op, Node *np)

-{

-	if (!(np->type->prop & TARITH))

-		error("unary operator requires numerical operand");

-	np = promote(np);

-	return node(op, np->type, np, NULL);

-}

-

-Node *

-convert(Node *np, Type *newtp, int iscast)

-{

-	Type *oldtp = np->type;

-

-	if (eqtype(newtp, oldtp, 0))

-		return np;

-

-	switch (oldtp->op) {

-	case ENUM:

-	case INT:

-	case FLOAT:

-		switch (newtp->op) {

-		case PTR:

-			if (oldtp->op == FLOAT || !cmpnode(np, 0) && !iscast)

-				return NULL;

-		case INT:

-		case FLOAT:

-		case ENUM:

-			break;

-		default:

-			return NULL;

-		}

-		break;

-	case PTR:

-		switch (newtp->op) {

-		case ENUM:

-		case INT:

-		case VOID:

-			if (!iscast)

-				return NULL;

-			break;

-		case PTR:

-			if (eqtype(newtp, oldtp, 1) ||

-			    iscast ||

-			    newtp == pvoidtype || oldtp == pvoidtype) {

-				np->type = newtp;

-				return np;

-			}

-		default:

-			return NULL;

-		}

-		break;

-	default:

-		return NULL;

-	}

-	return node(OCAST, newtp, np, NULL);

-}

-

-static Node *

-parithmetic(int op, Node *lp, Node *rp)

-{

-	Type *tp;

-	Node *size, *np;

-

-	if (lp->type->op != PTR)

-		XCHG(lp, rp, np);

-

-	tp = rp->type;

-	if (tp->op == PTR && !(tp->type->prop & TDEFINED))

-		goto incomplete;

-	tp = lp->type;

-	if (!(tp->type->prop & TDEFINED))

-		goto incomplete;

-	size = sizeofnode(tp->type);

-

-	if (op == OSUB && BTYPE(rp) == PTR) {

-		if ((rp = convert(rp, lp->type, 0)) == NULL)

-			goto incorrect;

-		lp = node(OSUB, pdifftype, lp, rp);

-		return node(ODIV, inttype, lp, size);

-	}

-	if (!(rp->type->prop & TINTEGER))

-		goto incorrect;

-

-	rp = convert(promote(rp), sizettype, 0);

-	rp = node(OMUL, sizettype, rp, size);

-	rp = convert(rp, tp, 1);

-

-	return node(op, tp, lp, rp);

-

-incomplete:

-	errorp("invalid use of undefined type");

-	return lp;

-incorrect:

-	errorp("incorrect arithmetic operands");

-	return lp;

-

-}

-

-static Node *

-arithmetic(int op, Node *lp, Node *rp)

-{

-	Type *ltp = lp->type, *rtp = rp->type;

-

-	if ((ltp->prop & TARITH) && (rtp->prop & TARITH)) {

-		arithconv(&lp, &rp);

-		return node(op, lp->type, lp, rp);

-	} else if ((ltp->op == PTR || rtp->op == PTR)) {

-		switch (op) {

-		case OADD:

-		case OSUB:

-		case OA_ADD:

-		case OA_SUB:

-		case OINC:

-		case ODEC:

-			return parithmetic(op, lp, rp);

-		}

-	}

-	errorp("incorrect arithmetic operands");

-}

-

-static Node *

-pcompare(int op, Node *lp, Node *rp)

-{

-	Node *np;

-

-	if (lp->type->prop & TINTEGER)

-		XCHG(lp, rp, np);

-	else if (eqtype(lp->type, pvoidtype, 1))

-		XCHG(lp, rp, np);

-

-	if ((np = convert(rp, lp->type, 0)) != NULL)

-		rp = np;

-	else

-		errorp("incompatible types in comparison");

-	return convert(node(op, pvoidtype, lp, rp), inttype, 1);

-}

-

-static Node *

-compare(int op, Node *lp, Node *rp)

-{

-	Type *ltp, *rtp;

-

-	ltp = lp->type;

-	rtp = rp->type;

-

-	if (ltp->op == PTR || rtp->op == PTR) {

-		return pcompare(op, rp, lp);

-	} else if ((ltp->prop & TARITH) && (rtp->prop & TARITH)) {

-		arithconv(&lp, &rp);

-		return convert(node(op, lp->type, lp, rp), inttype, 1);;

-	} else {

-		errorp("incompatible types in comparison");

-		freetree(lp);

-		freetree(rp);

-		return constnode(zero);

-	}

-}

-

-int

-negop(int op)

-{

-	switch (op) {

-	case OEQ:  return ONE;

-	case ONE:  return OEQ;

-	case OLT:  return OGE;

-	case OGE:  return OLT;

-	case OLE:  return OGT;

-	case OGT:  return OLE;

-	default:   abort();

-	}

-	return op;

-}

-

-static Node *

-exp2cond(Node *np, int neg)

-{

-	if (np->type->prop & TAGGREG) {

-		errorp("used struct/union type value where scalar is required");

-		return constnode(zero);

-	}

-	switch (np->op) {

-	case ONEG:

-	case OOR:

-	case OAND:

-		return (neg) ? node(ONEG, inttype, np, NULL) : np;

-	case OEQ:

-	case ONE:

-	case OLT:

-	case OGE:

-	case OLE:

-	case OGT:

-		if (neg)

-			np->op = negop(np->op);

-		return np;

-	default:

-		return compare((neg) ?  OEQ : ONE, np, constnode(zero));

-	}

-}

-

-static Node *

-logic(int op, Node *lp, Node *rp)

-{

-	lp = exp2cond(lp, 0);

-	rp = exp2cond(rp, 0);

-	return node(op, inttype, lp, rp);

-}

-

-static Node *

-field(Node *np)

-{

-	Symbol *sym;

-

-	namespace = np->type->ns;

-	next();

-	namespace = NS_IDEN;

-

-	sym = yylval.sym;

-	if (yytoken != IDEN)

-		unexpected();

-	next();

-

-	if (!(np->type->prop & TAGGREG)) {

-		errorp("request for member '%s' in something not a structure or union",

-		      yylval.sym->name);

-		goto free_np;

-	}

-	if ((sym->flags & SDECLARED) == 0) {

-		errorp("incorrect field in struct/union");

-		goto free_np;

-	}

-	np = node(OFIELD, sym->type, np, varnode(sym));

-	np->flags |= NLVAL;

-	return np;

-

-free_np:

-	freetree(np);

-	return constnode(zero);

-}

-

-static Node *

-content(int op, Node *np)

-{

-	if (BTYPE(np) != PTR) {

-		errorp("invalid argument of memory indirection");

-	} else {

-		if (np->op == OADDR) {

-			Node *new = np->left;

-			new->type = np->type->type;

-			free(np);

-			np = new;

-		} else {

-			np = node(op, np->type->type, np, NULL);

-		}

-		np->flags |= NLVAL;

-	}

-	return np;

-}

-

-static Node *

-array(Node *lp, Node *rp)

-{

-	Type *tp;

-	Node *np;

-

-	if (!(lp->type->prop & TINTEGER) && !(rp->type->prop & TINTEGER))

-		error("array subscript is not an integer");

-	np = arithmetic(OADD, lp, rp);

-	tp = np->type;

-	if (tp->op != PTR)

-		errorp("subscripted value is neither array nor pointer");

-	return content(OPTR, np);

-}

-

-static Node *

-assignop(int op, Node *lp, Node *rp)

-{

-	if ((rp = convert(rp, lp->type, 0)) == NULL) {

-		errorp("incompatible types when assigning");

-		return lp;

-	}

-

-	return node(op, lp->type, lp, rp);

-}

-

-static Node *

-incdec(Node *np, int op)

-{

-	Type *tp = np->type;

-	Node *inc;

-

-	chklvalue(np);

-	np->flags |= NEFFECT;

-

-	if (!(tp->prop & TDEFINED)) {

-		errorp("invalid use of undefined type");

-		return np;

-	} else if (tp->op == PTR && !(tp->type->prop & TDEFINED)) {

-		errorp("%s of pointer to an incomplete type",

-		       (op == OINC || op == OA_ADD) ? "increment" : "decrement");

-		return np;

-	} else if (tp->op == PTR || (tp->prop & TARITH)) {

-		inc = constnode(one);

-	} else {

-		errorp("wrong type argument to increment or decrement");

-		return np;

-	}

-	return arithmetic(op, np, inc);

-}

-

-static Node *

-address(int op, Node *np)

-{

-	Node *new;

-

-	/*

-	 * ansi c accepts & applied to a function name, and it generates

-	 * a function pointer

-	 */

-	if (np->op == OSYM) {

-		if (np->type->op == FTN)

-			return decay(np);

-		if (np->type->op == ARY)

-			goto dont_check_lvalue;

-	}

-	chklvalue(np);

-

-dont_check_lvalue:

-	if (np->sym && (np->sym->flags & SREGISTER))

-		errorp("address of register variable '%s' requested", yytext);

-	new = node(op, mktype(np->type, PTR, 0, NULL), np, NULL);

-	if (np->sym && np->sym->flags & (SGLOBAL|SLOCAL|SPRIVATE))

-		new->flags |= NCONST;

-	return new;

-}

-

-static Node *

-negation(int op, Node *np)

-{

-	if (!(np->type->prop & TARITH) && np->type->op != PTR) {

-		errorp("invalid argument of unary '!'");

-		return constnode(zero);

-	}

-	return exp2cond(np, 1);

-}

-

-static Symbol *

-notdefined(Symbol *sym)

-{

-	int isdef;

-

-	if (namespace == NS_CPP && !strcmp(sym->name, "defined")) {

-		disexpand = 1;

-		next();

-		expect('(');

-		sym = yylval.sym;

-		expect(IDEN);

-		expect(')');

-

-		isdef = (sym->flags & SDECLARED) != 0;

-		sym = newsym(NS_IDEN, NULL);

-		sym->type = inttype;

-		sym->flags |= SCONSTANT;

-		sym->u.i = isdef;

-		disexpand = 0;

-		return sym;

-	}

-	errorp("'%s' undeclared", yytext);

-	sym->type = inttype;

-	return install(sym->ns, yylval.sym);

-}

-

-static Symbol *

-adjstrings(Symbol *sym)

-{

-	char *s, *t;

-	size_t len, n;

-	Type *tp;

-

-	tp = sym->type;

-	s = sym->u.s;

-	for (len = strlen(s);; len += n) {

-		next();

-		if (yytoken != STRING)

-			break;

-		t = yylval.sym->u.s;

-		n = strlen(t);

-		s = xrealloc(s, len + n + 1);

-		memcpy(s+len, t, n);

-		s[len + n] = '\0';

-		killsym(yylval.sym);

-	}

-	++len;

-	if (tp->n.elem != len) {

-		sym->type = mktype(chartype, ARY, len, NULL);

-		sym->u.s = s;

-	}

-	return sym;

-}

-

-/*************************************************************

- * grammar functions                                         *

- *************************************************************/

-static Node *

-primary(void)

-{

-	Node *np;

-	Symbol *sym;

-	Node *(*fun)(Symbol *);

-

-	sym = yylval.sym;

-	switch (yytoken) {

-	case STRING:

-		np = constnode(adjstrings(sym));

-		sym->flags |= SHASINIT;

-		emit(ODECL, sym);

-		emit(OINIT, np);

-		return varnode(sym);

-	case BUILTIN:

-		fun = sym->u.fun;

-		next();

-		expect('(');

-		np = (*fun)(sym);

-		expect(')');

-

-		/* do not call to next */

-		return np;

-	case CONSTANT:

-		np = constnode(sym);

-		break;

-	case IDEN:

-		assert((sym->flags & SCONSTANT) == 0);

-		if ((sym->flags & SDECLARED) == 0) {

-			if (namespace == NS_CPP) {

-				np = constnode(zero);

-				break;

-			}

-			sym = notdefined(sym);

-		}

-		sym->flags |= SUSED;

-		np = varnode(sym);

-		break;

-	default:

-		unexpected();

-	}

-	next();

-

-	return np;

-}

-

-static Node *

-arguments(Node *np)

-{

-	int toomany, n, op;

-	Node *par = NULL, *arg;

-	Type *argtype, **targs, *tp = np->type, *rettype;

-

-	if (tp->op == PTR && tp->type->op == FTN) {

-		np = content(OPTR, np);

-		tp = np->type;

-	}

-	if (tp->op != FTN) {

-		targs = (Type *[]) {ellipsistype};

-		n = 1;

-		rettype = inttype;

-		errorp("function or function pointer expected");

-	} else {

-		targs = tp->p.pars;

-		n = tp->n.elem;

-		rettype = tp->type;

-	}

-

-	expect('(');

-	if (yytoken == ')')

-		goto no_pars;

-	toomany = 0;

-

-	do {

-		arg = xassign();

-		argtype = *targs;

-		if (argtype == ellipsistype) {

-			n = 0;

-			switch (arg->type->op) {

-			case INT:

-				arg = promote(arg);

-				break;

-			case FLOAT:

-				if (arg->type == floattype)

-					arg = convert(arg, doubletype, 1);

-				break;

-			}

-			par = node(OPAR, arg->type, par, arg);

-			continue;

-		}

-		if (--n < 0) {

-			if (!toomany)

-				errorp("too many arguments in function call");

-			toomany = 1;

-			continue;

-		}

-		++targs;

-		if ((arg = convert(arg, argtype, 0)) != NULL) {

-			par = node(OPAR, arg->type, par, arg);

-			continue;

-		}

-		errorp("incompatible type for argument %d in function call",

-		       tp->n.elem - n + 1);

-	} while (accept(','));

-

-no_pars:

-	expect(')');

-	if (n > 0 && *targs != ellipsistype)

-		errorp("too few arguments in function call");

-

-	op = (tp->prop&TELLIPSIS) ? OCALLE : OCALL;

-	return node(op, rettype, np, par);

-}

-

-static Node *unary(int);

-

-static Type *

-typeof(Node *np)

-{

-	Type *tp;

-

-	if (np == NULL)

-		unexpected();

-	tp = np->type;

-	freetree(np);

-	return tp;

-}

-

-static Type *

-sizeexp(void)

-{

-	Type *tp;

-

-	expect('(');

-	switch (yytoken) {

-	case TYPE:

-	case TYPEIDEN:

-		tp = typename();

-		break;

-	default:

-		tp = typeof(unary(0));

-		break;

-	}

-	expect(')');

-	return tp;

-}

-

-static Node *

-postfix(Node *lp)

-{

-	Node *rp;

-

-	for (;;) {

-		switch (yytoken) {

-		case '[':

-		case DEC:

-		case INC:

-		case INDIR:

-		case '.':

-		case '(':

-			lp = decay(lp);

-			switch (yytoken) {

-			case '[':

-				next();

-				rp = xexpr();

-				expect(']');

-				lp = array(lp, rp);

-				break;

-			case DEC:

-			case INC:

-				lp = incdec(lp, (yytoken == INC) ? OINC : ODEC);

-				next();

-				break;

-			case INDIR:

-				lp = content(OPTR, lp);

-			case '.':

-				lp = field(lp);

-				break;

-			case '(':

-				lp = arguments(lp);

-				lp->flags |= NEFFECT;

-				break;

-			}

-			break;

-		default:

-			return lp;

-		}

-	}

-}

-

-static Node *

-defined(void)

-{

-	Symbol *sym;

-	int paren;

-

-	disexpand = 1;

-	next();

-	paren = accept('(');

-	if (yytoken != IDEN && yytoken != TYPEIDEN)

-		cpperror("operator 'defined' requires an identifier");

-	if (yytoken == TYPEIDEN || !(yylval.sym->flags & SDECLARED))

-		sym = zero;

-	else

-		sym = one;

-	disexpand = 0;

-	next();

-	if (paren)

-		expect(')');

-	return constnode(sym);

-}

-

-static Node *cast(int);

-

-static Node *

-unary(int needdecay)

-{

-	Node *(*fun)(int, Node *), *np;

-	int op;

-	Type *tp;

-

-	switch (yytoken) {

-	case '!': op = 0;     fun = negation;     break;

-	case '+': op = OADD;  fun = numericaluop; break;

-	case '-': op = OSNEG; fun = numericaluop; break;

-	case '~': op = OCPL;  fun = integeruop;   break;

-	case '&': op = OADDR; fun = address;      break;

-	case '*': op = OPTR;  fun = content;      break;

-	case SIZEOF:

-		next();

-		tp = (yytoken == '(') ? sizeexp() : typeof(unary(0));

-		if (!(tp->prop & TDEFINED))

-			errorp("sizeof applied to an incomplete type");

-		return sizeofnode(tp);

-	case INC:

-	case DEC:

-		op = (yytoken == INC) ? OA_ADD : OA_SUB;

-		next();

-		np = incdec(unary(1), op);

-		goto chk_decay;

-	case IDEN:

-	case TYPEIDEN:

-		if (lexmode == CPPMODE && !strcmp(yylval.sym->name, "defined"))

-			return defined();

-	default:

-		np = postfix(primary());

-		goto chk_decay;

-	}

-

-	next();

-	np = (*fun)(op, cast(op != OADDR));

-

-chk_decay:

-	if (needdecay)

-		np = decay(np);

-	return np;

-}

-

-static Node *

-cast(int needdecay)

-{

-	Node *lp, *rp;

-	Type *tp;

-	static int nested;

-

-	if (!accept('('))

-		return unary(needdecay);

-

-	switch (yytoken) {

-	case TQUALIFIER:

-	case TYPE:

-	case TYPEIDEN:

-		tp = typename();

-		expect(')');

-

-		if (yytoken == '{')

-			return initlist(tp);

-

-		switch (tp->op) {

-		case ARY:

-			error("cast specifies an array type");

-		default:

-			lp = cast(needdecay);

-			if ((rp = convert(lp,  tp, 1)) == NULL)

-				error("bad type conversion requested");

-			rp->flags &= ~NLVAL;

-			rp->flags |= lp->flags & NLVAL;

-		}

-		break;

-	default:

-		if (nested == NR_SUBEXPR)

-			error("too many expressions nested by parentheses");

-		++nested;

-		rp = xexpr();

-		--nested;

-		expect(')');

-		rp = postfix(rp);

-		break;

-	}

-

-	return rp;

-}

-

-static Node *

-mul(void)

-{

-	Node *np, *(*fun)(int, Node *, Node *);

-	int op;

-

-	np = cast(1);

-	for (;;) {

-		switch (yytoken) {

-		case '*': op = OMUL; fun = arithmetic; break;

-		case '/': op = ODIV; fun = arithmetic; break;

-		case '%': op = OMOD; fun = integerop;  break;

-		default: return np;

-		}

-		next();

-		np = (*fun)(op, np, cast(1));

-	}

-}

-

-static Node *

-add(void)

-{

-	int op;

-	Node *np;

-

-	np = mul();

-	for (;;) {

-		switch (yytoken) {

-		case '+': op = OADD; break;

-		case '-': op = OSUB; break;

-		default:  return np;

-		}

-		next();

-		np = arithmetic(op, np, mul());

-	}

-}

-

-static Node *

-shift(void)

-{

-	int op;

-	Node *np;

-

-	np = add();

-	for (;;) {

-		switch (yytoken) {

-		case SHL: op = OSHL; break;

-		case SHR: op = OSHR; break;

-		default:  return np;

-		}

-		next();

-		np = integerop(op, np, add());

-	}

-}

-

-static Node *

-relational(void)

-{

-	int op;

-	Node *np;

-

-	np = shift();

-	for (;;) {

-		switch (yytoken) {

-		case '<': op = OLT; break;

-		case '>': op = OGT; break;

-		case GE:  op = OGE; break;

-		case LE:  op = OLE; break;

-		default:  return np;

-		}

-		next();

-		np = compare(op, np, shift());

-	}

-}

-

-static Node *

-eq(void)

-{

-	int op;

-	Node *np;

-

-	np = relational();

-	for (;;) {

-		switch (yytoken) {

-		case EQ: op = OEQ; break;

-		case NE: op = ONE; break;

-		default: return np;

-		}

-		next();

-		np = compare(op, np, relational());

-	}

-}

-

-static Node *

-bit_and(void)

-{

-	Node *np;

-

-	np = eq();

-	while (accept('&'))

-		np = integerop(OBAND, np, eq());

-	return np;

-}

-

-static Node *

-bit_xor(void)

-{

-	Node *np;

-

-	np = bit_and();

-	while (accept('^'))

-		np = integerop(OBXOR,  np, bit_and());

-	return np;

-}

-

-static Node *

-bit_or(void)

-{

-	Node *np;

-

-	np = bit_xor();

-	while (accept('|'))

-		np = integerop(OBOR, np, bit_xor());

-	return np;

-}

-

-static Node *

-and(void)

-{

-	Node *np;

-

-	np = bit_or();

-	while (accept(AND))

-		np = logic(OAND, np, bit_or());

-	return np;

-}

-

-static Node *

-or(void)

-{

-	Node *np;

-

-	np = and();

-	while (accept(OR))

-		np = logic(OOR, np, and());

-	return np;

-}

-

-static Node *

-ternary(void)

-{

-	Node *cond;

-

-	cond = or();

-	while (accept('?')) {

-		Node *ifyes, *ifno, *np;

-

-		cond = exp2cond(cond, 0);

-		ifyes = xexpr();

-		expect(':');

-		ifno = ternary();

-		np = chkternary(ifyes, ifno);

-		cond = node(OASK, np->type, cond, np);

-	}

-	return cond;

-}

-

-static Node *

-xassign(void)

-{

-	Node *np, *(*fun)(int , Node *, Node *);

-	int op;

-

-	np = ternary();

-	for (;;) {

-		switch (yytoken) {

-		case '=':    op = OASSIGN; fun = assignop;   break;

-		case MUL_EQ: op = OA_MUL;  fun = arithmetic; break;

-		case DIV_EQ: op = OA_DIV;  fun = arithmetic; break;

-		case MOD_EQ: op = OA_MOD;  fun = integerop;  break;

-		case ADD_EQ: op = OA_ADD;  fun = arithmetic; break;

-		case SUB_EQ: op = OA_SUB;  fun = arithmetic; break;

-		case SHL_EQ: op = OA_SHL;  fun = integerop;  break;

-		case SHR_EQ: op = OA_SHR;  fun = integerop;  break;

-		case AND_EQ: op = OA_AND;  fun = integerop;  break;

-		case XOR_EQ: op = OA_XOR;  fun = integerop;  break;

-		case OR_EQ:  op = OA_OR;   fun = integerop;  break;

-		default: return np;

-		}

-		chklvalue(np);

-		np->flags |= NEFFECT;

-		next();

-		np = (fun)(op, np, assign());

-	}

-}

-

-static Node *

-xexpr(void)

-{

-	Node *lp, *rp;

-

-	lp = xassign();

-	while (accept(',')) {

-		rp = xassign();

-		lp = node(OCOMMA, rp->type, lp, rp);

-	}

-	return lp;

-}

-

-Node *

-assign(void)

-{

-	return simplify(xassign());

-}

-

-Node *

-constexpr(void)

-{

-	Node *np;

-

-	np = ternary();

-	if (np && np->type->op == INT) {

-		np = simplify(convert(np, inttype, 0));

-		if (np->flags & NCONST)

-			return np;

-	}

-	freetree(np);

-	return NULL;

-}

-

-Node *

-expr(void)

-{

-	return simplify(xexpr());

-}

-

-Node *

-condexpr(int neg)

-{

-	Node *np;

-

-	np = exp2cond(xexpr(), neg);

-	if (np->flags & NCONST)

-		warn("conditional expression is constant");

-	return simplify(np);

-}

--- a/src/cmd/cc1/fold.c

+++ /dev/null

@@ -1,685 +1,0 @@

-static char sccsid[] = "@(#) ./cc1/fold.c";

-#include <assert.h>

-#include <stdlib.h>

-

-#include <scc/scc.h>

-#include "cc1.h"

-

-

-TUINT

-ones(int nbytes)

-{

-	return (nbytes == 8) ? -1 : ~(-1ull << nbytes * 8);

-}

-

-static int

-addi(TINT l, TINT r, Type *tp)

-{

-	struct limits *lim = getlimits(tp);

-	TINT max = lim->max.i, min = -lim->min.i;

-

-	if (l < 0 && r < 0 && l >= min - r ||

-	    l == 0 ||

-	    r == 0 ||

-	    l < 0 && r > 0 ||

-	    l > 0 && r < 0 ||

-	    l > 0 && r > 0 && l <= max - r) {

-		return 1;

-	}

-	warn("overflow in constant expression");

-	return 0;

-}

-

-static int

-addf(TFLOAT l, TFLOAT r, Type *tp)

-{

-	struct limits *lim = getlimits(tp);

-	TFLOAT max = lim->max.f, min = lim->min.f;

-

-	if (l < 0 && r < 0 && l >= min - r ||

-	    l == 0 ||

-	    r == 0 ||

-	    l < 0 && r > 0 ||

-	    l > 0 && r < 0 ||

-	    l > 0 && r > 0 && l <= max - r) {

-		return 1;

-	}

-	warn("overflow in constant expression");

-	return 0;

-}

-

-static int

-subi(TINT l, TINT r, Type *tp)

-{

-	return addi(l, -r, tp);

-}

-

-static int

-subf(TFLOAT l, TFLOAT r, Type *tp)

-{

-	return addf(l, -r, tp);

-}

-

-static int

-muli(TINT l, TINT r, Type *tp)

-{

-	struct limits *lim = getlimits(tp);

-	TINT max = lim->max.i, min = -lim->min.i;

-

-	if (l > -1 && l <= 1 ||

-	    r > -1 && r <= 1 ||

-	    l < 0 && r < 0 && -l <= max/-r ||

-	    l < 0 && r > 0 &&  l >= min/r  ||

-	    l > 0 && r < 0 &&  r >= min/l  ||

-	    l > 0 && r > 0 &&  l <= max/r) {

-			return 1;

-	}

-	warn("overflow in constant expression");

-	return 0;

-}

-

-static int

-mulf(TFLOAT l, TFLOAT r, Type *tp)

-{

-	struct limits *lim = getlimits(tp);

-	TFLOAT max = lim->max.f, min = lim->min.f;

-

-	if (l > -1 && l <= 1 ||

-	    r > -1 && r <= 1 ||

-	    l < 0 && r < 0 && -l <= max/-r ||

-	    l < 0 && r > 0 &&  l >= min/r  ||

-	    l > 0 && r < 0 &&  r >= min/l  ||

-	    l > 0 && r > 0 &&  l <= max/r) {

-			return 1;

-	}

-	warn("overflow in constant expression");

-	return 0;

-}

-

-static int

-divi(TINT l, TINT r,  Type *tp)

-{

-	struct limits *lim = getlimits(tp);

-

-	if (r == 0 || l == -lim->min.i && r == -1) {

-		warn("overflow in constant expression");

-		return 0;

-	}

-	return 1;

-}

-

-static int

-divf(TFLOAT l, TFLOAT r,  Type *tp)

-{

-	struct limits *lim = getlimits(tp);

-

-	if (l < 0) l = -l;

-	if (r < 0) r = -r;

-

-	if (r == 0.0 || r < 1.0 && l > lim->max.f * r) {

-		warn("overflow in constant expression");

-		return 0;

-	}

-	return 1;

-}

-

-static int

-lshi(TINT l, TINT r, Type *tp)

-{

-	if (r < 0 || r >= tp->size * 8) {

-		warn("shifting %d bits is undefined", r);

-		return 0;

-	}

-	return muli(l, 1 << r, tp);

-}

-

-static int

-rshi(TINT l, TINT r, Type *tp)

-{

-	if (r < 0 || r >= tp->size * 8) {

-		warn("shifting %d bits is undefined", r);

-		return 0;

-	}

-	return 1;

-}

-

-static int

-foldint(int op, Symbol *res, TINT l, TINT r)

-{

-	TINT i;

-	Type *tp = res->type;

-	int (*validate)(TINT, TINT, Type *tp);

-

-	switch (op) {

-	case OADD: validate = addi; break;

-	case OSUB: validate = subi; break;

-	case OMUL: validate = muli; break;

-	case ODIV: validate = divi; break;

-	case OSHL: validate = lshi; break;

-	case OSHR: validate = rshi; break;

-	case OMOD: validate = divi; break;

-	default:   validate = NULL; break;

-	}

-

-	if (validate && !(*validate)(l, r, tp))

-		return 0;

-

-	switch (op) {

-	case OADD:  i = l + r;  break;

-	case OSUB:  i = l - r;  break;

-	case OMUL:  i = l * r;  break;

-	case ODIV:  i = l / r;  break;

-	case OMOD:  i = l % r;  break;

-	case OSHL:  i = l << r; break;

-	case OSHR:  i = l >> r; break;

-	case OBAND: i = l & r;  break;

-	case OBXOR: i = l ^ r;  break;

-	case OBOR:  i = l | r;  break;

-	case OAND:  i = l && r; break;

-	case OOR:   i = l || r; break;

-	case OLT:   i = l < r;  break;

-	case OGT:   i = l > r;  break;

-	case OGE:   i = l >= r; break;

-	case OLE:   i = l <= r; break;

-	case OEQ:   i = l == r; break;

-	case ONE:   i = l != r; break;

-	case ONEG:  i = !l;     break;

-	case OSNEG: i = -l;     break;

-	case OCPL:  i = ~l;     break;

-	default:    return 0;

-	}

-	res->u.i = i;

-

-	DBG("FOLD i l=%lld %d r=%lld = %lld", l, op, r, i);

-	return 1;

-}

-

-static int

-folduint(int op, Symbol *res, TUINT l, TUINT r)

-{

-	TINT i;

-	TUINT u;

-

-	switch (op) {

-	case OADD:  u = l + r;  break;

-	case OSUB:  u = l - r;  break;

-	case OMUL:  u = l * r;  break;

-	case ODIV:  u = l / r;  break;

-	case OMOD:  u = l % r;  break;

-	case OSHL:  u = l << r; break;

-	case OSHR:  u = l >> r; break;

-	case OBAND: u = l & r;  break;

-	case OBXOR: u = l ^ r;  break;

-	case OBOR:  u = l | r;  break;

-	case ONEG:  u = !l;     break;

-	case OSNEG: u = -l;     break;

-	case OCPL:  u = ~l;     break;

-	case OAND:  i = l && r; goto sign;

-	case OOR:   i = l || r; goto sign;

-	case OLT:   i = l < r;  goto sign;

-	case OGT:   i = l > r;  goto sign;

-	case OGE:   i = l >= r; goto sign;

-	case OLE:   i = l <= r; goto sign;

-	case OEQ:   i = l == r; goto sign;

-	case ONE:   i = l != r; goto sign;

-	default:    return 0;

-	}

-	res->u.u = u & ones(res->type->size);

-

-	DBG("FOLD ui l=%llu %d r=%llu = %llu", l, op, r, u);

-	return 1;

-

-sign:

-	res->u.i = i;

-

-	DBG("FOLD sui %llu %d %llu = %llu", l, op, r, i);

-	return 1;

-}

-

-static int

-foldfloat(int op, Symbol *res, TFLOAT l, TFLOAT r)

-{

-	TFLOAT f;

-	TINT i;

-	int (*validate)(TFLOAT, TFLOAT, Type *tp);

-

-	switch (op) {

-	case OADD: validate = addf; break;

-	case OSUB: validate = subf; break;

-	case OMUL: validate = mulf; break;

-	case ODIV: validate = divf; break;

-	default:   validate = NULL; break;

-	}

-

-	if (validate && !(*validate)(l, r, res->type))

-		return 0;

-

-	switch (op) {

-	case OADD: f = l + r;  break;

-	case OSUB: f = l - r;  break;

-	case OMUL: f = l * r;  break;

-	case ODIV: f = l / r;  break;

-	case OLT:  i = l < r;  goto comparison;

-	case OGT:  i = l > r;  goto comparison;

-	case OGE:  i = l >= r; goto comparison;

-	case OLE:  i = l <= r; goto comparison;

-	case OEQ:  i = l == r; goto comparison;

-	case ONE:  i = l != r; goto comparison;

-	default:   return 0;

-	}

-	res->u.f = f;

-

-	DBG("FOLD f l=%lf %d r=%lf = %lf", l, op, r, f);

-	return 1;

-

-comparison:

-	res->u.i = i;

-

-	DBG("FOLD if l=%lf %d r=%lf = %lld", l, op, r, i);

-	return 1;

-}

-

-static Node *

-foldconst(int type, int op, Type *tp, Symbol *ls, Symbol *rs)

-{

-	Symbol *sym, aux;

-	TINT i;

-	TUINT u;

-	TFLOAT f;

-

-	aux.type = tp;

-	switch (type) {

-	case INT:

-		i = (rs) ? rs->u.i : 0;

-		if (!foldint(op, &aux, ls->u.i, i))

-			return NULL;

-		break;

-	case UNSIGNED:

-		u = (rs) ? rs->u.u : 0u;

-		if (!folduint(op, &aux, ls->u.u, u))

-			return NULL;

-		break;

-	case FLOAT:

-		f = (rs) ? rs->u.f : 0.0;

-		if (!foldfloat(op, &aux, ls->u.f, f))

-			return NULL;

-		break;

-	}

-	sym = newsym(NS_IDEN, NULL);

-	sym->flags |= SCONSTANT;

-	sym->type = tp;

-	sym->u = aux.u;

-	return constnode(sym);

-}

-

-static Node *

-foldcast(Node *np, Node *l)

-{

-	TUINT negmask, mask, u;

-	Type *newtp = np->type, *oldtp = l->type;

-	Symbol aux, *sym, *osym = l->sym;

-

-	if (!(l->flags & NCONST))

-		return np;

-

-	switch (newtp->op) {

-	case PTR:

-	case INT:

-	case ENUM:

-		switch (oldtp->op) {

-		case PTR:

-		case INT:

-		case ENUM:

-			u = (oldtp->prop & TSIGNED) ? osym->u.i : osym->u.u;

-			break;

-		case FLOAT:

-			oldtp = newtp;

-			u = osym->u.f;

-			break;

-		default:

-			return  np;

-		}

-		mask = ones(newtp->size);

-		if (newtp->prop & TSIGNED) {

-			negmask = ~mask;

-			if (u & (negmask >> 1) & mask)

-				u |= negmask;

-			aux.u.i = u;

-		} else {

-			aux.u.u = u & mask;

-		}

-		break;

-	case FLOAT:

-		/* FIXME: The cast can be from another float type */

-		aux.u.f = (oldtp->prop & TSIGNED) ? osym->u.i : osym->u.u;

-		break;

-	default:

-		return np;

-	}

-	DBG("FOLD cast %c->%c", oldtp->letter, newtp->letter);

-	freetree(np);

-	sym = newsym(NS_IDEN, NULL);

-	sym->flags |= SCONSTANT;

-	sym->type = newtp;

-	sym->u = aux.u;

-	return constnode(sym);

-}

-

-static Node *

-foldunary(Node *np, Node *l)

-{

-	int op = l->op;

-	Node *aux;

-

-	switch (np->op) {

-	case ONEG:

-		if (l->op == ONEG)

-			break;

-		return NULL;

-	case OADD:

-		DBG("FOLD unary delete %d", np->op);

-		np->left = NULL;

-		freetree(np);

-		return l;

-	case OCAST:

-		if (op != OCAST)

-			return foldcast(np, l);

-		/* TODO: This is wrong: (float)(int) 7.2 */

-		DBG("FOLD unary collapse %d", np->op);

-		np->left = l->left;

-		l->left = NULL;

-		freetree(l);

-		return np;

-	case OSNEG:

-	case OCPL:

-		if (op != np->op)

-			return NULL;

-		break;

-	case OPTR:

-		if (op != OADDR || np->type != l->left->type)

-			return NULL;

-		break;

-	case OADDR:

-		if (op != OPTR)

-			return NULL;

-		break;

-	default:

-		return NULL;

-	}

-	DBG("FOLD unary cancel %d", np->op);

-	aux = l->left;

-	l->left = NULL;

-	freetree(np);

-	return aux;

-}

-

-static Node *

-fold(Node *np)

-{

-	Symbol *rs, *ls;

-	Type *optype;

-	int type;

-	int op = np->op;

-	Node *p, *lp = np->left, *rp = np->right;

-	Type *tp = np->type;

-

-	assert(lp && rp);

-	if ((op == ODIV || op == OMOD) && cmpnode(rp, 0)) {

-		warn("division by 0");

-		return NULL;

-	}

-	/*

-	 * Return if any of the children is no constant,

-	 * or it is a constant generated when

-	 * the address of a static variable is taken

-	 * (when we don't know the physical address so

-	 * we cannot fold it)

-	 */

-	if (!rp) {

-		rs = NULL;

-	} else {

-		if (!(rp->flags & NCONST) || !rp->sym)

-			return NULL;

-		rs = rp->sym;

-	}

-

-	if (!(lp->flags & NCONST) || !lp->sym)

-		return NULL;

-	optype = lp->type;

-	ls = lp->sym;

-

-	switch (type = optype->op) {

-	case ENUM:

-	case INT:

-		if (!(optype->prop & TSIGNED))

-			type = UNSIGNED;

-	case PTR:

-	case FLOAT:

-		if ((p = foldconst(type, op, tp, ls, rs)) == NULL)

-			return NULL;

-		freetree(np);

-		return p;

-	default:

-		return NULL;

-	}

-}

-

-static void

-commutative(Node *np, Node *l, Node *r)

-{

-	int op = np->op;

-

-	if (r == NULL || r->flags&NCONST || !(l->flags&NCONST))

-		return;

-

-	switch (op) {

-	case OLT:

-	case OGT:

-	case OGE:

-	case OLE:

-		DBG("FOLD neg commutative %d", np->op);

-		np->op = negop(op);

-	case OEQ:

-	case ONE:

-	case OADD:

-	case OMUL:

-	case OBAND:

-	case OBXOR:

-	case OBOR:

-		DBG("FOLD commutative %d", np->op);

-		np->left = r;

-		np->right = l;

-		break;

-	}

-}

-

-static Node *

-identity(Node *np)

-{

-	int iszeror, isoner;

-	int iszerol, isonel;

-	Node *lp = np->left, *rp = np->right;

-

-	if (!rp)

-		return NULL;

-

-	iszeror = cmpnode(rp, 0);

-	isoner = cmpnode(rp, 1),

-	iszerol = cmpnode(lp, 0);

-	isonel = cmpnode(lp, 1);

-

-	switch (np->op) {

-	case OOR:

-		/*

-		 * 1 || i => 1    (free right)

-		 * i || 0 => i    (free right)

-		 * 0 || i => i    (free left)

-		 * i || 1 => i,1  (comma)

-		 */

-		if (isonel | iszeror)

-			goto free_right;

-		if (iszerol)

-			goto free_left;

-		if (isoner)

-			goto change_to_comma;

-		return NULL;

-	case OAND:

-		/*

-		 * 0 && i => 0    (free right)

-		 * i && 1 => i    (free right)

-		 * 1 && i => i    (free left)

-		 * i && 0 => i,0  (comma)

-		 */

-		if (iszerol | isoner)

-			goto free_right;

-		if (isonel)

-			goto free_left;

-		if (iszeror)

-			goto change_to_comma;

-		return NULL;

-	case OSHL:

-	case OSHR:

-		/*

-		 * i >> 0 => i    (free right)

-		 * i << 0 => i    (free right)

-		 * 0 >> i => 0    (free right)

-		 * 0 << i => 0    (free right)

-		 */

-		if (iszeror | iszerol)

-			goto free_right;

-		return NULL;

-	case OBXOR:

-	case OADD:

-	case OBOR:

-	case OSUB:

-		/*

-		 * i + 0  => i

-		 * i - 0  => i

-		 * i | 0  => i

-		 * i ^ 0  => i

-		 */

-		if (iszeror)

-			goto free_right;

-		return NULL;

-	case OMUL:

-		/*

-		 * i * 0  => i,0

-		 * i * 1  => i

-		 */

-		if (iszeror)

-			goto change_to_comma;

-		if (isoner)

-			goto free_right;

-		return NULL;

-	case ODIV:

-		/* i / 1  => i */

-		if (isoner)

-			goto free_right;

-		return NULL;

-	case OBAND:

-		/* i & ~0 => i */

-		if (cmpnode(rp, -1))

-			goto free_right;

-		return NULL;

-	case OMOD:

-		/* i % 1  => i,1 */

-		/* TODO: i % 2^n => i & n-1 */

-		if (isoner)

-			goto change_to_comma;

-	default:

-		return NULL;

-	}

-

-free_right:

-	DBG("FOLD identity %d", np->op);

-	np->left = NULL;

-	freetree(np);

-	return lp;

-

-free_left:

-	DBG("FOLD identity %d", np->op);

-	np->right = NULL;

-	freetree(np);

-	return rp;

-

-change_to_comma:

-	DBG("FOLD identity %d", np->op);

-	np->op = OCOMMA;

-	return np;

-}

-

-static Node *

-foldternary(Node *np, Node *cond, Node *body)

-{

-	if (!(cond->flags & NCONST))

-		return np;

-	if (cmpnode(cond, 0)) {

-		np = body->right;

-		freetree(body->left);

-	} else {

-		np = body->left;

-		freetree(body->right);

-	}

-

-	DBG("FOLD ternary");

-	body->left = NULL;

-	body->right = NULL;

-	freetree(cond);

-	free(body);

-	return np;

-}

-

-/* TODO: fold OCOMMA */

-

-Node *

-simplify(Node *np)

-{

-	Node *p, *l, *r;

-

-	if (!np)

-		return NULL;

-	if (debug)

-		prtree(np);

-

-	l = np->left = simplify(np->left);

-	r = np->right = simplify(np->right);

-

-	switch (np->op) {

-	case OASK:

-		return foldternary(np, l, r);

-	case OCALL:

-	case OPAR:

-	case OSYM:

-	case OASSIGN:

-	case OA_MUL:

-	case OA_DIV:

-	case OA_MOD:

-	case OA_ADD:

-	case OA_SUB:

-	case OA_SHL:

-	case OA_SHR:

-	case OA_AND:

-	case OA_XOR:

-	case OA_OR:

-		return np;

-	case OSNEG:

-	case OCPL:

-	case OADDR:

-	case OPTR:

-	case INC:

-	case DEC:

-	case OCAST:

-	case ONEG:

-		assert(!r);

-		if ((p = foldunary(np, l)) != NULL)

-			return p;

-		return np;

-	default:

-		commutative(np, l, r);

-		if ((p = fold(np)) != NULL)

-			return p;

-		if ((p = identity(np)) != NULL)

-			return p;

-		return np;

-	}

-}

--- a/src/cmd/cc1/init.c

+++ /dev/null

@@ -1,378 +1,0 @@

-static char sccsid[] = "@(#) ./cc1/init.c";

-#include <stdint.h>

-#include <stdlib.h>

-#include <string.h>

-

-#include <scc/cstd.h>

-#include <scc/scc.h>

-#include "cc1.h"

-

-

-typedef struct init Init;

-

-struct designator {

-	TINT pos;

-	Node *expr;

-	struct designator *next;

-};

-

-struct init {

-	TUINT pos;

-	TUINT max;

-	struct designator *tail;

-	struct designator *head;

-};

-

-static TINT

-arydesig(Type *tp, Init *ip)

-{

-	TINT npos;

-	Node *np;

-

-	if (tp->op != ARY)

-		errorp("array index in non-array initializer");

-	next();

-	np = constexpr();

-	npos = np->sym->u.i;

-	if (npos < 0 || (tp->prop & TDEFINED) && npos >= tp->n.elem) {

-		errorp("array index in initializer exceeds array bounds");

-		npos = 0;

-	}

-	freetree(np);

-	expect(']');

-	return npos;

-}

-

-static TINT

-fielddesig(Type *tp, Init *ip)

-{

-	int ons;

-	Symbol *sym, **p;

-

-	if (!(tp->prop & TAGGREG))

-		errorp("field name not in record or union initializer");

-	ons = namespace;

-	namespace = tp->ns;

-	next();

-	namespace = ons;

-	if (yytoken != IDEN)

-		unexpected();

-	sym = yylval.sym;

-	next();

-	if ((sym->flags & SDECLARED) == 0) {

-		errorp("unknown field '%s' specified in initializer",

-		      sym->name);

-		return 0;

-	}

-	for (p = tp->p.fields; *p != sym; ++p)

-		;

-	return p - tp->p.fields;

-}

-

-static Init *

-init(Init *ip)

-{

-	ip->tail = ip->head = NULL;

-	ip->pos = ip->max = 0;

-	return ip;

-}

-

-static Node *

-str2ary(Type *tp)

-{

-	Node *np;

-	Type *btp = tp->type;;

-	Symbol *sym;

-	size_t len;

-	char *s;

-

-	np = assign();

-	sym = np->left->sym;

-	if (btp != chartype && btp != uchartype && btp != schartype) {

-		errorp("array of inappropriate type initialized from string constant");

-		return constnode(zero);

-	}

-

-	len = sym->type->n.elem-1;

-	if (!(tp->prop & TDEFINED)) {

-		tp->n.elem = len+1;

-		deftype(tp);

-	} else if (tp->n.elem < len) {

-		warn("initializer-string for array of chars is too long");

-	}

-

-	len = tp->n.elem;

-	s = sym->u.s;

-	sym = newstring(NULL, len);

-	strncpy(sym->u.s, s, len);

-	np->sym = sym;

-	np->type = sym->type;

-

-	return np;

-}

-

-static Node *

-initialize(Type *tp)

-{

-	Node *np;

-	Symbol *sym;

-

-	if (tp->op == ARY && yytoken == STRING)

-		return str2ary(tp);

-

-	if (yytoken == '{' || tp->op == STRUCT || tp->op == ARY)

-		return initlist(tp);

-

-	np = assign();

-	if (eqtype(tp, np->type, 1))

-		return np;

-

-	np = convert(decay(np), tp, 0);

-	if (!np) {

-		errorp("incorrect initializer");

-		return constnode(zero);

-	}

-

-	return simplify(np);

-}

-

-static Node *

-mkcompound(Init *ip, Type *tp)

-{

-	Node **v, **p;

-	size_t n;

-	struct designator *dp, *next;

-	Symbol *sym;

-

-	if (tp->op == UNION) {

-		Node *np = NULL;

-

-		v = xmalloc(sizeof(*v));

-		for (dp = ip->head; dp; dp = next) {

-			freetree(np);

-			np = dp->expr;

-			next = dp->next;

-			free(dp);

-		}

-		*v = np;

-	} else {

-		n = (tp->prop&TDEFINED) ? tp->n.elem : ip->max;

-		if (n == 0) {

-			v = NULL;

-		} else if (n > SIZE_MAX / sizeof(*v)) {

-			errorp("compound literal too big");

-			return constnode(zero);

-		} else {

-			n *= sizeof(*v);

-			v = memset(xmalloc(n), 0, n);

-

-			for (dp = ip->head; dp; dp = next) {

-				p = &v[dp->pos];

-				freetree(*p);

-				*p = dp->expr;

-				next = dp->next;

-				free(dp);

-			}

-		}

-	}

-

-	sym = newsym(NS_IDEN, NULL);

-	sym->u.init = v;

-	sym->type = tp;

-	sym->flags |= SINITLST;

-

-	return constnode(sym);

-}

-

-static void

-newdesig(Init *ip, Node *np)

-{

-	struct designator *dp;

-

-	dp = xmalloc(sizeof(*dp));

-	dp->pos = ip->pos;

-	dp->expr = np;

-	dp->next = NULL;

-

-	if (ip->head == NULL) {

-		ip->head = ip->tail = dp;

-	} else {

-		ip->tail->next = dp;

-		ip->tail = dp;

-	}

-

-	if (ip->pos+1 > ip->max)

-		ip->max = ip->pos+1;

-}

-

-Node *

-initlist(Type *tp)

-{

-	Init in;

-	Node *np;

-	Type *curtp;

-	int braces, scalar, toomany, outbound;

-	TINT nelem = tp->n.elem;

-	static int depth;

-

-	if (depth == NR_SUBTYPE)

-		error("too many nested initializers");

-	++depth;

-	init(&in);

-	braces = scalar = toomany = 0;

-

-	if (accept('{'))

-		braces = 1;

-

-	do {

-		curtp = inttype;

-		switch (yytoken) {

-		case '[':

-			in.pos = arydesig(tp, &in);

-			curtp = tp->type;

-			goto desig_list;

-		case '.':

-			in.pos = fielddesig(tp, &in);

-			if (in.pos < nelem)

-				curtp = tp->p.fields[in.pos]->type;

-		desig_list:

-			if (yytoken == '[' || yytoken == '.') {

-				np = initlist(curtp);

-				goto new_desig;

-			}

-			expect('=');

-		default:

-			outbound = 0;

-

-			switch (tp->op) {

-			case ARY:

-				curtp = tp->type;

-				if (!(tp->prop & TDEFINED) || in.pos < tp->n.elem)

-					break;

-				if (!toomany)

-					warn("excess elements in array initializer");

-				toomany = 1;

-				outbound = 1;

-				break;

-			case UNION:

-			case STRUCT:

-				if (in.pos < nelem) {

-					curtp = tp->p.fields[in.pos]->type;

-					break;

-				}

-				if (!toomany)

-					warn("excess elements in struct initializer");

-				toomany = 1;

-				outbound = 1;

-				break;

-			default:

-				curtp = tp;

-				if (!scalar)

-					warn("braces around scalar initializer");

-				scalar = 1;

-				if (in.pos == 0)

-					break;

-				if (!toomany)

-					warn("excess elements in scalar initializer");

-				toomany = 1;

-				outbound = 1;

-				break;

-			}

-			np = initialize(curtp);

-			if (outbound) {

-				freetree(np);

-				np = NULL;

-			}

-		}

-

-new_desig:

-		if (np)

-			newdesig(&in, np);

-		if (++in.pos == 0)

-			errorp("compound literal too big");

-		if (nelem == in.pos && !braces)

-			break;

-	} while (accept(','));

-

-	if (braces)

-		expect('}');

-

-

-	if (tp->op == ARY && !(tp->prop & TDEFINED)) {

-		tp->n.elem = in.max;

-		deftype(tp);

-	}

-	if (in.max == 0) {

-		errorp("empty braced initializer");

-		return constnode(zero);

-	}

-

-	return mkcompound(&in, tp);

-}

-

-static void

-autoinit(Symbol *sym, Node *np)

-{

-	Symbol *hidden;

-	Type *tp = sym->type;

-	size_t n; /* FIXME: It should be SIZET */

-

-repeat:

-	switch (tp->op) {

-	case UNION:

-		np = np->sym->u.init[0];

-		tp = np->type;

-		goto repeat;

-	case ARY:

-	case STRUCT:

-		if (!(np->flags & NCONST))

-			abort(); /* TODO */

-		hidden = newsym(NS_IDEN, NULL);

-		hidden->type = sym->type;

-		hidden->flags |= SLOCAL | SHASINIT;

-		emit(ODECL, hidden);

-		emit(OINIT, np);

-		emit(ODECL, sym);

-		emit(OEXPR,

-		     node(OASSIGN, tp, varnode(sym), varnode(hidden)));

-		break;

-	default:

-		emit(ODECL, sym);

-		np = node(OASSIGN, tp, varnode(sym), np);

-		emit(OEXPR, np);

-		break;

-	}

-}

-

-void

-initializer(Symbol *sym, Type *tp)

-{

-	Node *np;

-	int flags = sym->flags;

-

-	if (tp->op == FTN) {

-		errorp("function '%s' initialized like a variable",

-		       sym->name);

-		tp = inttype;

-	}

-	np = initialize(tp);

-

-	if (flags & SDEFINED) {

-		errorp("redeclaration of '%s'", sym->name);

-	} else if ((flags & (SGLOBAL|SLOCAL|SPRIVATE)) != 0) {

-		if (!(np->flags & NCONST)) {

-			errorp("initializer element is not constant");

-			return;

-		}

-		sym->flags |= SHASINIT;

-		sym->flags &= ~SEMITTED;

-		emit(ODECL, sym);

-		emit(OINIT, np);

-		sym->flags |= SDEFINED;

-	} else if ((flags & (SEXTERN|STYPEDEF)) != 0) {

-		errorp("'%s' has both '%s' and initializer",

-		       sym->name, (flags&SEXTERN) ? "extern" : "typedef");

-	} else {

-		autoinit(sym, np);

-	}

-}

--- a/src/cmd/cc1/ir.md

+++ /dev/null

@@ -1,443 +1,0 @@

-# scc intermediate representation #

-

-The scc IR tries to be be a simple and easily parseable intermediate

-representation, and it makes it a bit terse and cryptic. The main

-characteristic of the IR is that all the types and operations are

-represented with only one letter, so parsing tables can be used

-to parse it.

-

-The language is composed of lines, representing statements.

-Each statement is composed of tab-separated fields.

-Declaration statements begin in column 0, expressions and

-control flow begin with a tabulator.

-When the frontend detects an error, it closes the output stream.

-

-## Types ##

-

-Types are represented with uppercase letters:

-

-* C -- signed    8-Bit integer

-* I -- signed   16-Bit integer

-* W -- signed   32-Bit integer

-* Q -- signed   64-Bit integer

-* K -- unsigned  8-Bit integer

-* N -- unsigned 16-Bit integer

-* Z -- unsigned 32-Bit integer

-* O -- unsigned 64-Bit integer

-* 0 -- void

-* P -- pointer

-* F -- function

-* V -- vector

-* U -- union

-* S -- struct

-* B -- bool

-* J -- float

-* D -- double

-* H -- long double

-

-This list has been built for the original Z80 backend, where 'int'

-has the same size as 'short'. Several types (S, F, V, U and others) need

-an identifier after the type letter for better differentiation

-between multiple structs, functions, vectors and unions (S1, V12 ...)

-naturally occuring in a C-program.

-

-## Storage classes ##

-

-The storage classes are represented using uppercase letters:

-

-* A -- automatic

-* R -- register

-* G -- public (global variable declared in the module)

-* X -- extern (global variable declared in another module)

-* Y -- private (variable in file-scope)

-* T -- local (static variable in function-scope)

-* M -- member (struct/union member)

-* L -- label

-

-## Declarations/definitions ##

-

-Variable names are composed of a storage class and an identifier

-(e.g. A1, R2, T3).

-Declarations and definitions are composed of a variable

-name, a type and the name of the variable:

-

-	A1	I	maxweight

-	R2	C	flag

-	A3	S4	statstruct

-

-### Type declarations ###

-

-Some declarations (e.g. structs) involve the declaration of member

-variables.

-Struct members are declared normally after the type declaration in

-parentheses.

-

-For example the struct declaration

-

-	struct foo {

-		int i;

-		long c;

-	} var1;

-

-generates

-

-	S2      foo     (

-	M3      I       i

-	M4      W       c

-	)

-	G5      S2      var1

-

-## Functions ##

-

-A function prototype

-

-	int printf(char *cmd, int flag, void *data);

-

-will generate a type declaration and a variable declaration

-

-	F5	P	I	P

-	X1	F5	printf

-

-The first line gives the function-type specification 'F' with

-an identifier '5' and subsequently lists the types of the

-function parameters.

-The second line declares the 'printf' function as a publicly

-scoped variable.

-

-Analogously, a statically declared function in file scope

-

-	static int printf(char *cmd, int flag, void *data);

-

-generates

-

-	F5      P       I       P

-	T1      F5      printf

-

-Thus, the 'printf' variable  went into local scope ('T').

-

-A '{' in the first column starts the body of the previously

-declared function:

-

-	int printf(char *cmd, int flag, void *data) {}

-

-generates

-

-	F5      P       I       P

-	G1      F5      printf

-	{

-	A2      P       cmd

-	A3      I       flag

-	A4      P       data

-	-

-	}

-

-Again, the frontend must ensure that '{' appears only after the

-declaration of a function. The character '-' marks the separation

-between parameters and local variables:

-

-	int printf(register char *cmd, int flag, void *data) {int i;};

-

-generates

-

-	F5      P       I       P

-	G1      F5      printf

-	{

-	R2      P       cmd

-	A3      I       flag

-	A4      P       data

-	-

-	A6      I       i

-	}

-

-### Expressions ###

-

-Expressions are emitted in reverse polish notation, simplifying

-parsing and converting into a tree representation.

-

-#### Operators ####

-

-Operators allowed in expressions are:

-

-* \+ -- addition

-* \- -- substraction

-* \* -- multiplication

-* % -- modulo

-* / -- division

-* l -- left shift

-* r -- right shift

-* < -- less than

-* > -- greather than

-* ] -- greather or equal than

-* [ -- less or equal than

-* = -- equal than

-* ! -- different than

-* & -- bitwise and

-* | -- bitwise or

-* ^ -- bitwise xor

-* ~ -- bitwise complement

-* : -- asignation

-* _ -- unary negation

-* c -- function call

-* p -- parameter

-* . -- field

-* , -- comma operator

-* ? -- ternary operator

-* ' -- take address

-* a -- logical shortcut and

-* o -- logical shortcut or

-* @ -- content of pointer

-

-Assignation has some suboperators:

-

-* :/ -- divide and assign

-* :% -- modulo and assign

-* :+ -- addition and assign

-* :- -- substraction and assign

-* :l -- left shift and assign

-* :r -- right shift and assign

-* :& -- bitwise and and assign

-* :^ -- bitwise xor and assign

-* :| -- bitwise or and assign

-* :i -- post increment

-* :d -- post decrement

-

-Every operator in an expression has a type descriptor.

-

-#### Constants ####

-

-Constants are introduced with the character '#'. For instance, 10 is

-translated to #IA (all constants are emitted in hexadecimal),

-where I indicates that it is an integer constant.

-Strings are a special case because they are represented with

-the " character.

-The constant "hello" is emitted as "68656C6C6F. For example

-

-	int

-	main(void)

-	{

-		int i, j;

-

-		i = j+2*3;

-	}

-

-generates

-

-	F1

-	G1	F1	main

-	{

-	-

-	A2      I	i

-	A3      I	j

-		A2	A3	#I6	+I	:I

-	}

-

-Type casts are expressed with a tuple denoting the

-type conversion

-

-        int

-	main(void)

-	{

-		int i;

-		long j;

-

-		j = (long)i;

-	}

-

-generates

-

-	F1

-	G1      F1      main

-	{

-	-

-	A2      I       i

-	A3      W       j

-	        A2      A3      WI      :I

-	}

-

-### Statements ###

-#### Jumps #####

-

-Jumps have the following form:

-

-	j	L#	[expression]

-

-the optional expression field indicates some condition which

-must be satisfied to jump. Example:

-

-	int

-	main(void)

-	{

-		int i;

-

-		goto    label;

-	label:

-		i -= i;

-	}

-

-generates

-

-	F1

-	G1      F1      main

-	{

-	-

-	A2	I	i

-		j	L3

-	L3

-		A2	A2	:-I

-	}

-

-Another form of jump is the return statement, which uses the

-letter 'y' followed by a type identifier.

-Depending on the type, an optional expression follows.

-

-	int

-	main(void)

-	{

-		return 16;

-	}

-

-generates

-

-	F1

-	G1	F1	main

-	{

-	-

-		yI	#I10

-	}

-

-

-#### Loops ####

-

-There are two special characters that are used to indicate

-to the backend that the following statements are part of

-a loop body.

-

-* b -- beginning of loop

-* e -- end of loop

-

-#### Switch statement ####

-

-Switches are represented using a table, in which the labels

-where to jump for each case are indicated. Common cases are

-represented with 'v' and default with 'f'.

-The switch statement itself is represented with 's' followed

-by the label where the jump table is located, and the

-expression of the switch:

-

-	int

-	func(int n)

-	{

-		switch (n+1) {

-		case 1:

-		case 2:

-		case 3:

-		default:

-			++n;

-		}

-	}

-

-generates

-

-	F2	I

-	G1	F2	func

-	{

-	A1	I	n

-	-

-		s	L4	A1	#I1	+I

-	L5

-	L6

-	L7

-	L8

-		A1	#I1	:+I

-		j	L3

-	L4

-		t	#4

-		v	L7	#I3

-		v	L6	#I2

-		v	L5	#I1

-		f	L8

-	L3

-	}

-

-The beginning of the jump table is indicated by the the letter 't',

-followed by the number of cases (including default case) of the

-switch.

-

-## Resumen ##

-

-* C -- signed    8-Bit integer

-* I -- signed   16-Bit integer

-* W -- signed   32-Bit integer

-* O -- signed   64-Bit integer

-* M -- unsigned  8-Bit integer

-* N -- unsigned 16-Bit integer

-* Z -- unsigned 32-Bit integer

-* Q -- unsigned 64-Bit integer

-* 0 -- void

-* P -- pointer

-* F -- function

-* V -- vector

-* U -- union

-* S -- struct

-* B -- bool

-* J -- float

-* D -- double

-* H -- long double

-* A -- automatic

-* R -- register

-* G -- public (global variable declared in the module)

-* X -- extern (global variable declared in another module)

-* Y -- private (variable in file-scope)

-* T -- local (static variable in function-scope)

-* M -- member (struct/union member)

-* L -- label

-* { -- beginning of function body

-* } -- end of function body

-* \\ -- end of function parameters

-* \+ -- addition

-* \- -- substraction

-* \* -- multiplication

-* % -- modulo

-* / -- division

-* l -- left shift

-* r -- right shift

-* < -- less than

-* > -- greather than

-* ] -- greather or equal than

-* [ -- less or equal than

-* = -- equal than

-* ! -- different than

-* & -- bitwise and

-* | -- bitwise or

-* ^ -- bitwise xor

-* ~ -- bitwise complement

-* : -- asignation

-* _ -- unary negation

-* c -- function call

-* p -- parameter

-* . -- field

-* , -- comma operator

-* ? -- ternary operator

-* ' -- take address

-* a -- logical shortcut and

-* o -- logical shortcut or

-* @ -- content of pointer

-* :/ -- divide and assign

-* :% -- modulo and assign

-* :+ -- addition and assign

-* :- -- substraction and assign

-* :l -- left shift and assign

-* :r -- right shift and assign

-* :& -- bitwise and and assign

-* :^ -- bitwise xor and assign

-* :| -- bitwise or and assign

-* ;+ -- post increment

-* ;- -- post decrement

-* j -- jump

-* y -- return

-* b -- begin of loop

-* d -- end of loop

-* s -- switch statement

-* t -- switch table

-* v -- case entry in switch table

-* f -- default entry in switch table

--- a/src/cmd/cc1/lex.c

+++ /dev/null

@@ -1,801 +1,0 @@

-static char sccsid[] = "@(#) ./cc1/lex.c";

-#include <assert.h>

-#include <ctype.h>

-#include <errno.h>

-#include <limits.h>

-#include <setjmp.h>

-#include <stdio.h>

-#include <stdlib.h>

-#include <string.h>

-

-#include <scc/cstd.h>

-#include <scc/scc.h>

-#include "cc1.h"

-

-int yytoken;

-struct yystype yylval;

-char yytext[STRINGSIZ+3];

-unsigned short yylen;

-int lexmode = CCMODE;

-unsigned lineno;

-char filenam[FILENAME_MAX];

-

-int namespace = NS_IDEN;

-static int safe;

-Input *input;

-

-void

-ilex(void)

-{

-	static struct keyword keys[] = {

-		{"auto", SCLASS, AUTO},

-		{"break", BREAK, BREAK},

-		{"_Bool", TYPE, BOOL},

-		{"__builtin_va_list", TYPE, VA_LIST},

-		{"case", CASE, CASE},

-		{"char", TYPE, CHAR},

-		{"const", TQUALIFIER, CONST},

-		{"continue", CONTINUE, CONTINUE},

-		{"default", DEFAULT, DEFAULT},

-		{"do", DO, DO},

-		{"double", TYPE, DOUBLE},

-		{"else", ELSE, ELSE},

-		{"enum", TYPE, ENUM},

-		{"extern", SCLASS, EXTERN},

-		{"float", TYPE, FLOAT},

-		{"for", FOR, FOR},

-		{"goto", GOTO, GOTO},

-		{"if", IF, IF},

-		{"inline", TQUALIFIER, INLINE},

-		{"int", TYPE, INT},

-		{"long", TYPE, LONG},

-		{"register", SCLASS, REGISTER},

-		{"restrict", TQUALIFIER, RESTRICT},

-		{"return", RETURN, RETURN},

-		{"short", TYPE, SHORT},

-		{"signed", TYPE, SIGNED},

-		{"sizeof", SIZEOF, SIZEOF},

-		{"static", SCLASS, STATIC},

-		{"struct", TYPE, STRUCT},

-		{"switch", SWITCH, SWITCH},

-		{"typedef", SCLASS, TYPEDEF},

-		{"union", TYPE, UNION},

-		{"unsigned", TYPE, UNSIGNED},

-		{"void", TYPE, VOID},

-		{"volatile", TQUALIFIER, VOLATILE},

-		{"while", WHILE, WHILE},

-		{NULL, 0, 0},

-	};

-	keywords(keys, NS_KEYWORD);

-}

-

-void

-setloc(char *fname, unsigned line)

-{

-	size_t len;

-

-	if ((len = strlen(fname)) >= FILENAME_MAX)

-		die("cc1: %s: file name too long", fname);

-	memmove(filenam, fname, len);

-	filenam[len] = '\0';

-

-	free(input->filenam);

-	input->filenam = xstrdup(fname);

-	lineno = input->lineno = line;

-}

-

-void

-addinput(char *fname, Symbol *hide, char *buffer)

-{

-	FILE *fp;

-	char *extp;

-	unsigned flags;

-	int infileln;

-	Input *newip, *curip = input;

-

-	if (hide) {

-		/* this is a macro expansion */

-		fp = NULL;

-		if (hide->hide == UCHAR_MAX)

-			die("cc1: too many macro expansions");

-		++hide->hide;

-		flags = IMACRO;

-	} else  if (fname) {

-		/* a new file */

-		if ((fp = fopen(fname, "r")) == NULL)

-			die("cc1: %s: %s", fname, strerror(errno));

-		flags = IFILE;

-		if (curip && onlyheader) {

-			infileln = strlen(infile);

-			if (extp = strrchr(infile, '.'))

-				infileln -= strlen(extp);

-			printf("%.*s.o: %s %s\n",

-			       infileln, infile, infile, fname);

-		}

-	} else {

-		/* reading from stdin */

-		fp = stdin;

-		fname = "<stdin>";

-		flags = ISTDIN;

-	}

-

-	newip = xmalloc(sizeof(*newip));

-

-	if (!buffer) {

-		buffer = xmalloc(INPUTSIZ);

-		buffer[0] = '\0';

-	}

-

-	if (curip)

-		curip->lineno = lineno;

-

-	newip->p = newip->begin = newip->line = buffer;

-	newip->filenam = NULL;

-	newip->lineno = 0;

-	newip->next = curip;

-	newip->fp = fp;

-	newip->hide = hide;

-	newip->flags = flags;

-	input = newip;

-

-	setloc(fname, (curip) ? curip->lineno : newip->lineno);

-}

-

-void

-delinput(void)

-{

-	Input *ip = input;

-	Symbol *hide = ip->hide;

-

-	switch (ip->flags & ITYPE) {

-	case IFILE:

-		if (fclose(ip->fp))

-			die("cc1: %s: %s", ip->filenam, strerror(errno));

-		break;

-	case IMACRO:

-		assert(hide->hide == 1);

-		--hide->hide;

-		break;

-	}

-	input = ip->next;

-	free(ip->filenam);

-	free(ip->line);

-	if (input) {

-		lineno = input->lineno;

-		strcpy(filenam, input->filenam);

-	}

-}

-

-static void

-newline(void)

-{

-	if (++lineno == 0)

-		die("cc1: %s: file too long", filenam);

-}

-

-/*

- * Read the next character from the input file, counting number of lines

- * and joining lines escaped with \

- */

-static int

-readchar(void)

-{

-	FILE *fp = input->fp;

-	int c;

-

-repeat:

-	switch (c = getc(fp)) {

-	case '\\':

-		if ((c = getc(fp)) == '\n') {

-			newline();

-			goto repeat;

-		}

-		ungetc(c, fp);

-		c = '\\';

-		break;

-	case '\n':

-		newline();

-		break;

-	default:

-		if (!isprint(c) && !ispunct(c) && !isspace(c))

-			warn("invalid input character. The shame of UB is yours");

-		break;

-	}

-

-	return c;

-}

-

-/*

- * discard a C comment. This function is only called from readline

- * because it is impossible to have a comment in a macro, because

- * comments are always discarded before processing any cpp directive

- */

-static void

-comment(int type)

-{

-	int c;

-

-repeat:

-	while ((c = readchar()) != EOF && c != type)

-		;

-

-	if (c == EOF) {

-		errorp("unterminated comment");

-		return;

-	}

-

-	if (type == '*' && (c = readchar()) != '/')

-		goto repeat;

-}

-

-/*

- * readline is used to read a full logic line from a file.

- * It discards comments and check that the line fits in

- * the input buffer

- */

-static int

-readline(void)

-{

-	char *bp, *lim;

-	int c, peekc = 0;

-

-	if (feof(input->fp)) {

-		input->flags |= IEOF;

-		return 0;

-	}

-

-	*input->line = '\0';

-	lim = &input->line[INPUTSIZ-1];

-	for (bp = input->line; bp < lim-1; *bp++ = c) {

-		c = (peekc) ? peekc : readchar();

-		peekc = 0;

-		if (c == '\n' || c == EOF)

-			break;

-		if (c != '/')

-			continue;

-

-		/* check for /* or // */

-		peekc = readchar();

-		if (peekc != '*' && peekc != '/')

-			continue;

-		comment((peekc == '/') ? '\n' : '*');

-		peekc = 0;

-		c = ' ';

-	}

-

-	input->begin = input->p = input->line;

-	if (bp == lim-1) {

-		errorp("line too long");

-		--bp;

-	}

-	*bp++ = '\n';

-	*bp = '\0';

-

-	return 1;

-}

-

-/*

- * moreinput gets more bytes to be passed to the lexer.

- * It can take more bytes from macro expansions or

- * directly reading from files. When a cpp directive

- * is processed the line is discarded because it must not

- * be passed to the lexer

- */

-static int

-moreinput(void)

-{

-	int wasexpand = 0;

-

-repeat:

-	if (!input)

-		return 0;

-

-	if (*input->p == '\0') {

-		if ((input->flags&ITYPE) == IMACRO) {

-			wasexpand = 1;

-			input->flags |= IEOF;

-		}

-		if (input->flags & IEOF) {

-			delinput();

-			goto repeat;

-		}

-		if (!readline() || cpp()) {

-			*input->p = '\0';

-			goto repeat;

-		}

-	}

-

-	if (onlycpp && !wasexpand)

-		ppragmaln();

-	return 1;

-}

-

-static void

-tok2str(void)

-{

-	if ((yylen = input->p - input->begin) > INTIDENTSIZ)

-		error("token too big");

-	memcpy(yytext, input->begin, yylen);

-	yytext[yylen] = '\0';

-	input->begin = input->p;

-}

-

-static Symbol *

-readint(char *s, int base, int sign, Symbol *sym)

-{

-	Type *tp = sym->type;

-	struct limits *lim;

-	TUINT u, val, max;

-	int c;

-

-	lim = getlimits(tp);

-	max = lim->max.i;

-	if (*s == '0')

-		++s;

-	if (toupper(*s) == 'X')

-		++s;

-

-	for (u = 0; isxdigit(c = *s++); u = u*base + val) {

-		static char letters[] = "0123456789ABCDEF";

-		val = strchr(letters, toupper(c)) - letters;

-	repeat:

-		if (u <= max/base && u*base <= max - val)

-			continue;

-		if (tp->prop & TSIGNED) {

-			if (tp == inttype)

-				tp = (base==10) ? longtype : uinttype;

-			else if (tp == longtype)

-				tp = (base==10) ? llongtype : ulongtype;

-			else

-				goto overflow;

-		} else {

-			if (tp == uinttype)

-				tp = (sign==UNSIGNED) ? ulongtype : longtype;

-			else if (tp == ulongtype)

-				tp = (sign==UNSIGNED) ? ullongtype : llongtype;

-			else

-				goto overflow;

-		}

-		sym->type = tp;

-		lim = getlimits(tp);

-		max = lim->max.i;

-		goto repeat;

-	}

-

-	if (tp->prop & TSIGNED)

-		sym->u.i = u;

-	else

-		sym->u.u = u;

-

-	return sym;

-

-overflow:

-	errorp("overflow in integer constant");

-	return sym;

-}

-

-static int

-integer(char *s, int base)

-{

-	Type *tp;

-	Symbol *sym;

-	unsigned size, sign;

-

-	for (size = sign = 0; ; ++input->p) {

-		switch (toupper(*input->p)) {

-		case 'L':

-			if (size == LLONG)

-				goto wrong_type;

-			size = (size == LONG) ? LLONG : LONG;

-			continue;

-		case 'U':

-			if (sign == UNSIGNED)

-				goto wrong_type;

-			sign = UNSIGNED;

-			continue;

-		default:

-			goto convert;

-		wrong_type:

-			error("invalid suffix in integer constant");

-		}

-	}

-

-convert:

-	tp = ctype(INT, sign, size);

-	sym = newsym(NS_IDEN, NULL);

-	sym->type = tp;

-	sym->flags |= SCONSTANT;

-	yylval.sym = readint(s, base, sign, sym);

-	return CONSTANT;

-}

-

-static char *

-digits(int base)

-{

-	char *p;

-	int c;

-

-	for (p = input->p; c = *p; ++p) {

-		switch (base) {

-		case 8:

-			if (!strchr("01234567", c))

-				goto end;

-			break;

-		case 10:

-			if (!isdigit(c))

-				goto end;

-			break;

-		case 16:

-			if (!isxdigit(c))

-				goto end;

-			break;

-		}

-	}

-end:

-	input->p = p;

-	tok2str();

-	return yytext;

-}

-

-static int

-number(void)

-{

-	int base;

-

-	if (*input->p != '0') {

-		base = 10;

-	} else {

-		if (toupper(*++input->p) == 'X') {

-			++input->p;

-			base = 16;

-		} else {

-			base = 8;

-		}

-	}

-

-	return integer(digits(base), base);

-}

-

-static int

-escape(void)

-{

-	int c, base;

-

-	switch (*++input->p) {

-	case 'a':  return '\a';

-	case 'f':  return '\f';

-	case 'n':  return '\n';

-	case 'r':  return '\r';

-	case 't':  return '\t';

-	case 'v':  return '\v';

-	case '"':  return '"';

-	case '\'': return '\'';

-	case '\\': return '\\';

-	case '\?': return '\?';

-	case 'u':

-		/*

-		 * FIXME: universal constants are not correctly handled

-		 */

-		if (!isdigit(*++input->p))

-			warn("incorrect digit for numerical character constant");

-		base = 10;

-		break;

-	case 'x':

-		if (!isxdigit(*++input->p))

-			warn("\\x used with no following hex digits");

-		base = 16;

-		break;

-	case '0':

-		if (!strchr("01234567", *++input->p))

-			warn("\\0 used with no following octal digits");

-		base = 8;

-		break;

-	default:

-		warn("unknown escape sequence");

-		return ' ';

-	}

-	errno = 0;

-	c = strtoul(input->p, &input->p, base);

-	if (errno || c > 255)

-		warn("character constant out of range");

-	--input->p;

-	return c;

-}

-

-static int

-character(void)

-{

-	int c;

-	Symbol *sym;

-

-	if ((c = *++input->p) == '\\')

-		c = escape();

-	else

-		c = *input->p;

-	++input->p;

-	if (*input->p != '\'')

-		errorp("invalid character constant");

-	else

-		++input->p;

-

-	sym = newsym(NS_IDEN, NULL);

-	sym->u.i = c;

-	sym->type = inttype;

-	yylval.sym = sym;

-	tok2str();

-	return CONSTANT;

-}

-

-static int

-string(void)

-{

-	char *bp = yytext;

-	int c;

-

-	*bp++ = '"';

-	for (++input->p; (c = *input->p) != '"'; ++input->p) {

-		if (c == '\0') {

-			errorp("missing terminating '\"' character");

-			break;

-		}

-		if (c == '\\')

-			c = escape();

-		if (bp == &yytext[STRINGSIZ+1]) {

-			/* TODO: proper error handling here */

-			error("string too long");

-		}

-		*bp++ = c;

-	}

-

-	input->begin = ++input->p;

-	*bp = '\0';

-

-	yylen = bp - yytext + 1;

-	yylval.sym = newstring(yytext+1, yylen-1);

-	*bp++ = '"';

-	*bp = '\0';

-	return STRING;

-}

-

-static int

-iden(void)

-{

-	Symbol *sym;

-	char *p, *begin;

-

-	begin = input->p;

-	for (p = begin; isalnum(*p) || *p == '_'; ++p)

-		;

-	input->p = p;

-	tok2str();

-	if ((sym = lookup(NS_CPP, yytext, NOALLOC)) != NULL) {

-		if (!disexpand && !sym->hide && expand(begin, sym))

-			return next();

-	}

-	sym = lookup(namespace, yytext, ALLOC);

-	yylval.sym = sym;

-	if (sym->flags & SCONSTANT)

-		return CONSTANT;

-	if (sym->token != IDEN)

-		yylval.token = sym->u.token;

-	return sym->token;

-}

-

-static int

-follow(int expect, int ifyes, int ifno)

-{

-	if (*input->p++ == expect)

-		return ifyes;

-	--input->p;

-	return ifno;

-}

-

-static int

-minus(void)

-{

-	switch (*input->p++) {

-	case '-': return DEC;

-	case '>': return INDIR;

-	case '=': return SUB_EQ;

-	default: --input->p; return '-';

-	}

-}

-

-static int

-plus(void)

-{

-	switch (*input->p++) {

-	case '+': return INC;

-	case '=': return ADD_EQ;

-	default: --input->p; return '+';

-	}

-}

-

-static int

-relational(int op, int equal, int shift, int assig)

-{

-	int c;

-

-	if ((c = *input->p++) == '=')

-		return equal;

-	if (c == op)

-		return follow('=', assig, shift);

-	--input->p;

-	return op;

-}

-

-static int

-logic(int op, int equal, int logic)

-{

-	int c;

-

-	if ((c = *input->p++) == '=')

-		return equal;

-	if (c == op)

-		return logic;

-	--input->p;

-	return op;

-}

-

-static int

-dot(void)

-{

-	int c;

-

-	if ((c = *input->p) != '.')

-		return '.';

-	if ((c = *++input->p) != '.')

-		error("incorrect token '..'");

-	++input->p;

-	return ELLIPSIS;

-}

-

-static int

-operator(void)

-{

-	int t;

-

-	switch (t = *input->p++) {

-	case '<': t = relational('<', LE, SHL, SHL_EQ); break;

-	case '>': t = relational('>', GE, SHR, SHR_EQ); break;

-	case '&': t = logic('&', AND_EQ, AND); break;

-	case '|': t = logic('|', OR_EQ, OR); break;

-	case '=': t = follow('=', EQ, '='); break;

-	case '^': t = follow('=', XOR_EQ, '^'); break;

-	case '*': t = follow('=', MUL_EQ, '*'); break;

-	case '/': t = follow('=', DIV_EQ, '/'); break;

-	case '!': t = follow('=', NE, '!'); break;

-	case '#': t = follow('#', '$', '#'); break;

-	case '-': t = minus(); break;

-	case '+': t = plus(); break;

-	case '.': t = dot(); break;

-	}

-	tok2str();

-	return t;

-}

-

-/* TODO: Ensure that namespace is NS_IDEN after a recovery */

-

-/*

- * skip all the spaces until the next token. When we are in

- * CPPMODE \n is not considered a whitespace

- */

-static int

-skipspaces(void)

-{

-	int c;

-

-	for (;;) {

-		switch (c = *input->p) {

-		case '\n':

-			if (lexmode == CPPMODE)

-				goto return_byte;

-			++input->p;

-		case '\0':

-			if (!moreinput())

-				return EOF;

-			break;

-		case ' ':

-		case '\t':

-		case '\v':

-		case '\r':

-		case '\f':

-			++input->p;

-			break;

-		default:

-			goto return_byte;

-		}

-	}

-

-return_byte:

-	input->begin = input->p;

-	return c;

-}

-

-int

-next(void)

-{

-	int c;

-

-	if ((c = skipspaces()) == EOF)

-		yytoken = EOFTOK;

-	else if (isalpha(c) || c == '_')

-		yytoken = iden();

-	else if (isdigit(c))

-		yytoken = number();

-	else if (c == '"')

-		yytoken = string();

-	else if (c == '\'')

-		yytoken = character();

-	else

-		yytoken = operator();

-

-	if (yytoken == EOF) {

-		strcpy(yytext, "<EOF>");

-		if (cppctx)

-			errorp("#endif expected");

-	}

-

-	DBG("TOKEN %s", yytext);

-	return yytoken;

-}

-

-void

-expect(int tok)

-{

-	if (yytoken != tok) {

-		if (isgraph(tok))

-			errorp("expected '%c' before '%s'", tok, yytext);

-		else

-			errorp("unexpected '%s'", yytext);

-	} else {

-		next();

-	}

-}

-

-int

-ahead(void)

-{

-	skipspaces();

-	return *input->begin;

-}

-

-void

-setsafe(int type)

-{

-	safe = type;

-}

-

-void

-discard(void)

-{

-	extern jmp_buf recover;

-	int c;

-

-	input->begin = input->p;

-	for (c = yytoken; ; c = *input->begin++) {

-		switch (safe) {

-		case END_COMP:

-			if (c == '}')

-				goto jump;

-			goto semicolon;

-		case END_COND:

-			if (c == ')')

-				goto jump;

-			break;

-		case END_LDECL:

-			if (c == ',')

-				goto jump;

-		case END_DECL:

-		semicolon:

-			if (c == ';')

-				goto jump;

-			break;

-		}

-		if (c == '\0' && !moreinput())

-			exit(1);

-	}

-jump:

-	yytoken = c;

-	longjmp(recover, 1);

-}

--- a/src/cmd/cc1/main.c

+++ /dev/null

@@ -1,102 +1,0 @@

-static char sccsid[] = "@(#) ./cc1/main.c";

-#include <setjmp.h>

-#include <stdio.h>

-#include <stdlib.h>

-#include <string.h>

-#include <errno.h>

-

-#include <scc/arg.h>

-#include <scc/scc.h>

-#include "cc1.h"

-

-char *argv0, *infile;

-

-int warnings;

-jmp_buf recover;

-

-static struct items uflags;

-int onlycpp, onlyheader;

-

-

-extern int failure;

-

-static void

-defmacro(char *macro)

-{

-	char *p = strchr(macro, '=');

-

-	if (p)

-		*p++ = '\0';

-	else

-		p = "1";

-

-	defdefine(macro, p, "command-line");

-}

-

-static void

-usage(void)

-{

-	fputs("usage: cc1 [-Ewd] [-D def[=val]]... [-U def]... "

-	      "[-I dir]... [-o output] [input]\n", stderr);

-	exit(1);

-}

-

-int

-main(int argc, char *argv[])

-{

-	int i;

-

-	ilex();

-	icpp();

-	icode();

-	ibuilts();

-

-	ARGBEGIN {

-	case 'D':

-		defmacro(EARGF(usage()));

-		break;

-	case 'M':

-		onlyheader = 1;

-		break;

-	case 'E':

-		onlycpp = 1;

-		break;

-	case 'I':

-		incdir(EARGF(usage()));

-		break;

-	case 'U':

-		newitem(&uflags, EARGF(usage()));

-		break;

-	case 'd':

-		DBGON();

-		break;

-	case 'w':

-		warnings = 1;

-		break;

-	default:

-		usage();

-	} ARGEND

-

-	if (argc > 1)

-		usage();

-

-	for (i = 0; i < uflags.n; ++i)

-		undefmacro(uflags.s[i]);

-

-	infile = (*argv) ? *argv : "<stdin>";

-	addinput(*argv, NULL, NULL);

-

-	/*

-	 * we cannot initialize arch until we have an

-	 * output stream, because we maybe want to emit new types

-	 */

-	iarch();

-	if (onlycpp || onlyheader) {

-		outcpp();

-	} else {

-		for (next(); yytoken != EOFTOK; decl())

-			;

-	}

-

-	return failure;

-}

--- a/src/cmd/cc1/stmt.c

+++ /dev/null

@@ -1,386 +1,0 @@

-static char sccsid[] = "@(#) ./cc1/stmt.c";

-#include <stddef.h>

-#include <setjmp.h>

-

-#include <scc/cstd.h>

-#include <scc/scc.h>

-#include "cc1.h"

-

-#define NEGATE   1

-#define NONEGATE 0

-

-Symbol *curfun;

-

-static void stmt(Symbol *lbreak, Symbol *lcont, Switch *lswitch);

-

-static void

-label(void)

-{

-	Symbol *sym;

-

-	switch (yytoken) {

-	case IDEN:

-	case TYPEIDEN:

-		sym = lookup(NS_LABEL, yytext, ALLOC);

-		if (sym->flags & SDEFINED)

-			error("label '%s' already defined", yytext);

-		if ((sym->flags & SDECLARED) == 0)

-			sym = install(NS_LABEL, sym);

-		sym->flags |= SDEFINED;

-		emit(OLABEL, sym);

-		next();

-		expect(':');

-		break;

-	default:

-		unexpected();

-	}

-}

-

-static void

-stmtexp(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

-{

-	Node *np;

-

-	if (accept(';'))

-		return;

-	if (yytoken == IDEN && ahead() == ':') {

-		label();

-		stmt(lbreak, lcont, lswitch);

-		return;

-	}

-	np = expr();

-	if ((np->flags & NEFFECT) == 0)

-		warn("expression without side effects");

-	emit(OEXPR, np);

-	expect(';');

-}

-

-static Node *

-condition(int neg)

-{

-	Node *np;

-

-	expect('(');

-	np = condexpr(neg);

-	expect(')');

-

-	return np;

-}

-

-static void

-While(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

-{

-	Symbol *begin;

-	Node *np;

-

-	begin = newlabel();

-	lcont = newlabel();

-	lbreak = newlabel();

-

-	expect(WHILE);

-	np = condition(NONEGATE);

-

-	emit(OJUMP, lcont);

-

-	emit(OBLOOP, NULL);

-	emit(OLABEL, begin);

-	stmt(lbreak, lcont, lswitch);

-	emit(OLABEL, lcont);

-	emit(OBRANCH, begin);

-	emit(OEXPR, np);

-	emit(OELOOP, NULL);

-

-	emit(OLABEL, lbreak);

-}

-

-static void

-For(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

-{

-	Symbol *begin, *cond;

-	Node *econd, *einc;

-

-	begin = newlabel();

-	lcont = newlabel();

-	cond = newlabel();

-	lbreak = newlabel();

-

-	pushctx();

-

-	expect(FOR);

-	expect('(');

-	switch (yytoken) {

-	case TYPE:

-	case TYPEIDEN:

-	case TQUALIFIER:

-	case SCLASS:

-		decl();

-		break;

-	default:

-		emit(OEXPR, expr());

-	case ';':

-		expect(';');

-		break;

-	}

-	econd = (yytoken != ';') ? condexpr(NONEGATE) : NULL;

-	expect(';');

-	einc = (yytoken != ')') ? expr() : NULL;

-	expect(')');

-

-	emit(OJUMP, cond);

-

-	emit(OBLOOP, NULL);

-	emit(OLABEL, begin);

-	stmt(lbreak, lcont, lswitch);

-	emit(OLABEL, lcont);

-	emit(OEXPR, einc);

-	emit(OLABEL, cond);

-	emit((econd) ? OBRANCH : OJUMP, begin);

-	emit(OEXPR, econd);

-	emit(OELOOP, NULL);

-

-	emit(OLABEL, lbreak);

-

-	popctx();

-}

-

-static void

-Dowhile(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

-{

-	Symbol *begin;

-	Node *np;

-

-	begin = newlabel();

-	lcont = newlabel();

-	lbreak = newlabel();

-

-	expect(DO);

-

-	emit(OBLOOP, NULL);

-	emit(OLABEL, begin);

-	stmt(lbreak, lcont, lswitch);

-	expect(WHILE);

-	np = condition(NONEGATE);

-	emit(OLABEL, lcont);

-	emit(OBRANCH, begin);

-	emit(OEXPR, np);

-	emit(OELOOP, NULL);

-

-	emit(OLABEL, lbreak);

-}

-

-static void

-Return(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

-{

-	Node *np;

-	Type *tp = curfun->type->type;

-

-	expect(RETURN);

-	np = (yytoken != ';') ? decay(expr()) : NULL;

-	expect(';');

-	if (!np) {

-		if (tp != voidtype)

-			warn("function returning non void returns no value");

-		tp = voidtype;

-	} else if (np->type != tp) {

-		if (tp == voidtype)

-			warn("function returning void returns a value");

-		else if ((np = convert(np, tp, 0)) == NULL)

-			errorp("incorrect type in return");

-	}

-	emit(ORET, NULL);

-	emit(OEXPR, np);

-}

-

-static void

-Break(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

-{

-	expect(BREAK);

-	if (!lbreak) {

-		errorp("break statement not within loop or switch");

-	} else {

-		emit(OJUMP, lbreak);

-		expect(';');

-	}

-}

-

-static void

-Continue(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

-{

-	expect(CONTINUE);

-	if (!lcont) {

-		errorp("continue statement not within loop");

-	} else {

-		emit(OJUMP, lcont);

-		expect(';');

-	}

-}

-

-static void

-Goto(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

-{

-	Symbol *sym;

-

-	namespace = NS_LABEL;

-	next();

-	namespace = NS_IDEN;

-

-	if (yytoken != IDEN)

-		unexpected();

-	sym = yylval.sym;

-	if ((sym->flags & SDECLARED) == 0)

-		sym = install(NS_LABEL, sym);

-	sym->flags |= SUSED;

-	emit(OJUMP, sym);

-	next();

-	expect(';');

-}

-

-static void

-Swtch(Symbol *obr, Symbol *lcont, Switch *osw)

-{

-	Switch sw = {0};

-	Node *cond;

-	Symbol *lbreak;

-

-	expect(SWITCH);

-

-	expect ('(');

-	if ((cond = convert(expr(), inttype, 0)) == NULL) {

-		errorp("incorrect type in switch statement");

-		cond = constnode(zero);

-	}

-	expect (')');

-

-	lbreak = newlabel();

-	emit(OBSWITCH, NULL);

-	emit(OEXPR, cond);

-	stmt(lbreak, lcont, &sw);

-	emit(OESWITCH, lbreak);

-	emit(OLABEL, lbreak);

-}

-

-static void

-Case(Symbol *lbreak, Symbol *lcont, Switch *sw)

-{

-	Node *np;

-	Symbol *label;

-

-	expect(CASE);

-	if ((np = constexpr()) == NULL)

-		errorp("case label does not reduce to an integer constant");

-	if (!sw) {

-		errorp("case label not within a switch statement");

-	} else if (sw->nr >= 0 && ++sw->nr == NR_SWITCH) {

-		errorp("too many case labels for a switch statement");

-		sw->nr = -1;

-	}

-	expect(':');

-

-	label = newlabel();

-	emit(OCASE, label);

-	emit(OEXPR, np);

-	emit(OLABEL, label);

-	stmt(lbreak, lcont, sw);

-}

-

-static void

-Default(Symbol *lbreak, Symbol *lcont, Switch *sw)

-{

-	Symbol *label = newlabel();

-

-	if (sw->hasdef)

-		errorp("multiple default labels in one switch");

-	sw->hasdef = 1;

-	expect(DEFAULT);

-	expect(':');

-	emit(ODEFAULT, label);

-	emit(OLABEL, label);

-	stmt(lbreak, lcont, sw);

-}

-

-static void

-If(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

-{

-	Symbol *end, *lelse;

-	Node *np;

-

-	lelse = newlabel();

-	expect(IF);

-	np = condition(NEGATE);

-	emit(OBRANCH, lelse);

-	emit(OEXPR, np);

-	stmt(lbreak, lcont, lswitch);

-	if (accept(ELSE)) {

-		end = newlabel();

-		emit(OJUMP, end);

-		emit(OLABEL, lelse);

-		stmt(lbreak, lcont, lswitch);

-		emit(OLABEL, end);

-	} else {

-		emit(OLABEL, lelse);

-	}

-}

-

-static void

-blockit(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

-{

-	switch (yytoken) {

-	case TYPEIDEN:

-		if (ahead() == ':')

-			goto parse_stmt;

-	case TYPE:

-	case TQUALIFIER:

-	case SCLASS:

-		decl();

-		return;

-	default:

-	parse_stmt:

-		stmt(lbreak, lcont, lswitch);

-	}

-}

-

-void

-compound(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

-{

-	static int nested;

-

-	pushctx();

-	expect('{');

-

-	if (nested == NR_BLOCK)

-		error("too many nesting levels of compound statements");

-

-	++nested;

-	for (;;) {

-		if (yytoken == '}')

-			break;

-		blockit(lbreak, lcont, lswitch);

-	}

-	--nested;

-

-	popctx();

-	expect('}');

-}

-

-static void

-stmt(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

-{

-	void (*fun)(Symbol *, Symbol *, Switch *);

-

-	switch (yytoken) {

-	case '{':      fun = compound; break;

-	case RETURN:   fun = Return;   break;

-	case WHILE:    fun = While;    break;

-	case FOR:      fun = For;      break;

-	case DO:       fun = Dowhile;  break;

-	case IF:       fun = If;       break;

-	case BREAK:    fun = Break;    break;

-	case CONTINUE: fun = Continue; break;

-	case GOTO:     fun = Goto;     break;

-	case SWITCH:   fun = Swtch;    break;

-	case CASE:     fun = Case;     break;

-	case DEFAULT:  fun = Default;  break;

-	default:       fun = stmtexp;  break;

-	}

-	(*fun)(lbreak, lcont, lswitch);

-}

--- a/src/cmd/cc1/symbol.c

+++ /dev/null

@@ -1,353 +1,0 @@

-static char sccsid[] = "@(#) ./cc1/symbol.c";

-#include <assert.h>

-#include <limits.h>

-#include <stdio.h>

-#include <stdlib.h>

-#include <string.h>

-

-#include <scc/cstd.h>

-#include <scc/scc.h>

-#include "cc1.h"

-

-#define NR_SYM_HASH 64

-#define NR_CPP_HASH 32

-#define NR_LBL_HASH 16

-

-unsigned curctx;

-static unsigned short counterid;

-

-static Symbol *head, *labels;

-static Symbol *htab[NR_SYM_HASH];

-static Symbol *htabcpp[NR_CPP_HASH];

-static Symbol *htablbl[NR_LBL_HASH];

-

-#ifndef NDEBUG

-void

-dumpstab(Symbol **tbl, char *msg)

-{

-	Symbol **bp, *sym;

-	unsigned size;

-

-	fprintf(stderr, "Symbol Table dump at ctx=%u\n%s\n", curctx, msg);

-	if (tbl == htab)

-		size = NR_SYM_HASH;

-	else if (tbl == htabcpp)

-		size = NR_CPP_HASH;

-	else if (tbl == htablbl)

-		size = NR_LBL_HASH;

-	else

-		abort();

-

-	for (bp = tbl; bp < &tbl[size]; ++bp) {

-		if (*bp == NULL)

-			continue;

-		fprintf(stderr, "%d", (int) (bp - htab));

-		for (sym = *bp; sym; sym = sym->hash)

-			fprintf(stderr, "->[%d,%d:'%s'=%p]",

-			        sym->ns, sym->ctx, sym->name, (void *) sym);

-		putc('\n', stderr);

-	}

-	fputs("head:", stderr);

-	for (sym = head; sym; sym = sym->next) {

-		fprintf(stderr, "->[%d,%d:'%s'=%p]",

-		        sym->ns, sym->ctx,

-		        (sym->name) ? sym->name : "", (void *) sym);

-	}

-	fputs("\nlabels:", stderr);

-	for (sym = labels; sym; sym = sym->next) {

-		fprintf(stderr, "->[%d,%d:'%s'=%p]",

-		        sym->ns, sym->ctx,

-		        (sym->name) ? sym->name : "", (void *) sym);

-	}

-	putc('\n', stderr);

-}

-#endif

-

-static Symbol **

-hash(char *s, int ns)

-{

-	unsigned c, h, size;

-	Symbol **tab;

-

-	for (h = 0; c = *s; ++s)

-		h = h*33 ^ c;

-

-	switch (ns) {

-	case NS_CPP:

-		tab = htabcpp;

-		size = NR_CPP_HASH-1;

-		break;

-	case NS_LABEL:

-		tab = htablbl;

-		size = NR_LBL_HASH-1;

-		break;

-	default:

-		tab = htab;

-		size = NR_SYM_HASH-1;

-		break;

-	}

-	return &tab[h & size];

-}

-

-static void

-unlinkhash(Symbol *sym)

-{

-	Symbol **h;

-

-	if ((sym->flags & SDECLARED) == 0)

-		return;

-	h = hash(sym->name, sym->ns);

-	assert(sym->ns == NS_CPP || *h == sym);

-	while (*h != sym)

-		h = &(*h)->hash;

-	*h = sym->hash;

-}

-

-void

-pushctx(void)

-{

-	DBG("SYM: pushed context %d", curctx+1);

-	if (++curctx == NR_BLOCK+1)

-		error("too many nested blocks");

-}

-

-void

-killsym(Symbol *sym)

-{

-	short f;

-	char *name;

-

-	if (!sym)

-		return;

-	f = sym->flags;

-	if (f & SSTRING)

-		free(sym->u.s);

-	if (sym->ns == NS_TAG)

-		sym->type->prop &= ~TDEFINED;

-	unlinkhash(sym);

-	if ((name = sym->name) != NULL) {

-		switch (sym->ns) {

-		case NS_LABEL:

-			if ((f & SDEFINED) == 0)

-				errorp("label '%s' is not defined", name);

-		case NS_IDEN:

-			if ((f & (SUSED|SGLOBAL|SDECLARED)) == SDECLARED)

-				warn("'%s' defined but not used", name);

-			break;

-		}

-	}

-	free(name);

-	free(sym);

-}

-

-void

-popctx(void)

-{

-	Symbol *next, *sym;

-	int ns, dangling = 0;

-

-	DBG("SYM: poped context %d", curctx);

-	/*

-	 * we have to be careful before popping the current

-	 * context, because since the parser is one token

-	 * ahead it may already have read an identifier at

-	 * this point, and yylval.sym is a pointer to

-	 * the symbol associated to such token. If that

-	 * symbol is from the context that we are popping

-	 * then we are going to generate a dangling pointer.

-	 * We can detect this situation and call again to

-	 * lookup.

-	 */

-	if ((yytoken == IDEN || yytoken == TYPEIDEN) &&

-	    yylval.sym->ctx == curctx) {

-		ns = yylval.sym->ns;

-		dangling = 1;

-	}

-

-	for (sym = head; sym && sym->ctx == curctx; sym = next) {

-		/*

-		 * Since we are unlinking them in the inverse order

-		 * we do know that sym is always the head of the

-		 * collision list

-		 */

-		next = sym->next;

-		killsym(sym);

-	}

-	head = sym;

-

-	if (--curctx == GLOBALCTX) {

-		for (sym = labels; sym; sym = next) {

-			next = sym->next;

-			killsym(sym);

-		}

-		labels = NULL;

-	}

-

-	if (dangling) {

-		yylval.sym = lookup(ns, yytext, ALLOC);

-		yytoken = yylval.sym->token;

-	}

-}

-

-unsigned

-newid(void)

-{

-	unsigned short id;

-

-	if (lexmode == CPPMODE)

-		return 0;

-	id = ++counterid;

-	if (id == 0) {

-		die("cc1: overflow in %s identifiers",

-		    (curctx) ? "internal" : "external");

-	}

-	return id;

-}

-

-Symbol *

-newsym(int ns, char *name)

-{

-	Symbol *sym;

-

-	sym = xmalloc(sizeof(*sym));

-	if (name)

-		name = xstrdup(name);

-	sym->name = name;

-	sym->id = 0;

-	sym->hide = 0;

-	sym->ns = ns;

-	sym->ctx = curctx;

-	sym->token = IDEN;

-	sym->flags = 0;

-	sym->u.s = NULL;

-	sym->type = NULL;

-	sym->hash = NULL;

-

-	if (ns == NS_LABEL) {

-		sym->next = labels;

-		labels = sym;

-	} else if (ns != NS_CPP) {

-		sym->next = head;

-		head = sym;

-	}

-	return sym;

-}

-

-static Symbol *

-linkhash(Symbol *sym)

-{

-	Symbol **h;

-

-	h = hash(sym->name, sym->ns);

-	sym->hash = *h;

-	*h = sym;

-

-	if (sym->ns != NS_CPP)

-		sym->id = newid();

-	sym->flags |= SDECLARED;

-	return sym;

-}

-

-Symbol *

-newstring(char *s, size_t len)

-{

-	Symbol *sym = newsym(NS_IDEN, NULL);

-

-	if (lexmode != CPPMODE)

-		sym->type = mktype(chartype, ARY, len, NULL);

-	sym->id = newid();

-	sym->flags |= SSTRING | SCONSTANT | SPRIVATE;

-	sym->u.s = xmalloc(len);

-	if (s)

-		memcpy(sym->u.s, s, len);

-

-	return sym;

-}

-

-Symbol *

-newlabel(void)

-{

-	Symbol *sym = newsym(NS_LABEL, NULL);

-	sym->id = newid();

-	return sym;

-}

-

-Symbol *

-lookup(int ns, char *name, int alloc)

-{

-	Symbol *sym;

-	int sns, c;

-	char *t;

-

-	c = *name;

-	for (sym = *hash(name, ns); sym; sym = sym->hash) {

-		t = sym->name;

-		if (*t != c || strcmp(t, name))

-			continue;

-		sns = sym->ns;

-		if (sns == ns)

-			return sym;

-		/*

-		 * When a lookup is done in a namespace associated

-		 * to a struct we also want symbols of NS_IDEN which

-		 * are typedef, because in other case we cannot declare

-		 * fields of such types.

-		 * TODO: Remove this trick

-		 */

-		if (sns == NS_KEYWORD ||

-		    (sym->flags & STYPEDEF) && ns >= NS_STRUCTS) {

-			return sym;

-		}

-	}

-	return (alloc == ALLOC) ? newsym(ns, name) : NULL;

-}

-

-Symbol *

-install(int ns, Symbol *sym)

-{

-	if (sym->flags & SDECLARED || sym->ctx != curctx) {

-		if (sym->ctx == curctx && ns == sym->ns)

-			return NULL;

-		sym = newsym(ns, sym->name);

-	}

-	return linkhash(sym);

-}

-

-void

-keywords(struct keyword *key, int ns)

-{

-	Symbol *sym;

-

-	for ( ; key->str; ++key) {

-		sym = linkhash(newsym(ns, key->str));

-		sym->token = key->token;

-		sym->u.token = key->value;

-	}

-	/*

-	 * Remove all the predefined symbols from * the symbol list. It

-	 * will make faster some operations. There is no problem of memory

-	 * leakeage because this memory is not ever freed

-	 */

-	counterid = 0;

-	head = NULL;

-}

-

-void

-builtins(struct builtin *built)

-{

-	Symbol *sym;

-	struct builtin *bp;

-

-	for (bp = built; bp->str; ++bp) {

-		sym = linkhash(newsym(NS_KEYWORD, bp->str));

-		sym->token = BUILTIN;

-		sym->u.fun = bp->fun;

-	}

-	/*

-	 * Remove all the predefined symbols from * the symbol list. It

-	 * will make faster some operations. There is no problem of memory

-	 * leakeage because this memory is not ever freed

-	 */

-	counterid = 0;

-	head = NULL;

-}

--- a/src/cmd/cc1/target/amd64-sysv/arch.c

+++ /dev/null

@@ -1,220 +1,0 @@

-static char sccsid[] = "@(#) ./cc1/arch/amd64-sysv/arch.c";

-

-#include <scc/scc.h>

-#include "../../cc1.h"

-

-#define RANK_BOOL    0

-#define RANK_SCHAR   1

-#define RANK_UCHAR   1

-#define RANK_CHAR    1

-#define RANK_SHORT   2

-#define RANK_USHORT  2

-#define RANK_INT     3

-#define RANK_UINT    3

-#define RANK_LONG    4

-#define RANK_ULONG   4

-#define RANK_LLONG   5

-#define RANK_ULLONG  5

-#define RANK_FLOAT   6

-#define RANK_DOUBLE  7

-#define RANK_LDOUBLE 8

-

-/*

- * Initializaion of type pointers were done with

- * a C99 initilizator '... = &(Type) {...', but

- * c compiler in Plan9 gives error with this

- * syntax, so I have switched it to this ugly form

- * I hope I will change it again in the future

- */

-

-static Type types[] = {

-	{       /* 0 = voidtype */

-		.op = VOID,

-		.letter = L_VOID,

-	},

-	{       /* 1 = pvoidtype */

-		.op = PTR,

-		.letter = L_POINTER,

-		.prop = TDEFINED,

-		.type = &types[5],  /* chartype */

-		.size = 8,

-		.align = 8,

-	},

-	{      /* 2 = booltype */

-		.op = INT,

-		.letter = L_BOOL,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 1,

-		.align = 1,

-		.n.rank = RANK_BOOL,

-	},

-	{       /* 3 = schartype */

-		.op = INT,

-		.letter = L_INT8,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 1,

-		.align = 1,

-		.n.rank = RANK_SCHAR,

-	},

-	{      /* 4 = uchartype */

-		.op = INT,

-		.letter = L_UINT8,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 1,

-		.align = 1,

-		.n.rank = RANK_UCHAR,

-	},

-	{      /* 5 = chartype */

-		.op = INT,

-		.letter = L_INT8,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 1,

-		.align = 1,

-		.n.rank = RANK_CHAR,

-	},

-	{       /* 6 = ushortype */

-		.op = INT,

-		.letter = L_UINT16,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 2,

-		.align = 2,

-		.n.rank = RANK_USHORT,

-	},

-	{       /* 7 = shortype */

-		.op = INT,

-		.letter = L_INT16,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 2,

-		.align = 2,

-		.n.rank = RANK_SHORT,

-	},

-	{       /* 8 = uinttype */

-		.op = INT,

-		.letter = L_UINT32,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 4,

-		.align = 4,

-		.n.rank = RANK_UINT,

-	},

-	{       /* 9 = inttype */

-		.op = INT,

-		.letter = L_INT32,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 4,

-		.align = 4,

-		.n.rank = RANK_INT,

-	},

-	{      /* 10 = longtype */

-		.op = INT,

-		.letter = L_INT64,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 8,

-		.align = 8,

-		.n.rank = RANK_LONG,

-	},

-	{       /* 11 = ulongtype */

-		.op = INT,

-		.letter = L_UINT64,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 8,

-		.align = 8,

-		.n.rank = RANK_ULONG,

-	},

-	{	/* 12 = ullongtype */

-		.op = INT,

-		.letter = L_UINT64,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 8,

-		.align = 8,

-		.n.rank = RANK_ULLONG,

-	},

-	{       /* 13 = llongtype */

-		.op = INT,

-		.letter = L_INT64,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 8,

-		.align = 8,

-		.n.rank = RANK_LLONG,

-	},

-	{       /* 14 = floattype */

-		.op = FLOAT,

-		.letter = L_FLOAT,

-		.prop = TDEFINED | TARITH,

-		.size = 4,

-		.align = 4,

-		.n.rank = RANK_FLOAT,

-	},

-	{       /* 15 = doubletype */

-		.op = FLOAT,

-		.letter = L_DOUBLE,

-		.prop = TDEFINED | TARITH,

-		.size = 8,

-		.align = 8,

-		.n.rank = RANK_DOUBLE,

-	},

-	{       /* 16 = ldoubletype */

-		.op = FLOAT,

-		.letter = L_LDOUBLE,

-		.prop = TDEFINED | TARITH,

-		.size = 16,

-		.align = 16,

-		.n.rank = RANK_LDOUBLE,

-	},

-	{       /* 17 = sizettype */

-		.op = INT,

-		.letter = L_UINT64,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 8,

-		.align = 8,

-		.n.rank = RANK_UINT,

-	},

-	{      /* 18 = ellipsis */

-		.op = ELLIPSIS,

-		.letter = L_ELLIPSIS,

-		.prop = TDEFINED,

-	},

-	{      /* 19 = pdifftype */

-		.op = INT,

-		.letter = L_INT64,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 8,

-		.align = 8,

-		.n.rank = RANK_LONG,

-	},

-	{      /* 20 = va_type */

-		.op = STRUCT,

-		.letter = L_VA_ARG,

-		.prop = TDEFINED,

-		.size = 24,

-		.align = 8,

-	},

-};

-

-Type *voidtype = &types[0], *pvoidtype = &types[1],

-     *booltype = &types[2], *schartype = &types[3],

-     *uchartype = &types[4], *chartype = &types[5],

-     *ushortype = &types[6], *shortype = &types[7],

-     *uinttype = &types[8], *inttype = &types[9],

-     *longtype = &types[10], *ulongtype = &types[11],

-     *ullongtype = &types[12], *llongtype = &types[13],

-     *floattype = &types[14], *doubletype = &types[15],

-     *ldoubletype = &types[16],

-     *sizettype = &types[17], *pdifftype = &types[19],

-     *ellipsistype = &types[18], *va_type = &types[20],

-     *va_list_type;

-

-static Symbol dummy0 = {.u.i = 0, .type = &types[9]},

-              dummy1 = {.u.i = 1, .type = &types[9]};

-Symbol *zero = &dummy0, *one = &dummy1;

-

-void

-iarch(void)

-{

-	va_list_type = mktype(va_type, ARY, 1, NULL);

-}

-

-int

-valid_va_list(Type *tp)

-{

-	return tp->op == PTR && eqtype(tp->type, va_type, 1);

-}

--- a/src/cmd/cc1/target/amd64-sysv/arch.mk

+++ /dev/null

@@ -1,4 +1,0 @@

-OBJ-amd64-sysv= $(OBJS)  target/amd64-sysv/arch.o

-

-$(LIBEXEC)/cc1-amd64-sysv: $(OBJ-amd64-sysv)

-	$(CC) $(SCC_LDFLAGS) $(OBJ-amd64-sysv) -lscc -o $@

--- a/src/cmd/cc1/target/arm64-sysv/arch.c

+++ /dev/null

@@ -1,220 +1,0 @@

-static char sccsid[] = "@(#) ./cc1/arch/arm64-sysv/arch.c";

-

-#include <scc/scc.h>

-#include "../../cc1.h"

-

-#define RANK_BOOL    0

-#define RANK_SCHAR   1

-#define RANK_UCHAR   1

-#define RANK_CHAR    1

-#define RANK_SHORT   2

-#define RANK_USHORT  2

-#define RANK_INT     3

-#define RANK_UINT    3

-#define RANK_LONG    4

-#define RANK_ULONG   4

-#define RANK_LLONG   5

-#define RANK_ULLONG  5

-#define RANK_FLOAT   6

-#define RANK_DOUBLE  7

-#define RANK_LDOUBLE 8

-

-/*

- * Initializaion of type pointers were done with

- * a C99 initilizator '... = &(Type) {...', but

- * c compiler in Plan9 gives error with this

- * syntax, so I have switched it to this ugly form

- * I hope I will change it again in the future

- */

-

-static Type types[] = {

-	{       /* 0 = voidtype */

-		.op = VOID,

-		.letter = L_VOID,

-	},

-	{       /* 1 = pvoidtype */

-		.op = PTR,

-		.letter = L_POINTER,

-		.prop = TDEFINED,

-		.type = &types[5],  /* chartype */

-		.size = 8,

-		.align = 8,

-	},

-	{      /* 2 = booltype */

-		.op = INT,

-		.letter = L_BOOL,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 1,

-		.align = 1,

-		.n.rank = RANK_BOOL,

-	},

-	{       /* 3 = schartype */

-		.op = INT,

-		.letter = L_INT8,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 1,

-		.align = 1,

-		.n.rank = RANK_SCHAR,

-	},

-	{      /* 4 = uchartype */

-		.op = INT,

-		.letter = L_UINT8,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 1,

-		.align = 1,

-		.n.rank = RANK_UCHAR,

-	},

-	{      /* 5 = chartype */

-		.op = INT,

-		.letter = L_INT8,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 1,

-		.align = 1,

-		.n.rank = RANK_CHAR,

-	},

-	{       /* 6 = ushortype */

-		.op = INT,

-		.letter = L_UINT16,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 2,

-		.align = 2,

-		.n.rank = RANK_USHORT,

-	},

-	{       /* 7 = shortype */

-		.op = INT,

-		.letter = L_INT16,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 2,

-		.align = 2,

-		.n.rank = RANK_SHORT,

-	},

-	{       /* 8 = uinttype */

-		.op = INT,

-		.letter = L_UINT32,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 4,

-		.align = 4,

-		.n.rank = RANK_UINT,

-	},

-	{       /* 9 = inttype */

-		.op = INT,

-		.letter = L_INT32,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 4,

-		.align = 4,

-		.n.rank = RANK_INT,

-	},

-	{      /* 10 = longtype */

-		.op = INT,

-		.letter = L_INT64,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 8,

-		.align = 8,

-		.n.rank = RANK_LONG,

-	},

-	{       /* 11 = ulongtype */

-		.op = INT,

-		.letter = L_UINT64,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 8,

-		.align = 8,

-		.n.rank = RANK_ULONG,

-	},

-	{	/* 12 = ullongtype */

-		.op = INT,

-		.letter = L_UINT64,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 8,

-		.align = 8,

-		.n.rank = RANK_ULLONG,

-	},

-	{       /* 13 = llongtype */

-		.op = INT,

-		.letter = L_INT64,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 8,

-		.align = 8,

-		.n.rank = RANK_LLONG,

-	},

-	{       /* 14 = floattype */

-		.op = FLOAT,

-		.letter = L_FLOAT,

-		.prop = TDEFINED | TARITH,

-		.size = 4,

-		.align = 4,

-		.n.rank = RANK_FLOAT,

-	},

-	{       /* 15 = doubletype */

-		.op = FLOAT,

-		.letter = L_DOUBLE,

-		.prop = TDEFINED | TARITH,

-		.size = 8,

-		.align = 8,

-		.n.rank = RANK_DOUBLE,

-	},

-	{       /* 16 = ldoubletype */

-		.op = FLOAT,

-		.letter = L_LDOUBLE,

-		.prop = TDEFINED | TARITH,

-		.size = 16,

-		.align = 16,

-		.n.rank = RANK_LDOUBLE,

-	},

-	{       /* 17 = sizettype */

-		.op = INT,

-		.letter = L_UINT64,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 8,

-		.align = 8,

-		.n.rank = RANK_UINT,

-	},

-	{      /* 18 = ellipsis */

-		.op = ELLIPSIS,

-		.letter = L_ELLIPSIS,

-		.prop = TDEFINED,

-	},

-	{      /* 19 = pdifftype */

-		.op = INT,

-		.letter = L_INT64,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 8,

-		.align = 8,

-		.n.rank = RANK_LONG,

-	},

-	{      /* 20 = va_type */

-		.op = STRUCT,

-		.letter = L_VA_ARG,

-		.prop = TDEFINED,

-		.size = 24,

-		.align = 8,

-	},

-};

-

-Type *voidtype = &types[0], *pvoidtype = &types[1],

-     *booltype = &types[2], *schartype = &types[3],

-     *uchartype = &types[4], *chartype = &types[5],

-     *ushortype = &types[6], *shortype = &types[7],

-     *uinttype = &types[8], *inttype = &types[9],

-     *longtype = &types[10], *ulongtype = &types[11],

-     *ullongtype = &types[12], *llongtype = &types[13],

-     *floattype = &types[14], *doubletype = &types[15],

-     *ldoubletype = &types[16],

-     *sizettype = &types[17], *pdifftype = &types[19],

-     *ellipsistype = &types[18], *va_type = &types[20],

-     *va_list_type;

-

-static Symbol dummy0 = {.u.i = 0, .type = &types[9]},

-              dummy1 = {.u.i = 1, .type = &types[9]};

-Symbol *zero = &dummy0, *one = &dummy1;

-

-void

-iarch(void)

-{

-	va_list_type = mktype(va_type, ARY, 1, NULL);

-}

-

-int

-valid_va_list(Type *tp)

-{

-	return tp->op == PTR && eqtype(tp->type, va_type, 1);

-}

--- a/src/cmd/cc1/target/arm64-sysv/arch.mk

+++ /dev/null

@@ -1,4 +1,0 @@

-OBJ-arm64-sysv= $(OBJS)  target/arm64-sysv/arch.o

-

-$(LIBEXEC)/cc1-arm64-sysv: $(OBJ-arm64-sysv)

-	$(CC) $(SCC_LDFLAGS) $(OBJ-arm64-sysv) -lscc -o $@

--- a/src/cmd/cc1/target/i386-sysv/arch.c

+++ /dev/null

@@ -1,221 +1,0 @@

-static char sccsid[] = "@(#) ./cc1/arch/i386-sysv/arch.c";

-

-#include <scc/scc.h>

-#include "../../cc1.h"

-

-#define RANK_BOOL    0

-#define RANK_SCHAR   1

-#define RANK_UCHAR   1

-#define RANK_CHAR    1

-#define RANK_SHORT   2

-#define RANK_USHORT  2

-#define RANK_INT     3

-#define RANK_UINT    3

-#define RANK_LONG    4

-#define RANK_ULONG   4

-#define RANK_LLONG   5

-#define RANK_ULLONG  5

-#define RANK_FLOAT   6

-#define RANK_DOUBLE  7

-#define RANK_LDOUBLE 8

-

-/*

- * Initializaion of type pointers were done with

- * a C99 initilizator '... = &(Type) {...', but

- * c compiler in Plan9 gives error with this

- * syntax, so I have switched it to this ugly form

- * I hope I will change it again in the future

- */

-

-static Type types[] = {

-	{       /* 0 = voidtype */

-		.op = VOID,

-		.letter = L_VOID,

-	},

-	{       /* 1 = pvoidtype */

-		.op = PTR,

-		.letter = L_POINTER,

-		.prop = TDEFINED,

-		.type = &types[5],  /* chartype */

-		.size = 4,

-		.align = 4,

-	},

-	{      /* 2 = booltype */

-		.op = INT,

-		.letter = L_BOOL,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 1,

-		.align = 1,

-		.n.rank = RANK_BOOL,

-	},

-	{       /* 3 = schartype */

-		.op = INT,

-		.letter = L_INT8,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 1,

-		.align = 1,

-		.n.rank = RANK_SCHAR,

-	},

-	{      /* 4 = uchartype */

-		.op = INT,

-		.letter = L_UINT8,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 1,

-		.align = 1,

-		.n.rank = RANK_UCHAR,

-	},

-	{      /* 5 = chartype */

-		.op = INT,

-		.letter = L_INT8,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 1,

-		.align = 1,

-		.n.rank = RANK_CHAR,

-	},

-	{       /* 6 = ushortype */

-		.op = INT,

-		.letter = L_UINT16,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 2,

-		.align = 2,

-		.n.rank = RANK_USHORT,

-	},

-	{       /* 7 = shortype */

-		.op = INT,

-		.letter = L_INT16,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 2,

-		.align = 2,

-		.n.rank = RANK_SHORT,

-	},

-	{       /* 8 = uinttype */

-		.op = INT,

-		.letter = L_UINT32,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 4,

-		.align = 4,

-		.n.rank = RANK_UINT,

-	},

-	{       /* 9 = inttype */

-		.op = INT,

-		.letter = L_INT32,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 4,

-		.align = 4,

-		.n.rank = RANK_INT,

-	},

-	{      /* 10 = longtype */

-		.op = INT,

-		.letter = L_INT32,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 4,

-		.align = 4,

-		.n.rank = RANK_LONG,

-	},

-	{       /* 11 = ulongtype */

-		.op = INT,

-		.letter = L_UINT32,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 4,

-		.align = 4,

-		.n.rank = RANK_ULONG,

-	},

-	{	/* 12 = ullongtype */

-		.op = INT,

-		.letter = L_UINT64,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 8,

-		.align = 4,

-		.n.rank = RANK_ULLONG,

-	},

-	{       /* 13 = llongtype */

-		.op = INT,

-		.letter = L_INT64,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 8,

-		.align = 4,

-		.n.rank = RANK_LLONG,

-	},

-	{       /* 14 = floattype */

-		.op = FLOAT,

-		.letter = L_FLOAT,

-		.prop = TDEFINED | TARITH,

-		.size = 4,

-		.align = 4,

-		.n.rank = RANK_FLOAT,

-	},

-	{       /* 15 = doubletype */

-		.op = FLOAT,

-		.letter = L_DOUBLE,

-		.prop = TDEFINED | TARITH,

-		.size = 8,

-		.align = 4,

-		.n.rank = RANK_DOUBLE,

-	},

-	{       /* 16 = ldoubletype */

-		.op = FLOAT,

-		.letter = L_LDOUBLE,

-		.prop = TDEFINED | TARITH,

-		.size = 12,

-		.align = 4,

-		.n.rank = RANK_LDOUBLE,

-	},

-	{       /* 17 = sizettype */

-		.op = INT,

-		.letter = L_UINT32,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 4,

-		.align = 4,

-		.n.rank = RANK_UINT,

-	},

-	{      /* 18 = ellipsis */

-		.op = ELLIPSIS,

-		.letter = L_ELLIPSIS,

-		.prop = TDEFINED,

-	},

-	{       /* 19 = pdifftype */

-		.op = INT,

-		.letter = L_INT32,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 4,

-		.align = 4,

-		.n.rank = RANK_INT,

-	},

-	{      /* 20 = va_list_type */

-		.op = PTR,

-		.letter = L_POINTER,

-		.prop = TDEFINED,

-		.size = 4,

-		.align = 4,

-	},

-};

-

-

-Type *voidtype = &types[0], *pvoidtype = &types[1],

-     *booltype = &types[2], *schartype = &types[3],

-     *uchartype = &types[4], *chartype = &types[5],

-     *ushortype = &types[6], *shortype = &types[7],

-     *uinttype = &types[8], *inttype = &types[9],

-     *longtype = &types[10], *ulongtype = &types[11],

-     *ullongtype = &types[12], *llongtype = &types[13],

-     *floattype = &types[14], *doubletype = &types[15],

-     *ldoubletype = &types[16],

-     *sizettype = &types[17], *pdifftype = &types[19],

-     *ellipsistype = &types[18], *va_list_type = &types[20];

-

-

-

-static Symbol dummy0 = {.u.i = 0, .type = &types[9]},

-              dummy1 = {.u.i = 1, .type = &types[9]};

-Symbol *zero = &dummy0, *one = &dummy1;

-

-void

-iarch(void)

-{

-}

-

-int

-valid_va_list(Type *tp)

-{

-	return eqtype(tp, va_list_type, 1);

-}

--- a/src/cmd/cc1/target/i386-sysv/arch.mk

+++ /dev/null

@@ -1,4 +1,0 @@

-OBJ-i386-sysv= $(OBJS)  target/i386-sysv/arch.o

-

-$(LIBEXEC)/cc1-i386-sysv: $(OBJ-i386-sysv)

-	$(CC) $(SCC_LDFLAGS) $(OBJ-i386-sysv) -lscc -o $@

--- a/src/cmd/cc1/target/z80-scc/arch.c

+++ /dev/null

@@ -1,219 +1,0 @@

-static char sccsid[] = "@(#) ./cc1/arch/z80/arch.c";

-

-#include <scc/scc.h>

-#include "../../cc1.h"

-

-#define RANK_BOOL    0

-#define RANK_SCHAR   1

-#define RANK_UCHAR   1

-#define RANK_CHAR    1

-#define RANK_SHORT   2

-#define RANK_USHORT  2

-#define RANK_INT     3

-#define RANK_UINT    3

-#define RANK_LONG    4

-#define RANK_ULONG   4

-#define RANK_LLONG   5

-#define RANK_ULLONG  5

-#define RANK_FLOAT   6

-#define RANK_DOUBLE  7

-#define RANK_LDOUBLE 8

-

-/*

- * Initializaion of type pointers were done with

- * a C99 initilizator '... = &(Type) {...', but

- * c compiler in Plan9 gives error with this

- * syntax, so I have switched it to this ugly form

- * I hope I will change it again in the future

- */

-

-static Type types[] = {

-	{       /* 0 = voidtype */

-		.op = VOID,

-		.letter = L_VOID,

-	},

-	{       /* 1 = pvoidtype */

-		.op = PTR,

-		.letter = L_POINTER,

-		.prop = TDEFINED,

-		.type = &types[5], /* char type */

-		.size = 2,

-		.align = 2,

-	},

-	{      /* 2 = booltype */

-		.op = INT,

-		.letter = L_BOOL,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 1,

-		.align = 1,

-		.n.rank = RANK_BOOL,

-	},

-	{       /* 3 = schartype */

-		.op = INT,

-		.letter = L_INT8,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 1,

-		.align = 1,

-		.n.rank = RANK_SCHAR,

-	},

-	{      /* 4 = uchartype */

-		.op = INT,

-		.letter = L_UINT8,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 1,

-		.align = 1,

-		.n.rank = RANK_UCHAR,

-	},

-	{      /* 5 = chartype */

-		.op = INT,

-		.letter = L_UINT8,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 1,

-		.align = 1,

-		.n.rank = RANK_CHAR,

-	},

-	{       /* 6 = ushortype */

-		.op = INT,

-		.letter = L_UINT16,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 2,

-		.align = 1,

-		.n.rank = RANK_USHORT,

-	},

-	{       /* 7 = shortype */

-		.op = INT,

-		.letter = L_INT16,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 2,

-		.align = 1,

-		.n.rank = RANK_SHORT,

-	},

-	{       /* 8 = uinttype */

-		.op = INT,

-		.letter = L_UINT16,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 2,

-		.align = 1,

-		.n.rank = RANK_UINT,

-	},

-	{       /* 9 = inttype */

-		.op = INT,

-		.letter = L_INT16,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 2,

-		.align = 1,

-		.n.rank = RANK_INT,

-	},

-	{      /* 10 = longtype */

-		.op = INT,

-		.letter = L_INT32,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 4,

-		.align = 1,

-		.n.rank = RANK_LONG,

-	},

-	{       /* 11 = ulongtype */

-		.op = INT,

-		.letter = L_UINT32,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 4,

-		.align = 1,

-		.n.rank = RANK_ULONG,

-	},

-	{	/* 12 = ullongtype */

-		.op = INT,

-		.letter = L_UINT64,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 8,

-		.align = 1,

-		.n.rank = RANK_ULLONG,

-	},

-	{       /* 13 = llongtype */

-		.op = INT,

-		.letter = L_INT64,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 8,

-		.align = 1,

-		.n.rank = RANK_LLONG,

-	},

-	{       /* 14 = floattype */

-		.op = FLOAT,

-		.letter = L_FLOAT,

-		.prop = TDEFINED | TARITH,

-		.size = 4,

-		.align = 1,

-		.n.rank = RANK_FLOAT,

-	},

-	{       /* 15 = doubletype */

-		.op = FLOAT,

-		.letter = L_DOUBLE,

-		.prop = TDEFINED | TARITH,

-		.size = 8,

-		.align = 1,

-		.n.rank = RANK_DOUBLE,

-	},

-	{       /* 16 = ldoubletype */

-		.op = FLOAT,

-		.letter = L_LDOUBLE,

-		.prop = TDEFINED | TARITH,

-		.size = 16,

-		.align = 1,

-		.n.rank = RANK_LDOUBLE,

-	},

-	{       /* 17 = sizettype */

-		.op = INT,

-		.letter = L_UINT16,

-		.prop = TDEFINED | TINTEGER | TARITH,

-		.size = 2,

-		.align = 1,

-		.n.rank = RANK_UINT,

-	},

-	{      /* 18 = ellipsis */

-		.op = ELLIPSIS,

-		.letter = L_ELLIPSIS,

-		.prop = TDEFINED,

-	},

-	{       /* 7 = pdifftype */

-		.op = INT,

-		.letter = L_INT16,

-		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

-		.size = 2,

-		.align = 1,

-		.n.rank = RANK_SHORT,

-	},

-	{       /* 20 = va_list_type */

-		.op = PTR,

-		.letter = L_POINTER,

-		.prop = TDEFINED,

-		.size = 2,

-		.align = 1,

-	}

-};

-

-Type *voidtype = &types[0], *pvoidtype = &types[1],

-     *booltype = &types[2], *schartype = &types[3],

-     *uchartype = &types[4], *chartype = &types[5],

-     *ushortype = &types[6], *shortype = &types[7],

-     *uinttype = &types[8], *inttype = &types[9],

-     *longtype = &types[10], *ulongtype = &types[11],

-     *ullongtype = &types[12], *llongtype = &types[13],

-     *floattype = &types[14], *doubletype = &types[15],

-     *ldoubletype = &types[16],

-     *sizettype = &types[17], *pdifftype = &types[19],

-     *ellipsistype = &types[18], *va_list_type = &types[20];

-

-

-static Symbol dummy0 = {.u.i = 0, .type = &types[9]},

-              dummy1 = {.u.i = 1, .type = &types[9]};

-Symbol *zero = &dummy0, *one = &dummy1;

-

-void

-iarch(void)

-{

-}

-

-int

-valid_va_list(Type *tp)

-{

-	return eqtype(tp, va_list_type, 1);

-}

--- a/src/cmd/cc1/target/z80-scc/arch.mk

+++ /dev/null

@@ -1,4 +1,0 @@

-OBJ-z80-scc= $(OBJS) target/z80-scc/arch.o

-

-$(LIBEXEC)/cc1-z80-scc: $(OBJ-z80-scc)

-	$(CC) $(SCC_LDFLAGS) $(OBJ-z80-scc) -lscc -o $@

--- a/src/cmd/cc1/types.c

+++ /dev/null

@@ -1,438 +1,0 @@

-static char sccsid[] = "@(#) ./cc1/types.c";

-#include <assert.h>

-#include <inttypes.h>

-#include <stdlib.h>

-#include <string.h>

-

-#include <scc/cstd.h>

-#include <scc/scc.h>

-#include "cc1.h"

-

-#define NR_TYPE_HASH 16

-#define HASH(t) (((t)->op ^ (uintptr_t) (t)->type>>3) & NR_TYPE_HASH-1)

-

-static Type *typetab[NR_TYPE_HASH], *localtypes;

-

-/* FIXME:

- * Compiler can generate warnings here if the ranges of TINT,

- * TUINT and TFLOAT are smaller than any of the constants in this

- * array. Ignore them if you know that the target types are correct

- */

-static struct limits limits[][4] = {

-	{

-		{	/* 0 = unsigned 1 byte */

-			.min.i = 0,

-			.max.i = 0xff

-		},

-		{	/* 1 = unsigned 2 bytes */

-			.min.i = 0,

-			.max.i = 0xffff

-		},

-		{	/* 2 = unsigned 4 bytes */

-			.min.i = 0,

-			.max.i = 0xffffffff

-		},

-		{	/* 3 = unsigned 8 bytes */

-			.min.i = 0,

-			.max.i = 0xffffffffffffffff

-		}

-	},

-	{

-		{	/* 0 = signed 1 byte */

-			.min.i = -0x7f-1,

-			.max.i = 0x7f

-		},

-		{	/* 1 = signed 2 byte */

-			.min.i = -0x7fff-1,

-			.max.i = 0x7fff

-		},

-		{	/* 2 = signed 4 byte */

-			.min.i = -0x7fffffff-1,

-			.max.i = 0x7fffffff

-		},

-		{	/* 3 = signed 8 byte */

-			.min.i = -0x7fffffffffffffff-1,

-			.max.i = 0x7fffffffffffffff,

-		}

-	},

-	{

-		{

-			/* 0 = float 4 bytes */

-			.min.f = -1,

-			.max.f = 2

-		},

-		{

-			/* 1 = float 8 bytes */

-			.min.f = -1,

-			.max.f = 2,

-		},

-		{

-			/* 2 = float 16 bytes */

-			.min.f = -1,

-			.max.f = 2,

-		}

-	}

-};

-

-struct limits *

-getlimits(Type *tp)

-{

-	int ntable, ntype;

-

-	switch (tp->op) {

-	case ENUM:

-	case INT:

-		ntable = ((tp->prop & TSIGNED) != 0);

-		switch (tp->size) {

-		case 1: ntype = 0; break;

-		case 2: ntype = 1; break;

-		case 4: ntype = 2; break;

-		case 8: ntype = 3; break;

-		}

-		break;

-	case FLOAT:

-		ntable = 2;

-		switch (tp->size) {

-		case 4:  ntype = 0; break;

-		case 8:  ntype = 1; break;

-		case 16: ntype = 2; break;

-		}

-		break;

-	default:

-		abort();

-	}

-

-	return &limits[ntable][ntype];

-}

-

-Type *

-ctype(int type, int sign, int size)

-{

-	switch (type) {

-	case CHAR:

-		if (size)

-			goto invalid_type;

-		switch (sign) {

-		case 0:

-			return chartype;

-		case SIGNED:

-			return schartype;

-		case UNSIGNED:

-			return uchartype;

-		}

-		break;

-	case VA_LIST:

-		if (size || sign)

-			goto invalid_type;

-		return va_list_type;

-	case VOID:

-		if (size || sign)

-			goto invalid_type;

-		return voidtype;

-	case BOOL:

-		if (size || sign)

-			goto invalid_type;

-		return booltype;

-	case 0:

-	case INT:

-		switch (size) {

-		case 0:

-			return (sign == UNSIGNED) ? uinttype   : inttype;

-		case SHORT:

-			return (sign == UNSIGNED) ? ushortype  : shortype;

-		case LONG:

-			return (sign == UNSIGNED) ? ulongtype  : longtype;

-		case LLONG:

-			return (sign == UNSIGNED) ? ullongtype : llongtype;

-		}

-		break;

-	case DOUBLE:

-		if (size == LLONG)

-			goto invalid_type;

-		if (size == LONG)

-			size = LLONG;

-		else

-			size = LONG;

-		goto floating;

-	case FLOAT:

-		if (size == LLONG)

-			goto invalid_type;

-	floating:

-		if (sign)

-			goto invalid_type;

-		switch (size) {

-		case 0:

-			return floattype;

-		case LONG:

-			return doubletype;

-		case LLONG:

-			return ldoubletype;

-		}

-		break;

-	}

-

-invalid_type:

-	error("invalid type specification");

-}

-

-void

-typesize(Type *tp)

-{

-	Symbol **sp;

-	Type *type;

-	unsigned long size, offset;

-	int align, a;

-	TINT n;

-

-	switch (tp->op) {

-	case ARY:

-		/* FIXME: Control overflow */

-		tp->size = tp->n.elem * tp->type->size;

-		tp->align = tp->type->align;

-		return;

-	case PTR:

-		tp->size = pvoidtype->size;

-		tp->align = pvoidtype->align;

-		return;

-	case STRUCT:

-	case UNION:

-		/* FIXME: Control overflow */

-		/*

-		 * The alignment of the struct/union is

-		 * he alignment of the largest included type.

-		 * The size of an union is the size of the largest

-		 * field, and the size of a struct is the sum

-		 * of the size of every field plus padding bits.

-		 */

-		offset = align = size = 0;

-		n = tp->n.elem;

-		for (sp = tp->p.fields; n--; ++sp) {

-			(*sp)->u.i = offset;

-			type = (*sp)->type;

-			a = type->align;

-			if (a > align)

-				align = a;

-			if (tp->op == STRUCT) {

-				if (--a != 0)

-					size = (size + a) & ~a;

-				size += type->size;

-				offset = size;

-			} else {

-				if (type->size > size)

-					size = type->size;

-			}

-		}

-

-		tp->align = align;

-		/*

-		 * We have to add the padding bits to

-		 * ensure next struct in an array is well

-		 * alignment.

-		 */

-		if (tp->op == STRUCT && align-- > 1)

-			size += size+align & ~align;

-		tp->size = size;

-		return;

-	case ENUM:

-		tp->size = inttype->size;

-		tp->align = inttype->align;

-		return;

-	case FTN:

-		return;

-	default:

-		abort();

-	}

-}

-

-Type *

-deftype(Type *tp)

-{

-	tp->prop |= TDEFINED;

-	typesize(tp);

-	emit(OTYP, tp);

-	return tp;

-}

-

-static Type *

-newtype(Type *base)

-{

-	Type *tp;

-	size_t siz;

-

-	tp = xmalloc(sizeof(*tp));

-	*tp = *base;

-	tp->id = newid();

-

-	if (tp->op == FTN) {

-		siz = tp->n.elem * sizeof(Type *);

-		tp->p.pars = memcpy(xmalloc(siz), tp->p.pars, siz);

-	}

-

-	if (curfun) {

-		/* it is a type defined in the body of a function */

-		tp->next = localtypes;

-		localtypes = tp;

-	}

-	if (tp->prop & TDEFINED)

-		deftype(tp);

-	return tp;

-}

-

-Type *

-mktype(Type *tp, int op, TINT nelem, Type *pars[])

-{

-	Type **tbl, type;

-	Type *bp;

-

-	if (op == PTR && tp == voidtype)

-		return pvoidtype;

-

-	memset(&type, 0, sizeof(type));

-	type.type = tp;

-	type.op = op;

-	type.p.pars = pars;

-	type.n.elem = nelem;

-

-	switch (op) {

-	case ARY:

-		if (tp == voidtype) {

-			errorp("declaration of array of voids type");

-			tp = inttype;

-		}

-		type.letter = L_ARRAY;

-		if (nelem != 0)

-			type.prop |= TDEFINED;

-		break;

-	case KRFTN:

-		type.prop |= TDEFINED | TK_R;

-		type.op = FTN;

-		type.letter = L_FUNCTION;

-		break;

-	case FTN:

-		if (nelem > 0 && pars[nelem-1] == ellipsistype)

-			type.prop |= TELLIPSIS;

-		type.letter = L_FUNCTION;

-		type.prop |= TDEFINED;

-		break;

-	case PTR:

-	        type.letter = L_POINTER;

-		type.prop |= TDEFINED;

-		break;

-	case ENUM:

-		type.letter = inttype->letter;

-		type.prop |= TINTEGER | TARITH;

-		type.n.rank = inttype->n.rank;

-		goto create_type;

-	case STRUCT:

-		type.letter = L_STRUCT;

-		type.prop |= TAGGREG;

-		goto create_type;

-	case UNION:

-		type.letter = L_UNION;

-		type.prop |= TAGGREG;

-	create_type:

-		return newtype(&type);

-	default:

-		abort();

-	}

-

-	tbl = &typetab[HASH(&type)];

-	for (bp = *tbl; bp; bp = bp->h_next) {

-		if (eqtype(bp, &type, 0))

-			return bp;

-	}

-

-	bp = newtype(&type);

-	bp->h_next = *tbl;

-	*tbl = bp;

-

-	return bp;

-}

-

-int

-eqtype(Type *tp1, Type *tp2, int equiv)

-{

-	TINT n;

-	Type **p1, **p2;

-	Symbol **s1, **s2;

-

-	if (tp1 == tp2)

-		return 1;

-	if (!tp1 || !tp2)

-		return 0;

-	if (tp1->op != tp2->op)

-		return 0;

-

-	switch (tp1->op) {

-	case UNION:

-	case STRUCT:

-		if (tp1->letter != tp2->letter)

-			return 0;

-		if (tp1->tag->name || tp2->tag->name)

-			return tp1->tag == tp2->tag;

-		if (tp1->n.elem != tp2->n.elem)

-			return 0;

-		s1 = tp1->p.fields, s2 = tp2->p.fields;

-		for (n = tp1->n.elem; n > 0; --n, ++s1, ++s2) {

-			if (strcmp((*s1)->name, (*s2)->name))

-				return 0;

-			if (!eqtype((*s1)->type, (*s2)->type, equiv))

-				return 0;

-		}

-		return 1;

-	case FTN:

-		if (tp1->n.elem != tp2->n.elem)

-			return 0;

-		p1 = tp1->p.pars, p2 = tp2->p.pars;

-		for (n = tp1->n.elem; n > 0; --n) {

-			if (!eqtype(*p1++, *p2++, equiv))

-				return 0;

-		}

-		goto check_base;

-	case ARY:

-		if (equiv && (tp1->n.elem == 0 || tp2->n.elem == 0))

-			goto check_base;

-		if (tp1->n.elem != tp2->n.elem)

-			return 0;

-	case PTR:

-	check_base:

-		return eqtype(tp1->type, tp2->type, equiv);

-	case VOID:

-	case ENUM:

-		return 0;

-	case INT:

-	case FLOAT:

-		return tp1->letter == tp2->letter;

-	default:

-		abort();

-	}

-}

-

-void

-flushtypes(void)

-{

-	Type *tp, *next, **h;

-

-	for (tp = localtypes; tp; tp = next) {

-		next = tp->next;

-		switch (tp->op) {

-		default:

-			/*

-			 * All the local types are linked after

-			 * global types, and since we are

-			 * unlinking them in the inverse order

-			 * we do know that tp is always the head

-			 * of the collision list

-			 */

-			h = &typetab[HASH(tp)];

-			assert(*h == tp);

-			*h = tp->h_next;

-		case STRUCT:

-		case UNION:

-		case ENUM:

-			free(tp);

-			break;

-		}

-	}

-	localtypes = NULL;

-}

--- a/src/cmd/cc2/.gitignore

+++ /dev/null

@@ -1,1 +1,0 @@

-error.h

--- a/src/cmd/cc2/Makefile

+++ /dev/null

@@ -1,40 +1,0 @@

-.POSIX:

-

-PROJECTDIR = ../../..

-include $(PROJECTDIR)/scripts/rules.mk

-

-MORECFLAGS = -I$(INCDIR)/$(STD)

-

-OBJS = main.o \

-       parser.o \

-       peep.o \

-       symbol.o \

-       node.o \

-       code.o \

-       optm.o \

-

-TARGET  = $(LIBEXEC)/cc2-amd64-sysv \

-          $(LIBEXEC)/cc2-i386-sysv \

-          $(LIBEXEC)/cc2-qbe_amd64-sysv \

-          $(LIBEXEC)/cc2-z80-scc \

-

-all: $(TARGET)

-

-$(TARGET): error.h

-

-error.h: cc2.h

-	rm -f $@;\

-	trap 'r=$?;rm -f $$$$.h;exit $r' EXIT INT QUIT ;\

-	awk -f generror.awk cc2.h > $$$$.h && mv $$$$.h $@

-

-dep: inc-dep

-

-clean:

-	rm -f target/*/*.o error.h

-

-include target/amd64-sysv/target.mk

-include target/i386-sysv/target.mk

-include target/qbe_amd64-sysv/target.mk

-include target/qbe_arm64-sysv/target.mk

-include target/z80-scc/target.mk

-include deps.mk

--- a/src/cmd/cc2/cc2.h

+++ /dev/null

@@ -1,256 +1,0 @@

-enum iflags {

-	BBENTRY =    1,        /* basic block entry */

-};

-

-enum tflags {

-	SIGNF   =     1 << 0,  /* Signed type */

-	INTF    =     1 << 1,  /* integer type */

-	FLOATF  =     1 << 2,  /* float type */

-	STRF    =     1 << 3,  /* string */

-	AGGRF   =     1 << 4,  /* aggregate */

-	FUNF    =     1 << 5,  /* function */

-	PARF    =     1 << 6,  /* parameter */

-	INITF   =     1 << 7,  /* initializer flag */

-	ELLIPS  =     1 << 8,  /* vararg function */

-};

-

-enum sclass {

-	SAUTO     = 'A',

-	SREG      = 'R',

-	SLABEL    = 'L',

-	SINDEX    = 'I',

-	STMP      = 'N',

-	SGLOB     = 'G',

-	SEXTRN    = 'X',

-	SPRIV     = 'Y',

-	SLOCAL    = 'T',

-	SMEMB     = 'M',

-	SCONST    = '#',

-	STRING    = '"',

-	SNONE     = 0 /* cc2 relies on SNONE being 0 in nextpc() */

-};

-

-enum types {

-	ELLIPSIS = 'E',

-	INT8     = 'C',

-	INT16    = 'I',

-	INT32    = 'W',

-	INT64    = 'Q',

-	UINT8    = 'K',

-	UINT16   = 'N',

-	UINT32   = 'Z',

-	UINT64   = 'O',

-	POINTER  = 'P',

-	FUNCTION = 'F',

-	VECTOR   = 'V',

-	UNION    = 'U',

-	STRUCT   = 'S',

-	BOOL     = 'B',

-	FLOAT    = 'J',

-	DOUBLE   = 'D',

-	LDOUBLE  = 'H',

-	VOID     = '0'

-};

-

-enum op {

-	/* kind of operand */

-	/* operands */

-	OMEM     = 'M',

-	OTMP     = 'N',

-	OAUTO    = 'A',

-	OREG     = 'R',

-	OCONST   = '#',

-	OSTRING  = '"',

-	OLOAD    = 'D',

-	OLABEL   = 'L',

-	OADD     = '+',

-	OSUB     = '-',

-	OMUL     = '*',

-	OMOD     = '%',

-	ODIV     = '/',

-	OSHL     = 'l',

-	OSHR     = 'r',

-	OLT      = '<',

-	OGT      = '>',

-	OLE      = '[',

-	OGE      = ']',

-	OEQ      = '=',

-	ONE      = '!',

-	OBAND    = '&',

-	OBOR     = '|',

-	OBXOR    = '^',

-	OCPL     = '~',

-	OASSIG   = ':',

-	OSNEG    = '_',

-	OCALL    = 'c',

-	OCALLE   = 'z',

-	OPAR     = 'p',

-	OFIELD   = '.',

-	OCOMMA   = ',',

-	OASK     = '?',

-	OCOLON   = ' ',

-	OADDR    = '\'',

-	OAND     = 'a',

-	OOR      = 'o',

-	ONEG     = 'n',

-	OPTR     = '@',

-	OCAST    = 'g',

-	OINC     = 'i',

-	ODEC     = 'd',

-	OBUILTIN = 'm',

-	/*statements */

-	ONOP     = 'q',

-	OJMP     = 'j',

-	OBRANCH  = 'y',

-	ORET     = 'h',

-	OBLOOP   = 'b',

-	OELOOP   = 'e',

-	OCASE    = 'v',

-	ODEFAULT = 'f',

-	OBSWITCH = 's',

-	OESWITCH = 't',

-	OBFUN    = 'x',

-	OEFUN    = 'k',

-};

-

-enum builtins {

-	BVA_START = 's',

-	BVA_END   = 'e',

-	BVA_ARG   = 'a',

-	BVA_COPY  = 'c',

-};

-

-enum nerrors {

-	EEOFFUN,       /* EOF while parsing function */

-	ENLABEL,       /* label without statement */

-	EIDOVER,       /* identifier overflow */

-	EOUTPAR,       /* out pf params */

-	ESYNTAX,       /* syntax error */

-	ESTACKA,       /* stack unaligned */

-	ESTACKO,       /* stack overflow */

-	ESTACKU,       /* stack underflow */

-	ELNLINE,       /* line too long */

-	ELNBLNE,       /* line without new line */

-	EFERROR,       /* error reading from file:%s */

-	EBADID,        /* incorrect symbol id */

-	EWTACKO,       /* switch stack overflow */

-	EWTACKU,       /* switch stack underflow */

-	ENOSWTC,       /* Out of switch statement */

-	EBBUILT,       /* Unknown builtin */

-	ENUMERR

-};

-

-typedef struct node Node;

-typedef struct type Type;

-typedef struct symbol Symbol;

-typedef struct addr Addr;

-typedef struct inst Inst;

-

-struct type {

-	unsigned long size;

-	unsigned long align;

-	short flags;

-};

-

-struct symbol {

-	Type type;

-	Type rtype;

-	unsigned short id;

-	unsigned short numid;

-	char *name;

-	char kind;

-	union {

-		unsigned long off;

-		Node *stmt;

-		Inst *inst;

-	} u;

-	Symbol *next;

-	Symbol *h_next;

-};

-

-struct node {

-	char op;

-	Type type;

-	char complex;

-	char address;

-	unsigned char flags;

-	union {

-		TUINT i;

-		TFLOAT f;

-		char reg;

-		char *s;

-		Symbol *sym;

-		char subop;

-	} u;

-	Symbol *label;

-	Node *left, *right;

-	Node *next, *prev;

-};

-

-struct addr {

-        char kind;

-        union {

-                char reg;

-                TUINT i;

-                Symbol *sym;

-        } u;

-};

-

-struct inst {

-	unsigned char op;

-	unsigned char flags;

-	Symbol *label;

-	Inst *next, *prev;

-	Addr from1, from2, to;

-};

-

-/* main.c */

-extern void error(unsigned nerror, ...);

-

-/* parse.c */

-extern void parse(void);

-

-/* optm.c */

-extern Node *optm_dep(Node *np), *optm_ind(Node *np);

-

-/* cgen.c */

-extern Node *sethi(Node *np);

-extern Node *cgen(Node *np);

-

-/* peep.c */

-extern void peephole(void);

-

-/* code.c */

-extern void data(Node *np);

-extern void writeout(void), endinit(void), newfun(void);

-extern void code(int op, Node *to, Node *from1, Node *from2);

-extern void defvar(Symbol *), defpar(Symbol *), defglobal(Symbol *);

-extern void setlabel(Symbol *sym), getbblocks(void);

-extern Node *label2node(Node *np, Symbol *sym);

-extern Node *constnode(Node *np, TUINT n, Type *tp);

-extern Symbol *newlabel(void);

-

-/* node.c */

-#define SETCUR  1

-#define KEEPCUR 0

-extern void apply(Node *(*fun)(Node *));

-extern void cleannodes(void);

-extern void delnode(Node *np);

-extern void deltree(Node *np);

-extern void prtree(Node *np), prforest(char *msg);

-extern Node *node(int op);

-extern Node *addstmt(Node *np, int flags);

-extern Node *delstmt(void);

-extern Node *nextstmt(void);

-

-/* symbol.c */

-#define TMPSYM  0

-extern Symbol *getsym(unsigned id);

-extern void popctx(void);

-extern void pushctx(void);

-extern void freesym(Symbol *sym);

-

-/* globals */

-extern Symbol *curfun;

-extern Symbol *locals;

-extern Inst *pc, *prog;

--- a/src/cmd/cc2/code.c

+++ /dev/null

@@ -1,133 +1,0 @@

-static char sccsid[] = "@(#) ./cc2/code.c";

-#include <stdlib.h>

-#include <string.h>

-

-#include <scc/scc.h>

-#include "cc2.h"

-

-Inst *pc, *prog;

-

-static void

-nextpc(void)

-{

-        Inst *new;

-

-        new = xcalloc(1, sizeof(*new)); /* TODO: create an arena */

-

-        if (!pc) {

-                prog = new;

-        } else {

-                new->next = pc->next;

-                pc->next = new;

-        }

-

-	/* SNONE being 0, calloc initialized {from1,from2,to}.kind for us */

-        new->prev = pc;

-        pc = new;

-}

-

-static void

-addr(Node *np, Addr *addr)

-{

-	Symbol *sym;

-

-	switch (np->op) {

-	case OREG:

-		/* TODO:

-		 * At this moment this op is used also for register variables

-		 */

-		addr->kind = SREG;

-		addr->u.reg = np->u.reg;

-		break;

-	case OCONST:

-		addr->kind = SCONST;

-		/* TODO: Add support for more type of constants */

-		addr->u.i = np->u.i;

-		break;

-	case OTMP:

-	case OLABEL:

-	case OAUTO:

-	case OMEM:

-		sym = np->u.sym;

-		addr->kind = sym->kind;

-		addr->u.sym = sym;

-		break;

-	default:

-		abort();

-	}

-}

-

-Symbol *

-newlabel(void)

-{

-	Symbol *sym = getsym(TMPSYM);

-

-	sym->kind = SLABEL;

-	return sym;

-}

-

-Node *

-label2node(Node *np, Symbol *sym)

-{

-	if(!sym)

-		sym = newlabel();

-	if (!np)

-		np = node(OLABEL);

-	np->op = OLABEL;

-	np->u.sym = sym;

-

-	return np;

-}

-

-Node *

-constnode(Node *np, TUINT n, Type *tp)

-{

-	if (!np)

-		np = node(OCONST);

-	np->op = OCONST;

-	np->left = NULL;

-	np->right = NULL;

-	np->type = *tp;

-	np->u.i = n;

-	return np;

-}

-

-void

-setlabel(Symbol *sym)

-{

-	if (!sym)

-		return;

-	code(0, NULL, NULL, NULL);

-	pc->label = sym;

-	sym->u.inst = pc;

-}

-

-void

-code(int op, Node *to, Node *from1, Node *from2)

-{

-	nextpc();

-	if (from1)

-		addr(from1, &pc->from1);

-	if (from2)

-		addr(from2, &pc->from2);

-	if (to)

-		addr(to, &pc->to);

-	pc->op = op;

-}

-

-void

-delcode(void)

-{

-        Inst *prev = pc->prev, *next = pc->next;

-

-        free(pc);

-        if (!prev) {

-                pc = next;

-                prog = NULL;

-        } else {

-                pc = prev;

-                prev->next = next;

-                if (next)

-                        next->prev = prev;

-        }

-}

--- a/src/cmd/cc2/deps.mk

+++ /dev/null

@@ -1,61 +1,0 @@

-#deps

-code.o: $(INCDIR)/scc/scc/scc.h

-code.o: cc2.h

-main.o: $(INCDIR)/scc/scc/arg.h

-main.o: $(INCDIR)/scc/scc/scc.h

-main.o: cc2.h

-main.o: error.h

-node.o: $(INCDIR)/scc/scc/scc.h

-node.o: cc2.h

-optm.o: $(INCDIR)/scc/scc/scc.h

-optm.o: cc2.h

-parser.o: $(INCDIR)/scc/scc/cstd.h

-parser.o: $(INCDIR)/scc/scc/scc.h

-parser.o: cc2.h

-peep.o: $(INCDIR)/scc/scc/scc.h

-peep.o: cc2.h

-symbol.o: $(INCDIR)/scc/scc/scc.h

-symbol.o: cc2.h

-target/amd64-sysv/cgen.o: $(INCDIR)/scc/scc/scc.h

-target/amd64-sysv/cgen.o: target/amd64-sysv/../../cc2.h

-target/amd64-sysv/cgen.o: target/amd64-sysv/arch.h

-target/amd64-sysv/code.o: $(INCDIR)/scc/scc/cstd.h

-target/amd64-sysv/code.o: $(INCDIR)/scc/scc/scc.h

-target/amd64-sysv/code.o: target/amd64-sysv/../../cc2.h

-target/amd64-sysv/code.o: target/amd64-sysv/arch.h

-target/amd64-sysv/optm.o: $(INCDIR)/scc/scc/scc.h

-target/amd64-sysv/optm.o: target/amd64-sysv/../../cc2.h

-target/amd64-sysv/types.o: $(INCDIR)/scc/scc/scc.h

-target/amd64-sysv/types.o: target/amd64-sysv/../../cc2.h

-target/i386-sysv/cgen.o: $(INCDIR)/scc/scc/scc.h

-target/i386-sysv/cgen.o: target/i386-sysv/../../cc2.h

-target/i386-sysv/cgen.o: target/i386-sysv/arch.h

-target/i386-sysv/code.o: $(INCDIR)/scc/scc/cstd.h

-target/i386-sysv/code.o: $(INCDIR)/scc/scc/scc.h

-target/i386-sysv/code.o: target/i386-sysv/../../cc2.h

-target/i386-sysv/code.o: target/i386-sysv/arch.h

-target/i386-sysv/optm.o: $(INCDIR)/scc/scc/scc.h

-target/i386-sysv/optm.o: target/i386-sysv/../../cc2.h

-target/i386-sysv/types.o: $(INCDIR)/scc/scc/scc.h

-target/i386-sysv/types.o: target/i386-sysv/../../cc2.h

-target/qbe/cgen.o: $(INCDIR)/scc/scc/cstd.h

-target/qbe/cgen.o: $(INCDIR)/scc/scc/scc.h

-target/qbe/cgen.o: target/qbe/../../cc2.h

-target/qbe/cgen.o: target/qbe/arch.h

-target/qbe/code.o: $(INCDIR)/scc/scc/cstd.h

-target/qbe/code.o: $(INCDIR)/scc/scc/scc.h

-target/qbe/code.o: target/qbe/../../cc2.h

-target/qbe/code.o: target/qbe/arch.h

-target/qbe/optm.o: $(INCDIR)/scc/scc/scc.h

-target/qbe/optm.o: target/qbe/../../cc2.h

-target/z80-scc/cgen.o: $(INCDIR)/scc/scc/scc.h

-target/z80-scc/cgen.o: target/z80-scc/../../cc2.h

-target/z80-scc/cgen.o: target/z80-scc/arch.h

-target/z80-scc/code.o: $(INCDIR)/scc/scc/cstd.h

-target/z80-scc/code.o: $(INCDIR)/scc/scc/scc.h

-target/z80-scc/code.o: target/z80-scc/../../cc2.h

-target/z80-scc/code.o: target/z80-scc/arch.h

-target/z80-scc/optm.o: $(INCDIR)/scc/scc/scc.h

-target/z80-scc/optm.o: target/z80-scc/../../cc2.h

-target/z80-scc/types.o: $(INCDIR)/scc/scc/scc.h

-target/z80-scc/types.o: target/z80-scc/../../cc2.h

--- a/src/cmd/cc2/generror.awk

+++ /dev/null

@@ -1,9 +1,0 @@

-/^enum nerrors \{/     {print "char *errlist[] = {"; inhome = 1}

-

-inhome && /E[A-Z]*, /  {sub(/,/, "", $1)

-                        printf("\t[%s] = \"", $1)

-                        for (i = 3; i <= NF-1; ++i)

-				printf("%s%s", $i, (i == NF-1) ? "\"" : " ")

-			print ","}

-

-inhome && /^}/          {print "};" ; inhome = 0}

--- a/src/cmd/cc2/main.c

+++ /dev/null

@@ -1,70 +1,0 @@

-static char sccsid[] = "@(#) ./cc2/main.c";

-

-#include <errno.h>

-#include <stdarg.h>

-#include <stdio.h>

-#include <stdlib.h>

-#include <string.h>

-

-#include <scc/arg.h>

-#include <scc/scc.h>

-#include "cc2.h"

-#include "error.h"

-

-char *argv0;

-

-void

-error(unsigned nerror, ...)

-{

-	va_list va;

-	va_start(va, nerror);

-	vfprintf(stderr, errlist[nerror], va);

-	va_end(va);

-	putc('\n', stderr);

-	exit(1);

-}

-

-static int

-moreinput(void)

-{

-	int c;

-

-repeat:

-	if (feof(stdin))

-		return 0;

-	if ((c = getchar()) == '\n' || c == EOF)

-		goto repeat;

-	ungetc(c, stdin);

-	return 1;

-}

-

-static void

-usage(void)

-{

-	fputs("usage: cc2 [irfile]\n", stderr);

-	exit(1);

-}

-

-int

-main(int argc, char *argv[])

-{

-	ARGBEGIN {

-	default:

-		usage();

-	} ARGEND

-

-	if (argv[0] && !freopen(argv[0], "r", stdin))

-		die("cc2: %s: %s", argv[0], strerror(errno));

-

-	while (moreinput()) {

-		parse();

-		apply(optm_ind);

-		apply(optm_dep);

-		apply(sethi);

-		apply(cgen);

-		getbblocks();  /* TODO: run apply over asm ins too */

-		peephole();

-		writeout();

-	}

-	return 0;

-}

--- a/src/cmd/cc2/node.c

+++ /dev/null

@@ -1,142 +1,0 @@

-static char sccsid[] = "@(#) ./cc2/node.c";

-#include <stdlib.h>

-#include <string.h>

-

-#include <scc/scc.h>

-

-#include "cc2.h"

-

-#define NNODES   32

-

-Node *curstmt;

-Symbol *curfun;

-

-static Alloc *arena;

-

-

-Node *

-node(int op)

-{

-	struct arena *ap;

-	Node *np;

-

-	if (!arena)

-		arena = alloc(sizeof(Node), NNODES);

-	np = memset(new(arena), 0, sizeof(*np));

-	np->op = op;

-

-	return np;

-}

-

-#ifndef NDEBUG

-#include <stdio.h>

-

-static void

-prnode(Node *np)

-{

-	if (np->left)

-		prnode(np->left);

-	if (np->right)

-		prnode(np->right);

-	fprintf(stderr, "\t%c%lu", np->op, np->type.size);

-}

-

-void

-prtree(Node *np)

-{

-	prnode(np);

-	putc('\n', stderr);

-}

-

-void

-prforest(char *msg)

-{

-	Node *np;

-

-	if (!curfun)

-		return;

-

-	fprintf(stderr, "%s {\n", msg);

-	for (np = curfun->u.stmt; np; np = np->next)

-		prtree(np);

-	fputs("}\n", stderr);

-}

-#endif

-

-Node *

-addstmt(Node *np, int flag)

-{

-	if (curstmt)

-		np->next = curstmt->next;

-	np->prev = curstmt;

-

-	if (!curfun->u.stmt)

-		curfun->u.stmt = np;

-	else

-		curstmt->next = np;

-

-	if (flag == SETCUR)

-		curstmt = np;

-

-	return np;

-}

-

-Node *

-delstmt(void)

-{

-	Node *next, *prev;

-

-	next = curstmt->next;

-	prev = curstmt->prev;

-	if (next)

-		next->prev = prev;

-	if (prev)

-		prev->next = next;

-	else

-		curfun->u.stmt = next;

-	deltree(curstmt);

-

-	return curstmt = next;

-}

-

-Node *

-nextstmt(void)

-{

-	return curstmt = curstmt->next;

-}

-

-void

-delnode(Node *np)

-{

-	delete(arena, np);

-}

-

-void

-deltree(Node *np)

-{

-	if (!np)

-		return;

-	deltree(np->left);

-	deltree(np->right);

-	delnode(np);

-}

-

-void

-cleannodes(void)

-{

-	if (arena) {

-		dealloc(arena);

-		arena = NULL;

-	}

-	curstmt = NULL;

-}

-

-void

-apply(Node *(*fun)(Node *))

-{

-	if (!curfun)

-		return;

-	curstmt = curfun->u.stmt;

-	while (curstmt)

-		(*fun)(curstmt) ? nextstmt() : delstmt();

-}

--- a/src/cmd/cc2/optm.c

+++ /dev/null

@@ -1,9 +1,0 @@

-#include <scc/scc.h>

-#include "cc2.h"

-

-Node *

-optm_ind(Node *np)

-{

-	return np;

-}

-

--- a/src/cmd/cc2/parser.c

+++ /dev/null

@@ -1,722 +1,0 @@

-static char sccsid[] = "@(#) ./cc2/parser.c";

-#include <errno.h>

-#include <stdio.h>

-#include <stdlib.h>

-#include <string.h>

-

-#include <scc/cstd.h>

-#include <scc/scc.h>

-

-#include "cc2.h"

-

-#define STACKSIZ     50

-

-extern Type int8type, int16type, int32type, int64type,

-            uint8type, uint16type, uint32type, uint64type,

-            float32type, float64type, float80type,

-            booltype,

-            ptrtype,

-            voidtype,

-            arg_type;

-

-Type funetype = {

-	.flags = FUNF | ELLIPS

-};

-

-Type funtype = {

-	.flags = FUNF

-};

-

-union tokenop {

-	void *arg;

-	unsigned op;

-};

-

-struct swtch {

-	int nr;

-	Node *first;

-	Node *last;

-};

-

-static struct swtch swtbl[NR_BLOCK], *swp = swtbl;

-static Symbol *lastfun;

-

-typedef void parsefun(char *, union tokenop);

-static parsefun type, symbol, getname, unary, binary, ternary, call,

-                constant, composed, binit, einit,

-                jump, oreturn, loop, assign,

-                ocase, bswitch, eswitch, builtin;

-

-typedef void evalfun(void);

-static evalfun vardecl, beginfun, endfun, endpars, stmt,

-               array, aggregate, flddecl, labeldcl;

-

-static struct decoc {

-	void (*eval)(void);

-	void (*parse)(char *token, union tokenop);

-	union tokenop u;

-} optbl[] = {      /*  eval     parse           args */

-	['A']   = {  vardecl,  symbol, .u.op  =  SAUTO<<8 | OAUTO},

-	['R']   = {  vardecl,  symbol, .u.op  =   SREG<<8 |  OREG},

-	['G']   = {  vardecl,  symbol, .u.op  =  SGLOB<<8 |  OMEM},

-	['X']   = {  vardecl,  symbol, .u.op  = SEXTRN<<8 |  OMEM},

-	['Y']   = {  vardecl,  symbol, .u.op  =  SPRIV<<8 |  OMEM},

-	['T']   = {  vardecl,  symbol, .u.op  = SLOCAL<<8 |  OMEM},

-	['M']   = {  flddecl,  symbol, .u.op  =  SMEMB<<8 |  OMEM},

-	['L']   = { labeldcl,  symbol, .u.op  = SLABEL<<8 | OLABEL},

-

-	['C']   = {     NULL,    type, .u.arg =    &int8type},

-	['I']   = {     NULL,    type, .u.arg =   &int16type},

-	['W']   = {     NULL,    type, .u.arg =   &int32type},

-	['Q']   = {     NULL,    type, .u.arg =   &int64type},

-	['K']   = {     NULL,    type, .u.arg =   &uint8type},

-	['N']   = {     NULL,    type, .u.arg =  &uint16type},

-	['Z']   = {     NULL,    type, .u.arg =  &uint32type},

-	['O']   = {     NULL,    type, .u.arg =  &uint64type},

-	['J']   = {     NULL,    type, .u.arg = &float32type},

-	['D']   = {     NULL,    type, .u.arg = &float64type},

-	['H']   = {     NULL,    type, .u.arg = &float80type},

-	['0']   = {     NULL,    type, .u.arg =    &voidtype},

-	['B']   = {     NULL,    type, .u.arg =    &booltype},

-	['P']   = {     NULL,    type, .u.arg =     &ptrtype},

-	['E']   = {     NULL,    type, .u.arg =    &funetype},

-	['1']	= {     NULL,    type, .u.arg =    &arg_type},

-

-	['F']   = {     NULL,    type, .u.arg =     &funtype},

-	['V']   = {    array,composed,                     0},

-	['U']   = {aggregate,composed,                     0},

-	['S']   = {aggregate,composed,                     0},

-

-	['"']   = {     NULL, getname,                     0},

-	['{']   = { beginfun,    NULL,                     0},

-	['}']   = {   endfun,    NULL,                     0},

-	['(']   = {     NULL,   binit,                     0},

-	[')']   = {     NULL,   einit,                     0},

-	['\\']  = {  endpars,    NULL,                     0},

-	['\t']  = {     stmt,    NULL,                     0},

-

-	['~']   = {     NULL,   unary, .u.op =          OCPL},

-	['_']   = {     NULL,   unary, .u.op =         OSNEG},

-	['\'']  = {     NULL,   unary, .u.op =         OADDR},

-	['@']   = {     NULL,   unary, .u.op =          OPTR},

-	['g']   = {     NULL,   unary, .u.op =         OCAST},

-	['p']   = {     NULL,   unary, .u.op =          OPAR},

-	['n']   = {     NULL,   unary, .u.op =          ONEG},

-

-	['a']   = {     NULL,  binary, .u.op =          OAND},

-	['o']   = {     NULL,  binary, .u.op =           OOR},

-	['.']   = {     NULL,  binary, .u.op =        OFIELD},

-	['+']   = {     NULL,  binary, .u.op =          OADD},

-	['-']   = {     NULL,  binary, .u.op =          OSUB},

-	['*']   = {     NULL,  binary, .u.op =          OMUL},

-	['%']   = {     NULL,  binary, .u.op =          OMOD},

-	['/']   = {     NULL,  binary, .u.op =          ODIV},

-	['l']   = {     NULL,  binary, .u.op =          OSHL},

-	['r']   = {     NULL,  binary, .u.op =          OSHR},

-	['<']   = {     NULL,  binary, .u.op =           OLT},

-	['>']   = {     NULL,  binary, .u.op =           OGT},

-	['[']   = {     NULL,  binary, .u.op =           OLE},

-	[']']   = {     NULL,  binary, .u.op =           OGE},

-	['=']   = {     NULL,  binary, .u.op =           OEQ},

-	['!']   = {     NULL,  binary, .u.op =           ONE},

-	['&']   = {     NULL,  binary, .u.op =         OBAND},

-	['|']   = {     NULL,  binary, .u.op =          OBOR},

-	['^']   = {     NULL,  binary, .u.op =         OBXOR},

-	[',']   = {     NULL,  binary, .u.op =        OCOMMA},

-	['m']   = {     NULL,  builtin,.u.op =      OBUILTIN},

-

-	[':']   = {     NULL,  assign, .u.op =        OASSIG},

-	['?']   = {     NULL, ternary, .u.op =          OASK},

-	['c']   = {     NULL,    call, .u.op =         OCALL},

-	['z']   = {     NULL,    call, .u.op =        OCALLE},

-

-	['#']   = {     NULL,constant, .u.op =        OCONST},

-

-	['j']   = {     NULL,    jump, .u.op =          OJMP},

-	['y']   = {     NULL,    jump, .u.op =       OBRANCH},

-	['h']   = {     NULL, oreturn, .u.op =          ORET},

-	['i']   = {     NULL,    NULL, .u.op =          OINC},

-	['d']   = {     NULL,    NULL, .u.op =          ODEC},

-

-	['b']   = {     NULL,    loop, .u.op =        OBLOOP},

-	['e']   = {     NULL,    loop, .u.op =        OELOOP},

-

-	['v']   = {     NULL,   ocase, .u.op =         OCASE},

-	['f']   = {     NULL,   ocase, .u.op =      ODEFAULT},

-	['t']   = {     NULL, eswitch, .u.op =      OESWITCH},

-	['s']   = {     NULL, bswitch, .u.op =      OBSWITCH},

-};

-

-static int sclass, inpars, ininit, endf, lineno;

-static void *stack[STACKSIZ], **sp = stack;

-

-static Node *

-push(void *elem)

-{

-	if (sp == &stack[STACKSIZ])

-		error(ESTACKO);

-	return *sp++ = elem;

-}

-

-static void *

-pop(void)

-{

-	if (sp == stack)

-		error(ESTACKU);

-	return *--sp;

-}

-

-static int

-empty(void)

-{

-	return sp == stack;

-}

-

-static void

-type(char *token, union tokenop u)

-{

-	push(u.arg);

-}

-

-static void

-composed(char *token, union tokenop u)

-{

-	Symbol *sym;

-

-	sym = getsym(atoi(token+1));

-	push(&sym->type);

-}

-

-static void

-getname(char *t, union tokenop u)

-{

-	push((*++t) ? xstrdup(t) : NULL);

-}

-

-static void

-symbol(char *token, union tokenop u)

-{

-	Node *np = node(u.op & 0xFF);

-	Symbol *sym = getsym(atoi(token+1));

-

-	sclass = u.op >> 8;

-	np->u.sym = sym;

-	np->type = sym->type;

-	push(np);

-}

-

-static Type *

-gettype(char *token)

-{

-	struct decoc *dp;

-

-	dp = &optbl[*token];

-	if (!dp->parse)

-		error(ESYNTAX);

-	(*dp->parse)(token, dp->u);

-	return pop();

-}

-

-static void

-constant(char *token, union tokenop u)

-{

-	static char letters[] = "0123456789ABCDEF";

-	Node *np;

-	TUINT v;

-	unsigned c;

-

-	++token;

-	if (*token == '"') {

-		++token;

-		np = node(OSTRING);

-		np->type.flags = STRF;

-		np->type.size = strlen(token);

-		np->type.align = int8type.align;

-		np->u.s = xstrdup(token);

-	} else {

-		np = node(OCONST);

-		np->type = *gettype(token++);

-		for (v = 0; c = *token++; v += c) {

-			v <<= 4;

-			c = strchr(letters, c) - letters;

-		}

-		np->u.i = v;

-	}

-	push(np);

-}

-

-static void

-assign(char *token, union tokenop u)

-{

-	int subop;

-	Node *np = node(u.op);

-

-	switch (subop = *++token) {

-	case '+':

-	case '-':

-	case '*':

-	case '%':

-	case '/':

-	case 'l':

-	case 'r':

-	case '&':

-	case '|':

-	case '^':

-	case 'i':

-	case 'd':

-		++token;

-		subop = optbl[subop].u.op;

-		break;

-	default:

-		subop = 0;

-		break;

-	}

-

-	np->u.subop = subop;

-	np->type = *gettype(token);

-	np->right = pop();

-	np->left = pop();

-	push(np);

-}

-

-static void

-ternary(char *token, union tokenop u)

-{

-	Node *ask = node(OASK), *colon = node(OCOLON);

-	Type *tp = gettype(token+1);

-

-	colon->right = pop();

-	colon->left = pop();

-

-	ask->type = *tp;

-	ask->left = pop();

-	ask->right = colon;

-	push(ask);

-}

-

-static void

-eval(char *tok)

-{

-	struct decoc *dp;

-

-	do {

-		dp = &optbl[*tok];

-		if (!dp->parse)

-			break;

-		(*dp->parse)(tok, dp->u);

-	} while (tok = strtok(NULL, "\t\n"));

-}

-

-static int

-nextline(void)

-{

-	static char line[LINESIZ];

-	size_t len;

-	int c;

-	void (*fun)(void);

-

-repeat:

-	++lineno;

-	if (!fgets(line, sizeof(line), stdin))

-		return 0;

-	if ((len = strlen(line)) == 0 || line[0] == '\n')

-		goto repeat;

-	if (line[len-1] != '\n')

-		error(len < sizeof(line)-1 ? ELNBLNE : ELNLINE);

-	line[len-1] = '\0';

-

-	c = *line;

-	eval(strtok(line, "\t\n"));

-	if ((fun = *optbl[c].eval) != NULL)

-		(*fun)();

-	if (sp != stack)

-		error(ESTACKA);

-	return 1;

-}

-

-static void

-oreturn(char *token, union tokenop u)

-{

-	Node *np = node(u.op);

-

-	if (token = strtok(NULL, "\t\n"))

-		eval(token);

-	if (!empty())

-		np->left = pop();

-	push(np);

-}

-

-/*

- * Move np (which is a OCASE/ODEFAULT/OESWITCH) to be contigous with

- * the last switch table. It is a bit ugly to touch directly curstmt

- * here, but moving this function to node.c is worse, because we are

- * putting knowledge of how the text is parsed into the node

- * represtation module.

- */

-static void

-waft(Node *np)

-{

-	Node *lastcase, *next;;

-	struct swtch *cur;

-	extern Node *curstmt;

-

-	if (swp == swtbl)

-		error(EWTACKU);

-

-	cur = swp - 1;

-	lastcase = cur->last;

-	next = lastcase->next;

-

-	np->next = next;

-	np->prev = lastcase;

-

-	if (next)

-		next->prev = np;

-	lastcase->next = np;

-

-	if (curstmt == cur->last)

-		curstmt = np;

-	cur->last = np;

-	cur->nr++;

-}

-

-static void

-bswitch(char *token, union tokenop u)

-{

-	struct swtch *cur;

-	Node *np = node(u.op);

-

-	if (swp == &swtbl[NR_BLOCK])

-		error(EWTACKO);

-	cur = swp++;

-	cur->nr = 0;

-

-	eval(strtok(NULL, "\t\n"));

-	np->left = pop();

-

-	push(cur->first = cur->last = np);

-}

-

-static void

-eswitch(char *token, union tokenop u)

-{

-	struct swtch *cur;

-

-	if (swp == swtbl)

-		error(EWTACKU);

-	jump(token, u);

-	waft(pop());

-	cur = --swp;

-	cur->first->u.i = cur->nr;

-}

-

-static void

-ocase(char *token, union tokenop u)

-{

-	jump(token, u);

-	waft(pop());

-}

-

-static void

-jump(char *token, union tokenop u)

-{

-	Node *aux, *np = node(u.op);

-

-	eval(strtok(NULL, "\t\n"));

-

-	if (u.op == OBRANCH || u.op == OCASE)

-		np->left = pop();

-	aux = pop();

-	np->u.sym = aux->u.sym;

-	delnode(aux);

-	push(np);

-}

-

-static void

-loop(char *token, union tokenop u)

-{

-	push(node(u.op));

-}

-

-static void

-unary(char *token, union tokenop u)

-{

-	Node *np = node(u.op);

-

-	np->type = *gettype(token+1);

-	np->left = pop();

-	np->right = NULL;

-	push(np);

-}

-

-static void

-call(char *token, union tokenop u)

-{

-	Node *np, *par, *fun = node(u.op);

-

-	for (par = NULL;; par = np) {

-		np = pop();

-		if (np->op != OPAR)

-			break;

-		np->right = par;

-	}

-

-	fun->type = *gettype(token+1);

-	fun->left = np;

-	fun->right = par;

-	push(fun);

-}

-

-static void

-builtin(char *token, union tokenop u)

-{

-	Node *np = node(u.op);

-	char *name;

-	unsigned subop, nchilds;

-

-	np->type = *gettype(token+1);

-	name = pop();

-

-	if (!strcmp("__builtin_va_arg", name)) {

-		nchilds = 1;

-		subop = BVA_ARG;

-	} else if (!strcmp("__builtin_va_start", name)) {

-		nchilds = 2;

-		subop = BVA_START;

-	} else if (!strcmp("__builtin_va_end", name)) {

-		nchilds = 1;

-		subop = BVA_END;

-	} else if (!strcmp("__builtin_va_copy", name)) {

-		nchilds = 2;

-		subop = BVA_COPY;

-	} else {

-		error(EBBUILT);;

-	}

-

-	np->u.subop = subop;

-	np->right = (nchilds == 2) ? pop() : NULL;

-	np->left = (nchilds != 0) ? pop() : NULL;

-

-	free(name);

-	push(np);

-}

-

-static void

-binary(char *token, union tokenop u)

-{

-	Node *np = node(u.op);

-

-	np->type = *gettype(token+1);

-	np->right = pop();

-	np->left = pop();

-	push(np);

-}

-

-static void

-binit(char *token, union tokenop u)

-{

-	ininit = 1;

-}

-

-static void

-einit(char *token, union tokenop u)

-{

-	ininit = 0;

-	endinit();

-}

-

-static void

-endpars(void)

-{

-	if (!curfun || !inpars)

-		error(ESYNTAX);

-	inpars = 0;

-}

-

-static void

-aggregate(void)

-{

-	Node *align, *size;

-	char *name;

-	Type *tp;

-	Symbol *sym;

-

-	align = pop();

-	size = pop();

-	name = pop();

-	tp = pop();

-

-	tp->size = size->u.i;

-	tp->align = align->u.i;

-	tp->flags = AGGRF;

-	/*

-	 * type is the first field of Symbol so we can obtain the

-	 * address of the symbol from the address of the type.

-	 * We have to do this because composed returns the pointer

-	 * to the type, but in this function we also need the

-	 * symbol to store the name.

-	 */

-	sym = (Symbol *) tp;

-	sym->name = name;

-

-	delnode(align);

-	delnode(size);

-}

-

-static void

-array(void)

-{

-	Type *tp, *base;

-	Node *size;

-

-	size = pop();

-	base = pop();

-	tp = pop();

-	tp->size = size->u.i * base->size; /* FIXME check for overflow */

-	tp->align = base->align;

-

-	delnode(size);

-}

-

-static void

-decl(Symbol *sym)

-{

-	Type *tp = &sym->type;

-

-	if (tp->flags & FUNF) {

-		lastfun = sym;

-	} else {

-		switch (sym->kind) {

-		case SEXTRN:

-		case SGLOB:

-		case SPRIV:

-		case SLOCAL:

-			defglobal(sym);

-			break;

-		case SAUTO:

-		case SREG:

-			if (!curfun)

-				error(ESYNTAX);

-			((inpars) ? defpar : defvar)(sym);

-			break;

-		default:

-			abort();

-		}

-	}

-}

-

-static void

-vardecl(void)

-{

-	Type *tp, *rp;

-	Node *np;

-	Symbol *sym;

-	char *name;

-

-	name = pop();

-	tp = pop();

-	if (tp->flags & FUNF)

-		rp = pop();

-	np = pop();

-

-	sym = np->u.sym;

-	/*

-	 * We have to free sym->name because in tentative declarations

-	 * we can have multiple declarations of the same symbol, and in

-	 * this case our parser will allocate twice the memory

-	 */

-	free(sym->name);

-	sym->name = name;

-	sym->type = *tp;

-	if (tp->flags & FUNF)

-		sym->rtype = *rp;

-	sym->kind = sclass;

-

-	if (ininit)

-		sym->type.flags |= INITF;

-	decl(sym);

-	delnode(np);

-}

-

-static void

-flddecl(void)

-{

-	Node *off, *np;

-	char *name;

-	Type *tp;

-	Symbol *sym;

-

-	off = pop();

-	name = pop();

-	tp = pop();

-	np = pop();

-

-	sym = np->u.sym;

-	sym->u.off = off->u.i;

-	sym->name = name;

-	sym->type = *tp;

-

-	delnode(np);

-	delnode(off);

-}

-

-static void

-labeldcl(void)

-{

-	Node *np;

-	Symbol *sym;

-

-	np = pop();

-	np->op = ONOP;

-	sym = np->u.sym;

-	sym->kind = SLABEL;

-	sym->u.stmt = np;

-	np->label = sym;

-	addstmt(np, SETCUR);

-}

-

-static void

-stmt(void)

-{

-	Node *np;

-

-	if (empty())

-		return;

-	np = pop();

-	if (ininit) {

-		data(np);

-		deltree(np);

-		return;

-	}

-	addstmt(np, SETCUR);

-}

-

-static void

-beginfun(void)

-{

-	curfun = lastfun;

-	inpars = 1;

-	pushctx();

-	addstmt(node(OBFUN), SETCUR);

-}

-

-static void

-endfun(void)

-{

-	endf = 1;

-	addstmt(node(OEFUN), SETCUR);

-}

-

-void

-parse(void)

-{

-	cleannodes();  /* remove code of previous function */

-	popctx();  /* remove context of previous function */

-	curfun = NULL;

-	endf = 0;

-

-	while (!endf && nextline())

-		;

-	if (ferror(stdin))

-		error(EFERROR, strerror(errno));

-}

--- a/src/cmd/cc2/peep.c

+++ /dev/null

@@ -1,8 +1,0 @@

-static char sccsid[] = "@(#) ./cc2/peep.c";

-#include <scc/scc.h>

-#include "cc2.h"

-

-void

-peephole(void)

-{

-}

--- a/src/cmd/cc2/symbol.c

+++ /dev/null

@@ -1,92 +1,0 @@

-static char sccsid[] = "@(#) ./cc2/symbol.c";

-#include <limits.h>

-#include <stdio.h>

-#include <stdlib.h>

-#include <string.h>

-

-#include <scc/scc.h>

-

-#include "cc2.h"

-

-#define NR_SYMHASH  64

-

-Symbol *locals;

-

-static Symbol *symtab[NR_SYMHASH], *curlocal;

-static int infunction;

-

-

-void

-freesym(Symbol *sym)

-{

-	free(sym->name);

-	free(sym);

-}

-

-void

-pushctx(void)

-{

-	infunction = 1;

-}

-

-void

-popctx(void)

-{

-	Symbol *sym, *next;

-

-	infunction = 0;

-	for (sym = locals; sym; sym = next) {

-		next = sym->next;

-		/*

-		 * Symbols are inserted in the hash in the inverted

-		 * order they are found in locals and it is impossible

-		 * to have a global over a local, because a local is

-		 * any symbol defined in the body of a function,

-		 * even if it has extern linkage.

-		 * For this reason when we reach a symbol in the

-		 * locals list we know that it is the head of it

-		 * collision list and we can remove it assigning

-		 * it h_next to the hash table position

-		 */

-		if (sym->id != TMPSYM)

-			symtab[sym->id & NR_SYMHASH-1] = sym->h_next;

-		freesym(sym);

-	}

-	curlocal = locals = NULL;

-}

-

-Symbol *

-getsym(unsigned id)

-{

-	Symbol **htab, *sym;

-	static unsigned short num;

-

-	if (id >= USHRT_MAX)

-		error(EBADID);

-

-	if (id != TMPSYM) {

-		htab = &symtab[id & NR_SYMHASH-1];

-		for (sym = *htab; sym; sym = sym->h_next) {

-			if (sym->id == id)

-				return sym;

-		}

-	}

-

-	sym = xcalloc(1, sizeof(*sym));

-	sym->id = id;

-	if (infunction) {

-		if (!locals)

-			locals = sym;

-		if (curlocal)

-			curlocal->next = sym;

-		curlocal = sym;

-	}

-	if (id != TMPSYM) {

-		sym->h_next = *htab;

-		*htab = sym;

-	}

-	if ((sym->numid = ++num) == 0)

-		error(EIDOVER);

-

-	return sym;

-}

--- a/src/cmd/cc2/target/amd64-sysv/cgen.c

+++ /dev/null

@@ -1,15 +1,0 @@

-static char sccsid[] = "@(#) ./cc2/arch/amd64-sysv/cgen.c";

-

-#include "arch.h"

-#include <scc/scc.h>

-#include "../../cc2.h"

-

-Node *

-cgen(Node *np)

-{

-}

-

-Node *

-sethi(Node *np)

-{

-}

--- a/src/cmd/cc2/target/amd64-sysv/code.c

+++ /dev/null

@@ -1,211 +1,0 @@

-static char sccsid[] = "@(#) ./cc2/arch/amd64-sysv/code.c";

-

-#include <stdio.h>

-#include <stdlib.h>

-

-#include <scc/cstd.h>

-#include <scc/scc.h>

-

-#include "arch.h"

-#include "../../cc2.h"

-

-enum segment {

-	CODESEG,

-	DATASEG,

-	BSSSEG,

-	NOSEG

-};

-

-static int curseg = NOSEG;

-

-static void

-segment(int seg)

-{

-	static char *txt[] = {

-		[CODESEG] = "\t.text\n",

-		[DATASEG] = "\t.data\n",

-		[BSSSEG] = "\t.bss\n",

-	};

-

-	if (seg == curseg)

-		return;

-	fputs(txt[seg], stdout);

-	curseg = seg;

-}

-

-static char *

-symname(Symbol *sym)

-{

-	static char name[INTIDENTSIZ+1];

-

-	if (sym->name) {

-		switch (sym->kind) {

-		case SEXTRN:

-		case SGLOB:

-		case SPRIV:

-			return sym->name;

-		}

-	}

-

-	sprintf(name, ".L%d", sym->numid);

-

-	return name;

-}

-

-static void

-emitconst(Node *np)

-{

-	switch (np->type.size) {

-	case 1:

-		printf("%d", (int) np->u.i & 0xFF);

-		break;

-	case 2:

-		printf("%d", (int) np->u.i & 0xFFFF);

-		break;

-	case 4:

-		printf("%ld", (long) np->u.i & 0xFFFFFFFF);

-		break;

-	case 8:

-		printf("%lld", (long long) np->u.i & 0xFFFFFFFF);

-		break;

-	default:

-		abort();

-	}

-}

-

-static void

-emittree(Node *np)

-{

-	if (!np)

-		return;

-

-	switch (np->op) {

-	case OSTRING:

-		printf("\"%s\"", np->u.s);

-		free(np->u.s);

-		np->u.s = NULL;

-		break;

-	case OCONST:

-		emitconst(np);

-		break;

-	case OADDR:

-		emittree(np->left);

-		break;

-	case OMEM:

-		fputs(symname(np->u.sym), stdout);

-		break;

-	default:

-		emittree(np->left);

-		printf(" %c ", np->op);

-		emittree(np->right);

-		break;

-	}

-}

-static void

-size2asm(Type *tp)

-{

-	char *s;

-

-	if (tp->flags & STRF) {

-		s = "\t.ascii\t";

-	} else {

-		switch (tp->size) {

-		case 1:

-			s = "\t.byte\t";

-			break;

-		case 2:

-			s = "\t.short\t";

-			break;

-		case 4:

-			s = "\t.long\t";

-			break;

-		case 8:

-			s = "\t.quad\t";

-			break;

-		default:

-			s = "\t.space\t%lu,";

-			break;

-		}

-	}

-	printf(s, tp->size);

-}

-

-

-void

-data(Node *np)

-{

-	size2asm(&np->type);

-	emittree(np);

-	putchar('\n');

-}

-

-static void

-label(Symbol *sym)

-{

-	int seg;

-	char *name = symname(sym);

-	Type *tp = &sym->type;

-

-	if (sym->type.flags & FUNF)

-		seg = CODESEG;

-	else if (sym->type.flags & INITF)

-		seg = DATASEG;

-	else

-		seg = BSSSEG;

-	segment(seg);

-

-	switch (sym->kind) {

-	case SEXTRN:

-		printf("\t.extern\t%s\n", name);

-	case SLOCAL:

-		return;

-	case SGLOB:

-		printf("\t.global\t%s\n", name);

-		if (seg == BSSSEG)

-			printf("\t.comm\t%s,%lu\n", name, tp->size);

-		break;

-	}

-	if (sym->type.align != 1)

-		printf("\t.align\t%lu\n", sym->type.align );

-	printf("%s:\n", name);

-}

-

-void

-defglobal(Symbol *sym)

-{

-	label(sym);

-	if (sym->kind == SEXTRN || (sym->type.flags & INITF))

-		return;

-	size2asm(&sym->type);

-	puts("0");

-}

-

-void

-defvar(Symbol *sym)

-{

-}

-

-void

-defpar(Symbol *sym)

-{

-}

-

-void

-newfun(void)

-{

-}

-

-void

-writeout(void)

-{

-}

-

-void

-endinit(void)

-{

-}

-

-void

-getbblocks(void)

-{

-}

--- a/src/cmd/cc2/target/amd64-sysv/optm.c

+++ /dev/null

@@ -1,11 +1,0 @@

-static char sccsid[] = "@(#) ./cc2/arch/amd64-sysv/optm.c";

-

-#include <scc/scc.h>

-

-#include "../../cc2.h"

-

-Node *

-optm_dep(Node *np)

-{

-	return np;

-}

--- a/src/cmd/cc2/target/amd64-sysv/target.mk

+++ /dev/null

@@ -1,8 +1,0 @@

-OBJ-amd64-sysv = $(OBJS)  \

-        target/amd64-sysv/cgen.o \

-        target/amd64-sysv/optm.o \

-        target/amd64-sysv/code.o \

-        target/amd64-sysv/types.o

-

-$(LIBEXEC)/cc2-amd64-sysv: $(OBJ-amd64-sysv)

-	$(CC) $(SCC_LDFLAGS) $(OBJ-amd64-sysv) -lscc -o $@

--- a/src/cmd/cc2/target/amd64-sysv/types.c

+++ /dev/null

@@ -1,94 +1,0 @@

-static char sccsid[] = "@(#) ./cc2/arch/amd64-sysv/types.c";

-

-#include <scc/scc.h>

-

-#include "../../cc2.h"

-

-

-Type int8type = {

-	.flags  = SIGNF | INTF,

-	.size   = 1,

-	.align  = 1

-};

-

-Type int16type = {

-	.flags  = SIGNF | INTF,

-	.size   = 2,

-	.align  = 2

-};

-

-Type int32type = {

-	.flags  = SIGNF | INTF,

-	.size   = 4,

-	.align  = 4

-};

-

-Type int64type = {

-	.flags  = SIGNF | INTF,

-	.size   = 8,

-	.align  = 8

-};

-

-Type uint8type = {

-	.flags  = INTF,

-	.size   = 1,

-	.align  = 1

-};

-

-Type uint16type = {

-	.flags  = INTF,

-	.size   = 2,

-	.align  = 2

-};

-

-Type uint32type = {

-	.flags  = INTF,

-	.size   = 4,

-	.align  = 4

-};

-

-Type uint64type = {

-	.flags  = INTF,

-	.size   = 8,

-	.align  = 2

-};

-

-Type ptrtype = {

-	.flags  = INTF,

-	.size   = 8,

-	.align  = 8

-};

-

-Type booltype = {

-	.flags  = INTF,

-	.size   = 1,

-	.align  = 1

-};

-

-Type float32type = {

-	.flags  = FLOATF,

-	.size   = 4,

-	.align  = 4

-};

-

-Type float64type = {

-	.flags  = FLOATF,

-	.size   = 8,

-	.align  = 8

-};

-

-Type float80type = {

-	.flags  = FLOATF,

-	.size   = 16,

-	.align  = 16

-};

-

-Type voidtype = {

-	.size = 0,

-	.align = 0

-};

-

-Type arg_type = {

-	.size = 24,

-	.align = 8

-};

--- a/src/cmd/cc2/target/i386-sysv/cgen.c

+++ /dev/null

@@ -1,16 +1,0 @@

-static char sccsid[] = "@(#) ./cc2/arch/i386-sysv/cgen.c";

-

-#include <scc/scc.h>

-

-#include "arch.h"

-#include "../../cc2.h"

-

-Node *

-cgen(Node *np)

-{

-}

-

-Node *

-sethi(Node *np)

-{

-}

--- a/src/cmd/cc2/target/i386-sysv/code.c

+++ /dev/null

@@ -1,209 +1,0 @@

-static char sccsid[] = "@(#) ./cc2/arch/i386-sysv/code.c";

-#include <stdio.h>

-#include <stdlib.h>

-

-#include <scc/cstd.h>

-#include <scc/scc.h>

-

-#include "arch.h"

-#include "../../cc2.h"

-

-enum segment {

-	CODESEG,

-	DATASEG,

-	BSSSEG,

-	NOSEG

-};

-

-static int curseg = NOSEG;

-

-static void

-segment(int seg)

-{

-	static char *txt[] = {

-		[CODESEG] = "\t.text\n",

-		[DATASEG] = "\t.data\n",

-		[BSSSEG] = "\t.bss\n",

-	};

-

-	if (seg == curseg)

-		return;

-	fputs(txt[seg], stdout);

-	curseg = seg;

-}

-

-static char *

-symname(Symbol *sym)

-{

-	static char name[INTIDENTSIZ+1];

-

-	if (sym->name) {

-		switch (sym->kind) {

-		case SEXTRN:

-		case SGLOB:

-		case SPRIV:

-			return sym->name;

-		}

-	}

-

-	sprintf(name, ".L%d", sym->numid);

-

-	return name;

-}

-

-static void

-emitconst(Node *np)

-{

-	switch (np->type.size) {

-	case 1:

-		printf("%d", (int) np->u.i & 0xFF);

-		break;

-	case 2:

-		printf("%d", (int) np->u.i & 0xFFFF);

-		break;

-	case 4:

-		printf("%ld", (long) np->u.i & 0xFFFFFFFF);

-		break;

-	case 8:

-		printf("%lld", (long long) np->u.i & 0xFFFFFFFF);

-		break;

-	default:

-		abort();

-	}

-}

-

-static void

-emittree(Node *np)

-{

-	if (!np)

-		return;

-

-	switch (np->op) {

-	case OSTRING:

-		printf("\"%s\"", np->u.s);

-		free(np->u.s);

-		np->u.s = NULL;

-		break;

-	case OCONST:

-		emitconst(np);

-		break;

-	case OADDR:

-		emittree(np->left);

-		break;

-	case OMEM:

-		fputs(symname(np->u.sym), stdout);

-		break;

-	default:

-		emittree(np->left);

-		printf(" %c ", np->op);

-		emittree(np->right);

-		break;

-	}

-}

-static void

-size2asm(Type *tp)

-{

-	char *s;

-

-	if (tp->flags & STRF) {

-		s = "\t.ascii\t";

-	} else {

-		switch (tp->size) {

-		case 1:

-			s = "\t.byte\t";

-			break;

-		case 2:

-			s = "\t.short\t";

-			break;

-		case 4:

-			s = "\t.long\t";

-			break;

-		case 8:

-			s = "\t.quad\t";

-			break;

-		default:

-			s = "\t.space\t%lu,";

-			break;

-		}

-	}

-	printf(s, tp->size);

-}

-

-void

-data(Node *np)

-{

-	size2asm(&np->type);

-	emittree(np);

-	putchar('\n');

-}

-

-static void

-label(Symbol *sym)

-{

-	int seg;

-	char *name = symname(sym);

-	Type *tp = &sym->type;

-

-	if (sym->type.flags & FUNF)

-		seg = CODESEG;

-	else if (sym->type.flags & INITF)

-		seg = DATASEG;

-	else

-		seg = BSSSEG;

-	segment(seg);

-

-	switch (sym->kind) {

-	case SEXTRN:

-		printf("\t.extern\t%s\n", name);

-	case SLOCAL:

-		return;

-	case SGLOB:

-		printf("\t.global\t%s\n", name);

-		if (seg == BSSSEG)

-			printf("\t.comm\t%s,%lu\n", name, tp->size);

-		break;

-	}

-	if (sym->type.align != 1)

-		printf("\t.align\t%lu\n", sym->type.align );

-	printf("%s:\n", name);

-}

-

-void

-defglobal(Symbol *sym)

-{

-	label(sym);

-	if (sym->kind == SEXTRN || (sym->type.flags & INITF))

-		return;

-	size2asm(&sym->type);

-	puts("0");

-}

-

-void

-defpar(Symbol *sym)

-{

-}

-

-void

-defvar(Symbol *sym)

-{

-}

-

-void

-newfun(void)

-{

-}

-

-void

-writeout(void)

-{

-}

-

-void

-endinit(void)

-{

-}

-

-void

-getbblocks(void)

-{

-}

--- a/src/cmd/cc2/target/i386-sysv/optm.c

+++ /dev/null

@@ -1,11 +1,0 @@

-static char sccsid[] = "@(#) ./cc2/arch/i386-sysv/optm.c";

-

-#include <scc/scc.h>

-

-#include "../../cc2.h"

-

-Node *

-optm_dep(Node *np)

-{

-	return np;

-}

--- a/src/cmd/cc2/target/i386-sysv/target.mk

+++ /dev/null

@@ -1,8 +1,0 @@

-OBJ-i386-sysv = $(OBJS)  \

-        target/i386-sysv/cgen.o \

-        target/i386-sysv/optm.o \

-        target/i386-sysv/code.o \

-        target/i386-sysv/types.o

-

-$(LIBEXEC)/cc2-i386-sysv: $(OBJ-i386-sysv)

-	$(CC) $(SCC_LDFLAGS) $(OBJ-i386-sysv) -lscc -o $@

--- a/src/cmd/cc2/target/i386-sysv/types.c

+++ /dev/null

@@ -1,95 +1,0 @@

-static char sccsid[] = "@(#) ./cc2/arch/i386-sysv/types.c";

-

-#include <scc/scc.h>

-

-#include "../../cc2.h"

-

-

-Type int8type = {

-	.flags  = SIGNF | INTF,

-	.size   = 1,

-	.align  = 1

-};

-

-Type int16type = {

-	.flags  = SIGNF | INTF,

-	.size   = 2,

-	.align  = 2

-};

-

-Type int32type = {

-	.flags  = SIGNF | INTF,

-	.size   = 4,

-	.align  = 4

-};

-

-Type int64type = {

-	.flags  = SIGNF | INTF,

-	.size   = 8,

-	.align  = 4

-};

-

-Type uint8type = {

-	.flags  = INTF,

-	.size   = 1,

-	.align  = 1

-};

-

-Type uint16type = {

-	.flags  = INTF,

-	.size   = 2,

-	.align  = 2

-};

-

-Type uint32type = {

-	.flags  = INTF,

-	.size   = 4,

-	.align  = 2

-};

-

-Type uint64type = {

-	.flags  = INTF,

-	.size   = 8,

-	.align  = 4

-};

-

-Type ptrtype = {

-	.flags  = INTF,

-	.size   = 4,

-	.align  = 4

-};

-

-Type booltype = {

-	.flags  = INTF,

-	.size   = 1,

-	.align  = 1

-};

-

-Type float32type = {

-	.flags  = FLOATF,

-	.size   = 4,

-	.align  = 4

-};

-

-Type float64type = {

-	.flags  = FLOATF,

-	.size   = 8,

-	.align  = 4

-};

-

-Type float80type = {

-	.flags  = FLOATF,

-	.size   = 12,

-	.align  =  4

-};

-

-Type voidtype = {

-	.size = 0,

-	.align = 0

-};

-

-/* this type is not used in this architecture */

-Type arg_type = {

-        .size = 0,

-        .align = 0

-};

--- a/src/cmd/cc2/target/qbe/arch.h

+++ /dev/null

@@ -1,135 +1,0 @@

-enum asmop {

-	ASNOP = 0,

-	ASSTB,

-	ASSTH,

-	ASSTW,

-	ASSTL,

-	ASSTM,

-	ASSTS,

-	ASSTD,

-

-	ASLDSB,

-	ASLDUB,

-	ASLDSH,

-	ASLDUH,

-	ASLDSW,

-	ASLDUW,

-	ASLDL,

-	ASLDS,

-	ASLDD,

-

-	ASADDW,

-	ASSUBW,

-	ASMULW,

-	ASMODW,

-	ASUMODW,

-	ASDIVW,

-	ASUDIVW,

-	ASSHLW,

-	ASSHRW,

-	ASUSHRW,

-	ASLTW,

-	ASULTW,

-	ASGTW,

-	ASUGTW,

-	ASLEW,

-	ASULEW,

-	ASGEW,

-	ASUGEW,

-	ASEQW,

-	ASNEW,

-	ASBANDW,

-	ASBORW,

-	ASBXORW,

-

-	ASADDL,

-	ASSUBL,

-	ASMULL,

-	ASMODL,

-	ASUMODL,

-	ASDIVL,

-	ASUDIVL,

-	ASSHLL,

-	ASSHRL,

-	ASUSHRL,

-	ASLTL,

-	ASULTL,

-	ASGTL,

-	ASUGTL,

-	ASLEL,

-	ASULEL,

-	ASGEL,

-	ASUGEL,

-	ASEQL,

-	ASNEL,

-	ASBANDL,

-	ASBORL,

-	ASBXORL,

-

-	ASADDS,

-	ASSUBS,

-	ASMULS,

-	ASDIVS,

-	ASLTS,

-	ASGTS,

-	ASLES,

-	ASGES,

-	ASEQS,

-	ASNES,

-

-	ASADDD,

-	ASSUBD,

-	ASMULD,

-	ASDIVD,

-	ASLTD,

-	ASGTD,

-	ASLED,

-	ASGED,

-	ASEQD,

-	ASNED,

-

-	ASEXTBW,

-	ASUEXTBW,

-	ASEXTBL,

-	ASUEXTBL,

-	ASEXTHW,

-	ASUEXTHW,

-	ASEXTHL,

-	ASUEXTHL,

-	ASEXTWL,

-	ASUEXTWL,

-

-	ASSTOL,

-	ASSTOW,

-	ASDTOL,

-	ASDTOW,

-

-	ASSWTOD,

-	ASSWTOS,

-	ASSLTOD,

-	ASSLTOS,

-

-	ASEXTS,

-	ASTRUNCD,

-

-	ASJMP,

-	ASBRANCH,

-	ASRET,

-	ASCALL,

-	ASCALLE,

-	ASCALLEX,

-	ASPAR,

-	ASPARE,

-	ASALLOC,

-	ASFORM,

-

-	ASCOPYB,

-	ASCOPYH,

-	ASCOPYW,

-	ASCOPYL,

-	ASCOPYS,

-	ASCOPYD,

-

-	ASVSTAR,

-	ASVARG,

-};

--- a/src/cmd/cc2/target/qbe/cgen.c

+++ /dev/null

@@ -1,729 +1,0 @@

-static char sccsid[] = "@(#) ./cc2/arch/qbe/cgen.c";

-

-#include <assert.h>

-#include <stdlib.h>

-

-#include <scc/cstd.h>

-#include <scc/scc.h>

-

-#include "arch.h"

-#include "../../cc2.h"

-

-enum sflags {

-	ISTMP  = 1,

-	ISCONS = 2

-};

-

-static char opasmw[] = {

-	[OADD] = ASADDW,

-	[OSUB] = ASSUBW,

-	[OMUL] = ASMULW,

-	[OMOD] = ASMODW,

-	[ODIV] = ASDIVW,

-	[OSHL] = ASSHLW,

-	[OSHR] = ASSHRW,

-	[OLT] = ASLTW,

-	[OGT] = ASGTW,

-	[OLE] = ASLEW,

-	[OGE] = ASGEW,

-	[OEQ] = ASEQW,

-	[ONE] = ASNEW,

-	[OBAND] = ASBANDW,

-	[OBOR] = ASBORW,

-	[OBXOR] = ASBXORW,

-};

-

-static char opasml[] = {

-	[OADD] = ASADDL,

-	[OSUB] = ASSUBL,

-	[OMUL] = ASMULL,

-	[OMOD] = ASMODL,

-	[ODIV] = ASDIVL,

-	[OSHL] = ASSHLL,

-	[OSHR] = ASSHRL,

-	[OLT] = ASLTL,

-	[OGT] = ASGTL,

-	[OLE] = ASLEL,

-	[OGE] = ASGEL,

-	[OEQ] = ASEQL,

-	[ONE] = ASNEL,

-	[OBAND] = ASBANDL,

-	[OBOR] = ASBORL,

-	[OBXOR] = ASBXORL,

-};

-

-static char opasms[] = {

-	[OADD] = ASADDS,

-	[OSUB] = ASSUBS,

-	[OMUL] = ASMULS,

-	[ODIV] = ASDIVS,

-	[OLT] = ASLTS,

-	[OGT] = ASGTS,

-	[OLE] = ASLES,

-	[OGE] = ASGES,

-	[OEQ] = ASEQS,

-	[ONE] = ASNES,

-};

-static char opasmd[] = {

-	[OADD] = ASADDD,

-	[OSUB] = ASSUBD,

-	[OMUL] = ASMULD,

-	[ODIV] = ASDIVD,

-	[OLT] = ASLTD,

-	[OGT] = ASGTD,

-	[OLE] = ASLED,

-	[OGE] = ASGED,

-	[OEQ] = ASEQD,

-	[ONE] = ASNED,

-};

-

-extern Type int32type, uint32type, ptrtype;

-

-static Node *

-tmpnode(Node *np, Type *tp)

-{

-	char flags;

-	Symbol *sym;

-

-	if (!np)

-		np = node(OTMP);

-	sym = getsym(TMPSYM);

-	sym->type = np->type = *tp;

-	flags = tp->flags & ~(PARF|INITF);

-	sym->type.flags = np->type.flags = flags;

-	sym->kind = STMP;

-	np->left = np->right = NULL;

-	np->u.sym = sym;

-	np->op = OTMP;

-	np->flags |= ISTMP;

-	return np;

-}

-

-static Node *

-load(Type *tp, Node *np, Node *new)

-{

-	int op;

-	int flags = tp->flags;

-

-	if (flags & (AGGRF|FUNF)) {

-		*new = *np;

-		return new;

-	}

-	switch (tp->size) {

-	case 1:

-		op = ASLDSB;

-		break;

-	case 2:

-		op = ASLDSH;

-		break;

-	case 4:

-		op = (flags & FLOATF) ? ASLDS : ASLDSW;

-		break;

-	case 8:

-		op = (flags & FLOATF) ? ASLDD : ASLDL;

-		break;

-	default:

-		abort();

-	}

-	/*

-	 * unsigned version of operations are always +1 the

-	 * signed version

-	 */

-	if ((flags & (INTF|SIGNF)) == INTF && tp->size < 8)

-		++op;

-

-	code(op, tmpnode(new, tp), np, NULL);

-

-	return new;

-}

-

-static Node *rhs(Node *np, Node *new);

-

-static Node *

-cast(Type *td, Node *ns, Node *nd)

-{

-	Type *ts;

-	Node aux1, aux2;

-	int op, d_isint, s_isint;

-

-	ts = &ns->type;

-	d_isint = (td->flags & INTF) != 0;

-	s_isint = (ts->flags & INTF) != 0;

-

-	if (d_isint && s_isint) {

-		if (td->size <= ts->size) {

-			*nd = *ns;

-			return nd;

-		}

-		assert(td->size == 4 || td->size == 8);

-		switch (ts->size) {

-		case 1:

-			op = (td->size == 4) ? ASEXTBW : ASEXTBL;

-			break;

-		case 2:

-			op = (td->size == 4) ? ASEXTHW : ASEXTHL;

-			break;

-		case 4:

-			op = ASEXTWL;

-			break;

-		default:

-			abort();

-		}

-		/*

-		 * unsigned version of operations are always +1 the

-		 * signed version

-		 */

-		op += (ts->flags & SIGNF) == 0;

-	} else if (d_isint) {

-		/* conversion from float to int */

-		switch (ts->size) {

-		case 4:

-			op = (td->size == 8) ? ASSTOL : ASSTOW;

-			break;

-		case 8:

-			op = (td->size == 8) ? ASDTOL : ASDTOW;

-			break;

-		default:

-			abort();

-		}

-		/* TODO: Add signess */

-	} else if (s_isint) {

-		/* conversion from int to float */

-		switch (ts->size) {

-		case 1:

-		case 2:

-			ts = (ts->flags&SIGNF) ? &int32type : &uint32type;

-			ns = cast(ts, ns, tmpnode(&aux2, ts));

-		case 4:

-			op = (td->size == 8) ? ASSWTOD : ASSWTOS;

-			break;

-		case 8:

-			op = (td->size == 8) ? ASSLTOD : ASSLTOS;

-			break;

-		default:

-			abort();

-		}

-		/* TODO: Add signess */

-	} else {

-		/* conversion from float to float */

-		op = (td->size == 4) ? ASEXTS : ASTRUNCD;

-	}

-

-	code(op, tmpnode(nd, td), ns, NULL);

-	return nd;

-}

-

-static Node *

-call(Node *np, Node *fun, Node *ret)

-{

-	int n, op;

-	Type *tp;

-	Node aux, **q, *p, *pars[NR_FUNPARAM];

-

-	for (n = 0, p = np->right; p; p = p->right)

-		pars[n++] = rhs(p->left, node(OTMP));

-

-	tp = &np->type;

-	code(ASCALL, tmpnode(ret, tp), fun, NULL);

-

-	for (q = pars; q < &pars[n]; ++q) {

-		op = (q == &pars[n-1]) ? ASPARE : ASPAR;

-		tmpnode(&aux, &(*q)->type);

-		code(op, NULL, *q, &aux);

-	}

-	code((np->op == OCALL) ? ASCALLE : ASCALLEX, NULL, NULL, NULL);

-

-	return ret;

-}

-

-static Node *

-assign(Type *tp, Node *to, Node *from)

-{

-	int op;

-

-	switch (tp->size) {

-	case 1:

-		op = ASSTB;

-		break;

-	case 2:

-		op = ASSTH;

-		break;

-	case 4:

-		op = (tp->flags & FLOATF) ? ASSTS : ASSTW;

-		break;

-	case 8:

-		op = (tp->flags & FLOATF) ? ASSTD : ASSTL;

-		break;

-	default:

-		op = ASSTM;

-		break;

-	}

-	code(op, to, from, NULL);

-	return from;

-}

-

-static Node *

-copy(Type *tp, Node *to, Node *from)

-{

-	int op;

-

-	switch (tp->size) {

-	case 1:

-		op = ASCOPYB;

-		break;

-	case 2:

-		op = ASCOPYH;

-		break;

-	case 4:

-		op = (tp->flags & FLOATF) ? ASCOPYS : ASCOPYW;

-		break;

-	case 8:

-		op = (tp->flags & FLOATF) ? ASCOPYD : ASCOPYL;

-		break;

-	default:

-		/* TODO: Need to handle the general case */

-		abort();

-	}

-	code(op, to, from, NULL);

-	return from;

-}

-

-/* TODO: Do field() transformation in sethi */

-

-static Node *

-field(Node *np, Node *ret, int islhs)

-{

-	Node base, node, off, add, *addr;

-	TUINT offset = np->right->u.sym->u.off;

-

-	addr = rhs(np->left, &base);

-

-	if (offset != 0) {

-		node.op = OADD;

-		node.type = ptrtype;

-		node.left = addr;

-		node.right = constnode(&off, offset, &ptrtype);

-		addr = rhs(&node, &add);

-	}

-

-	if (islhs)

-		*ret = *addr;

-	else

-		load(&np->type, addr, ret);

-

-	return ret;

-}

-

-static Node *

-lhs(Node *np, Node *new)

-{

-	switch (np->op) {

-	case OMEM:

-	case OAUTO:

-		*new = *np;

-		return new;

-	case OPTR:

-		return rhs(np->left, new);

-	case OFIELD:

-		return field(np, new, 1);

-	default:

-		abort();

-	}

-}

-

-static void

-bool(Node *np, Symbol *true, Symbol *false)

-{

-	Node *l = np->left, *r = np->right;

-	Node ret, ifyes, ifno;

-	Symbol *label;

-

-	switch (np->op) {

-	case ONEG:

-		bool(l, false, true);

-		break;

-	case OAND:

-		label = newlabel();

-		bool(l, label, false);

-		setlabel(label);

-		bool(r, true, false);

-		break;

-	case OOR:

-		label = newlabel();

-		bool(l, true, label);

-		setlabel(label);

-		bool(r, true, false);

-		break;

-	default:

-		label2node(&ifyes, true);

-		label2node(&ifno, false);

-		code(ASBRANCH, rhs(np, &ret), &ifyes, &ifno);

-		break;

-	}

-}

-

-static Node *

-ternary(Node *np, Node *ret)

-{

-	Node ifyes, ifno, phi, *colon, aux1, aux2, aux3;

-

-	tmpnode(ret, &np->type);

-	label2node(&ifyes, NULL);

-	label2node(&ifno, NULL);

-	label2node(&phi, NULL);

-

-	colon = np->right;

-	code(ASBRANCH, rhs(np->left, &aux1), &ifyes, &ifno);

-

-	setlabel(ifyes.u.sym);

-	copy(&ret->type, ret, rhs(colon->left, &aux2));

-	code(ASJMP, NULL, &phi, NULL);

-

-	setlabel(ifno.u.sym);

-	copy(&ret->type, ret, rhs(colon->right, &aux3));

-	setlabel(phi.u.sym);

-

-	return ret;

-}

-

-static Node *

-function(void)

-{

-	Node aux;

-	Symbol *p;

-

-	/* allocate stack space for parameters */

-	for (p = locals; p && (p->type.flags & PARF) != 0; p = p->next)

-		code(ASALLOC, label2node(&aux, p), NULL, NULL);

-

-	/* allocate stack space for local variables) */

-	for ( ; p && p->id != TMPSYM; p = p->next) {

-		if (p->kind != SAUTO)

-			continue;

-		code(ASALLOC, label2node(&aux, p), NULL, NULL);

-	}

-	/* store formal parameters in parameters */

-	for (p = locals; p; p = p->next) {

-		if ((p->type.flags & PARF) == 0)

-			break;

-		code(ASFORM, label2node(&aux, p), NULL, NULL);

-	}

-	return NULL;

-}

-

-static void

-swtch_if(Node *idx)

-{

-	Node aux1, aux2, *np;

-	Symbol *deflabel = NULL;

-

-	for (;;) {

-		np = delstmt();

-		setlabel(np->label);

-

-		switch (np->op) {

-		case OESWITCH:

-			if (!deflabel)

-				deflabel = np->u.sym;

-			aux1.op = OJMP;

-			aux1.label = NULL;

-			aux1.u.sym = deflabel;

-			cgen(&aux1);

-			return;

-		case OCASE:

-			aux1 = *np;

-			aux1.op = OBRANCH;

-			aux1.label = NULL;

-			aux1.left = &aux2;

-

-			aux2.op = OEQ;

-			aux2.type = idx->type;

-			aux2.left = np->left;

-			aux2.right = idx;

-

-			cgen(&aux1);

-			break;

-		case ODEFAULT:

-			deflabel = np->u.sym;

-			break;

-		default:

-			abort();

-		}

-	}

-}

-

-static Node *

-rhs(Node *np, Node *ret)

-{

-	Node aux1, aux2, *phi, *l = np->left, *r = np->right;

-	Type *tp;

-	int off, op;

-	char *tbl;

-	Symbol *true, *false;

-

-	tp = &np->type;

-

-	switch (np->op) {

-	case OBFUN:

-		return function();

-	case ONOP:

-	case OBLOOP:

-	case OELOOP:

-	case OEFUN:

-		return NULL;

-	case OTMP:

-	case OCONST:

-		*ret = *np;

-		return np;

-	case OMEM:

-	case OAUTO:

-		return load(tp, np, ret);

-	case ONEG:

-	case OAND:

-	case OOR:

-		true = newlabel();

-		false = newlabel();

-		phi = label2node(&aux1, NULL);

-		tmpnode(ret, &int32type);

-

-		bool(np, true, false);

-

-		setlabel(true);

-		code(ASCOPYW, ret, constnode(&aux2, 1, &int32type), NULL);

-		code(ASJMP, NULL, phi, NULL);

-

-		setlabel(false);

-		code(ASCOPYW, ret, constnode(&aux2, 0, &int32type), NULL);

-

-		setlabel(phi->u.sym);

-		return ret;

-        case OMOD:

-        case OSHR:

-		assert(tp->flags & INTF);

-        case ODIV:

-        case OLT:

-        case OGT:

-        case OLE:

-        case OGE:

-                /*

-                 * unsigned version of operations are always +1 the

-                 * signed version

-                 */

-                off = (tp->flags & SIGNF) == 0;

-                goto binary;

-        case OSHL:

-        case OBAND:

-        case OBOR:

-        case OBXOR:

-		assert(tp->flags & INTF);

-        case OADD:

-        case OSUB:

-        case OMUL:

-        case OEQ:

-        case ONE:

-                off = 0;

-        binary:

-		if (l->complex >= r->complex) {

-			rhs(l, &aux1);

-			rhs(r, &aux2);

-		} else {

-			rhs(r, &aux2);

-			rhs(l, &aux1);

-		}

-                switch (tp->size) {

-                case 4:

-                        tbl = (tp->flags & FLOATF) ? opasms : opasmw;

-                        break;

-                case 8:

-                        tbl = (tp->flags & FLOATF) ? opasmd : opasml;

-                        break;

-                default:

-                        abort();

-                }

-                op = tbl[np->op] + off;

-		tmpnode(ret, tp);

-                code(op, ret, &aux1, &aux2);

-                return ret;

-	case OCALL:

-	case OCALLE:

-		if (l->op == OPTR)

-			l = rhs(l, &aux1);

-		return call(np, l, ret);

-	case OCAST:

-		return cast(tp, rhs(l, &aux1), ret);

-	case OASSIG:

-		/* TODO: Do this transformations in sethi */

-		switch (np->u.subop) {

-		case OINC:

-			op = OADD;

-			goto post_oper;

-		case ODEC:

-			op = OSUB;

-		post_oper:

-			aux1.op = op;

-			aux1.left = rhs(l, ret);

-			aux1.right = r;

-			aux1.type = np->type;

-			rhs(&aux1, &aux2);

-			lhs(l, &aux1);

-			assign(tp, &aux1, &aux2);

-			break;

-		default:

-			aux2.type = np->type;

-			aux2.op = np->u.subop;

-			aux2.right = np->right;

-			aux2.left = np->left;

-			r = rhs(&aux2, &aux1);

-			Node aux3;

-			if (l->op == OCAST) {

-				aux3.type = l->left->type;

-				aux3.op = OCAST;

-				aux3.left = r;

-				aux3.right = NULL;

-				r = &aux3;

-				l = l->left;

-			}

-		case 0:

-			/* TODO: see what is the most difficult */

-			lhs(l, &aux2);

-			rhs(r, ret);

-			return assign(tp, &aux2, ret);

-		}

-		return ret;

-	case OASK:

-		return ternary(np, ret);

-	case OCOMMA:

-		rhs(l, &aux1);

-		return rhs(r, ret);

-	case OPTR:

-		return load(tp, rhs(l, &aux1), ret);

-	case OADDR:

-		lhs(l, ret);

-		ret->type = *tp;

-		return ret;

-	case OFIELD:

-		return field(np, ret, 0);

-	case OBUILTIN:

-		switch (np->u.subop) {

-		case BVA_START:

-			l = rhs(l, &aux1);

-			code(ASVSTAR, NULL, l, NULL);

-			return NULL;

-		case BVA_END:

-			return NULL;

-		case BVA_ARG:

-			l = rhs(l, &aux1);

-			code(ASVARG, tmpnode(ret, tp), l, NULL);

-			return ret;

-		case BVA_COPY:

-			/* TODO */

-		default:

-			abort();

-		}

-	default:

-		abort();

-	}

-	abort();

-}

-

-Node *

-cgen(Node *np)

-{

-	Node aux, *p, *next;

-

-	setlabel(np->label);

-	switch (np->op) {

-	case OJMP:

-		label2node(&aux, np->u.sym);

-		code(ASJMP, NULL, &aux, NULL);

-		break;

-	case OBRANCH:

-		next = np->next;

-		if (!next->label)

-			next->label = newlabel();

-		bool(np->left, np->u.sym, next->label);

-		break;

-	case ORET:

-		p = (np->left) ? rhs(np->left, &aux) : NULL;

-		code(ASRET, NULL, p, NULL);

-		break;

-	case OBSWITCH:

-		p = rhs(np->left, &aux);

-		swtch_if(p);

-		break;

-	default:

-		rhs(np, &aux);

-		break;

-	}

-	return NULL;

-}

-

-/*

- * This is strongly influenced by

- * http://plan9.bell-labs.com/sys/doc/compiler.ps (/sys/doc/compiler.ps)

- * calculate addresability as follows

- *     AUTO => 11          value+fp

- *     REG => 11           reg

- *     STATIC => 11        (value)

- *     CONST => 11         $value

- * These values of addressability are not used in the code generation.

- * They are only used to calculate the Sethi-Ullman numbers. Since

- * QBE is AMD64 targered we could do a better job there, and try to

- * detect some of the complex addressing modes of these processors.

- */

-Node *

-sethi(Node *np)

-{

-	Node *lp, *rp;

-

-	if (!np)

-		return np;

-

-	np->complex = 0;

-	np->address = 0;

-	lp = np->left;

-	rp = np->right;

-

-	switch (np->op) {

-	case OAUTO:

-	case OREG:

-	case OMEM:

-	case OCONST:

-		np->address = 11;

-		break;

-	case OCPL:

-		assert(np->type.flags & INTF);

-		np->op = OBXOR;

-		rp = constnode(NULL, ~(TUINT) 0, &np->type);

-		goto binary;

-	case OSNEG:

-		np->op = OSUB;

-		rp = lp;

-		lp = constnode(NULL, 0, &np->type);

-		if ((np->type.flags & INTF) == 0)

-			lp->u.f = 0.0;

-	default:

-	binary:

-		lp = sethi(lp);

-		rp = sethi(rp);

-		break;

-	}

-	np->left = lp;

-	np->right = rp;

-

-	if (np->address > 10)

-		return np;

-	if (lp)

-		np->complex = lp->complex;

-	if (rp) {

-		int d = np->complex - rp->complex;

-

-		if (d == 0)

-			++np->complex;

-		else if (d < 0)

-			np->complex = rp->complex;

-	}

-	if (np->complex == 0)

-		++np->complex;

-	return np;

-}

--- a/src/cmd/cc2/target/qbe/code.c

+++ /dev/null

@@ -1,569 +1,0 @@

-static char sccsid[] = "@(#) ./cc2/arch/qbe/code.c";

-

-#include <stdio.h>

-#include <stdlib.h>

-#include <string.h>

-

-#include <scc/cstd.h>

-#include <scc/scc.h>

-

-#include "arch.h"

-#include "../../cc2.h"

-

-#define ADDR_LEN (INTIDENTSIZ+64)

-

-static void binary(void), unary(void), store(void), jmp(void), ret(void),

-            branch(void), call(void), ecall(void), param(void),

-            asalloc(void), form2local(void), ldir(void), vastart(void),

-            vaarg(void);

-

-static struct opdata {

-	void (*fun)(void);

-	char *txt;

-	char letter;

-} optbl [] = {

-	[ASLDSB]  =  {.fun = unary,  .txt = "loadsb", .letter = 'w'},

-	[ASLDUB]  =  {.fun = unary,  .txt = "loadub", .letter = 'w'},

-	[ASLDSH]  =  {.fun = unary,  .txt = "loadsh", .letter = 'w'},

-	[ASLDUH]  =  {.fun = unary,  .txt = "loaduh", .letter = 'w'},

-	[ASLDSW]  =  {.fun = unary,  .txt = "loadsw", .letter = 'w'},

-	[ASLDUW]  =  {.fun = unary,  .txt = "loaduw", .letter = 'w'},

-	[ASLDL]   =  {.fun = unary,  .txt = "loadl", .letter = 'l'},

-	[ASLDS]   =  {.fun = unary,  .txt = "loads", .letter = 's'},

-	[ASLDD]   =  {.fun = unary,  .txt = "loadd", .letter = 'd'},

-

-	[ASCOPYB] =  {.fun = unary,  .txt = "copy", .letter = 'b'},

-	[ASCOPYH] =  {.fun = unary,  .txt = "copy", .letter = 'h'},

-	[ASCOPYW] =  {.fun = unary,  .txt = "copy", .letter = 'w'},

-	[ASCOPYL] =  {.fun = unary,  .txt = "copy", .letter = 'l'},

-	[ASCOPYS] =  {.fun = unary,  .txt = "copy", .letter = 's'},

-	[ASCOPYD] =  {.fun = unary,  .txt = "copy", .letter = 'd'},

-

-	[ASSTB]   =  {.fun = store,  .txt = "store", .letter = 'b'},

-	[ASSTH]   =  {.fun = store,  .txt = "store", .letter = 'h'},

-	[ASSTW]   =  {.fun = store,  .txt = "store", .letter = 'w'},

-	[ASSTL]   =  {.fun = store,  .txt = "store", .letter = 'l'},

-	[ASSTM]   =  {.fun = ldir},

-	[ASSTS]   =  {.fun = store,  .txt = "store", .letter = 's'},

-	[ASSTD]   =  {.fun = store,  .txt = "store", .letter = 'd'},

-

-	[ASADDW]  =  {.fun = binary, .txt = "add", .letter = 'w'},

-	[ASSUBW]  =  {.fun = binary, .txt = "sub", .letter = 'w'},

-	[ASMULW]  =  {.fun = binary, .txt = "mul", .letter = 'w'},

-	[ASMODW]  =  {.fun = binary, .txt = "rem", .letter = 'w'},

-	[ASUMODW] =  {.fun = binary, .txt = "urem", .letter = 'w'},

-	[ASDIVW]  =  {.fun = binary, .txt = "div", .letter = 'w'},

-	[ASUDIVW] =  {.fun = binary, .txt = "udiv", .letter = 'w'},

-	[ASSHLW]  =  {.fun = binary, .txt = "shl", .letter = 'w'},

-	[ASSHRW]  =  {.fun = binary, .txt = "sar", .letter = 'w'},

-	[ASUSHRW] =  {.fun = binary, .txt = "shr", .letter = 'w'},

-	[ASLTW]   =  {.fun = binary, .txt = "csltw", .letter = 'w'},

-	[ASULTW]  =  {.fun = binary, .txt = "cultw", .letter = 'w'},

-	[ASGTW]   =  {.fun = binary, .txt = "csgtw", .letter = 'w'},

-	[ASUGTW]  =  {.fun = binary, .txt = "cugtw", .letter = 'w'},

-	[ASLEW]   =  {.fun = binary, .txt = "cslew", .letter = 'w'},

-	[ASULEW]  =  {.fun = binary, .txt = "culew", .letter = 'w'},

-	[ASGEW]   =  {.fun = binary, .txt = "csgew", .letter = 'w'},

-	[ASUGEW]  =  {.fun = binary, .txt = "cugew", .letter = 'w'},

-	[ASEQW]   =  {.fun = binary, .txt = "ceqw", .letter = 'w'},

-	[ASNEW]   =  {.fun = binary, .txt = "cnew", .letter = 'w'},

-	[ASBANDW] =  {.fun = binary, .txt = "and", .letter = 'w'},

-	[ASBORW]  =  {.fun = binary, .txt = "or", .letter = 'w'},

-	[ASBXORW] =  {.fun = binary, .txt = "xor", .letter = 'w'},

-

-	[ASADDL]  =  {.fun = binary, .txt = "add", .letter = 'l'},

-	[ASSUBL]  =  {.fun = binary, .txt = "sub", .letter = 'l'},

-	[ASMULL]  =  {.fun = binary, .txt = "mul", .letter = 'l'},

-	[ASMODL]  =  {.fun = binary, .txt = "rem", .letter = 'l'},

-	[ASUMODL] =  {.fun = binary, .txt = "urem", .letter = 'l'},

-	[ASDIVL]  =  {.fun = binary, .txt = "div", .letter = 'l'},

-	[ASUDIVL] =  {.fun = binary, .txt = "udiv", .letter = 'l'},

-	[ASSHLL]  =  {.fun = binary, .txt = "shl", .letter = 'l'},

-	[ASSHRL]  =  {.fun = binary, .txt = "sar", .letter = 'l'},

-	[ASUSHRL] =  {.fun = binary, .txt = "shr", .letter = 'l'},

-	[ASLTL]   =  {.fun = binary, .txt = "csltl", .letter = 'w'},

-	[ASULTL]  =  {.fun = binary, .txt = "cultl", .letter = 'w'},

-	[ASGTL]   =  {.fun = binary, .txt = "csgtl", .letter = 'w'},

-	[ASUGTL]  =  {.fun = binary, .txt = "cugtl", .letter = 'w'},

-	[ASLEL]   =  {.fun = binary, .txt = "cslel", .letter = 'w'},

-	[ASULEL]  =  {.fun = binary, .txt = "culel", .letter = 'w'},

-	[ASGEL]   =  {.fun = binary, .txt = "csgel", .letter = 'w'},

-	[ASUGEL]  =  {.fun = binary, .txt = "cugel", .letter = 'w'},

-	[ASEQL]   =  {.fun = binary, .txt = "ceql", .letter = 'w'},

-	[ASNEL]   =  {.fun = binary, .txt = "cnel", .letter = 'w'},

-	[ASBANDL] =  {.fun = binary, .txt = "and", .letter = 'l'},

-	[ASBORL]  =  {.fun = binary, .txt = "or", .letter = 'l'},

-	[ASBXORL] =  {.fun = binary, .txt = "xor", .letter = 'l'},

-

-	[ASADDS]  =  {.fun = binary, .txt = "add", .letter = 's'},

-	[ASSUBS]  =  {.fun = binary, .txt = "sub", .letter = 's'},

-	[ASMULS]  =  {.fun = binary, .txt = "mul", .letter = 's'},

-	[ASDIVS]  =  {.fun = binary, .txt = "div", .letter = 's'},

-	[ASLTS]   =  {.fun = binary, .txt = "clts", .letter = 'w'},

-	[ASGTS]   =  {.fun = binary, .txt = "cgts", .letter = 'w'},

-	[ASLES]   =  {.fun = binary, .txt = "cles", .letter = 'w'},

-	[ASGES]   =  {.fun = binary, .txt = "cges", .letter = 'w'},

-	[ASEQS]   =  {.fun = binary, .txt = "ceqs", .letter = 'w'},

-	[ASNES]   =  {.fun = binary, .txt = "cnes", .letter = 'w'},

-

-	[ASADDD]  =  {.fun = binary, .txt = "add", .letter = 'd'},

-	[ASSUBD]  =  {.fun = binary, .txt = "sub", .letter = 'd'},

-	[ASMULD]  =  {.fun = binary, .txt = "mul", .letter = 'd'},

-	[ASDIVD]  =  {.fun = binary, .txt = "div", .letter = 'd'},

-	[ASLTD]   =  {.fun = binary, .txt = "cltd", .letter = 'w'},

-	[ASGTD]   =  {.fun = binary, .txt = "cgtd", .letter = 'w'},

-	[ASLED]   =  {.fun = binary, .txt = "cled", .letter = 'w'},

-	[ASGED]   =  {.fun = binary, .txt = "cged", .letter = 'w'},

-	[ASEQD]   =  {.fun = binary, .txt = "ceqd", .letter = 'w'},

-	[ASNED]   =  {.fun = binary, .txt = "cned", .letter = 'w'},

-

-	[ASEXTBW] =  {.fun = unary, .txt = "extsb", .letter = 'w'},

-	[ASUEXTBW]=  {.fun = unary, .txt = "extub", .letter = 'w'},

-	[ASEXTBL] =  {.fun = unary, .txt = "extsb", .letter = 'l'},

-	[ASUEXTBL]=  {.fun = unary, .txt = "extub", .letter = 'l'},

-	[ASEXTHW] =  {.fun = unary, .txt = "extsh", .letter = 'w'},

-	[ASUEXTHW]=  {.fun = unary, .txt = "extuh", .letter = 'w'},

-	[ASEXTWL] =  {.fun = unary, .txt = "extsw", .letter = 'l'},

-	[ASUEXTWL]=  {.fun = unary, .txt = "extuw", .letter = 'l'},

-

-	[ASSTOL] = {.fun = unary, .txt = "stosi", .letter = 'l'},

-	[ASSTOW] = {.fun = unary, .txt = "stosi", .letter = 'w'},

-	[ASDTOL] = {.fun = unary, .txt = "dtosi", .letter = 'l'},

-	[ASDTOW] = {.fun = unary, .txt = "dtosi", .letter = 'w'},

-

-	[ASSWTOD] = {.fun = unary, .txt = "swtof", .letter = 'd'},

-	[ASSWTOS] = {.fun = unary, .txt = "swtof", .letter = 's'},

-	[ASSLTOD] = {.fun = unary, .txt = "sltof", .letter = 'd'},

-	[ASSLTOS] = {.fun = unary, .txt = "sltof", .letter = 's'},

-

-	[ASEXTS] = {.fun = unary, .txt = "exts", .letter = 'd'},

-	[ASTRUNCD] = {.fun = unary, .txt = "truncd", .letter = 's'},

-

-	[ASBRANCH] = {.fun = branch},

-	[ASJMP]  = {.fun = jmp},

-	[ASRET]  = {.fun = ret},

-	[ASCALL] = {.fun = call},

-	[ASCALLE] = {.fun = ecall, .txt = ")"},

-	[ASCALLEX] = {.fun = ecall, .txt = ", ...)"},

-	[ASPAR] = {.fun = param, .txt = "%s %s, "},

-	[ASPARE] = {.fun = param, .txt = "%s %s"},

-	[ASALLOC] = {.fun = asalloc},

-	[ASFORM] = {.fun = form2local},

-

-	[ASVSTAR] = {.fun = vastart},

-	[ASVARG] = {.fun = vaarg},

-};

-

-static char buff[ADDR_LEN];

-/*

- * : is for user-defined Aggregate Types

- * $ is for globals (represented by a pointer)

- * % is for function-scope temporaries

- * @ is for block labels

- */

-static char

-sigil(Symbol *sym)

-{

-	switch (sym->kind) {

-	case SEXTRN:

-	case SGLOB:

-	case SPRIV:

-	case SLOCAL:

-		return '$';

-	case SAUTO:

-	case STMP:

-		return '%';

-	case SLABEL:

-		return '@';

-	default:

-		abort();

-	}

-}

-

-static char *

-symname(Symbol *sym)

-{

-	char c = sigil(sym);

-

-	if (sym->name) {

-		switch (sym->kind) {

-		case SEXTRN:

-		case SGLOB:

-			sprintf(buff, "%c%s", c, sym->name);

-			return buff;

-		case SLOCAL:

-		case SPRIV:

-		case SAUTO:

-			sprintf(buff, "%c%s.%u", c, sym->name, sym->id);

-			return buff;

-		default:

-			abort();

-		}

-	}

-	sprintf(buff, "%c.%u", c, sym->numid);

-

-	return buff;

-}

-

-static void

-emitconst(Node *np)

-{

-	switch (np->type.size) {

-	case 1:

-		printf("%d", (int) np->u.i & 0xFF);

-		break;

-	case 2:

-		printf("%d", (int) np->u.i & 0xFFFF);

-		break;

-	case 4:

-		printf("%ld", (long) np->u.i & 0xFFFFFFFF);

-		break;

-        case 8:

-                printf("%lld", (long long) np->u.i);

-                break;

-	default:

-		abort();

-	}

-}

-

-static void

-emittree(Node *np)

-{

-	if (!np)

-		return;

-

-	switch (np->op) {

-	case OSTRING:

-		printf("\"%s\"", np->u.s);

-		free(np->u.s);

-		np->u.s = NULL;

-		break;

-	case OCONST:

-		emitconst(np);

-		break;

-	case OADDR:

-		emittree(np->left);

-		break;

-	case OMEM:

-		fputs(symname(np->u.sym), stdout);

-		break;

-	default:

-		emittree(np->left);

-		printf(" %c ", np->op);

-		emittree(np->right);

-		break;

-	}

-}

-

-static char *

-size2asm(Type *tp)

-{

-	if (tp->flags & STRF) {

-		return "b";

-	} else if (tp->flags & INTF) {

-		switch (tp->size) {

-		case 1:

-			return "b";

-		case 2:

-			return "h";

-		case 4:

-			return "w";

-		case 8:

-			return "l";

-		}

-	} else if (tp->flags & FLOATF) {

-		if (tp->size == 4)

-			return "s";

-		else if (tp->size == 8)

-			return "d";

-	}

-	abort();

-}

-

-void

-defglobal(Symbol *sym)

-{

-	if (sym->kind == SEXTRN)

-		return;

-	if (sym->kind == SGLOB)

-		fputs("export ", stdout);

-	printf("data %s = {\n", symname(sym));

-	if (sym->type.flags & INITF)

-		return;

-	printf("\tz\t%lu\n}\n", sym->type.size);

-}

-

-void

-defpar(Symbol *sym)

-{

-	sym->type.flags |= PARF;

-}

-

-void

-defvar(Symbol *sym)

-{

-	if (sym->kind == SREG)

-		sym->kind = SAUTO;

-}

-

-void

-data(Node *np)

-{

-	printf("\t%s\t", size2asm(&np->type));

-	emittree(np);

-	putchar(',');

-	putchar('\n');

-}

-

-static char *

-size2stack(Type *tp)

-{

-	if (tp->flags & INTF) {

-		switch (tp->size) {

-		case 1:

-		case 2:

-		case 4:

-			return "w";

-		case 8:

-			return "l";

-		}

-	} else if (tp->flags & FLOATF) {

-		if (tp->size == 4)

-			return "s";

-		else if (tp->size == 8)

-			return "d";

-	} else if (tp->size == 0) {

-		return "w";

-	}

-	abort();

-}

-

-void

-writeout(void)

-{

-	Symbol *p;

-	Type *tp;

-	char *sep, *name;

-	int haslabel = 0;

-

-	if (!curfun)

-		return;

-	if (curfun->kind == SGLOB)

-		fputs("export ", stdout);

-	printf("function %s %s(", size2stack(&curfun->rtype), symname(curfun));

-

-	/* declare formal parameters */

-	for (sep = "", p = locals; p; p = p->next, sep = ",") {

-		if ((p->type.flags & PARF) == 0)

-			break;

-		printf("%s%s %s.val", sep, size2stack(&p->type), symname(p));

-	}

-	printf("%s)\n{\n", (curfun->type.flags&ELLIPS) ? ", ..." : "");

-

-	/* emit assembler instructions */

-	for (pc = prog; pc; pc = pc->next) {

-		if (pc->label) {

-			haslabel = 1;

-			printf("%s\n", symname(pc->label));

-		}

-		if (!pc->op)

-			continue;

-		if (pc->flags&BBENTRY && !haslabel)

-			printf("%s\n", symname(newlabel()));

-		(*optbl[pc->op].fun)();

-		if (!pc->label)

-			haslabel = 0;

-	}

-

-	puts("}");

-}

-

-static char *

-addr2txt(Addr *a)

-{

-	switch (a->kind) {

-	case SCONST:

-		sprintf(buff, "%llu", (unsigned long long) a->u.i);

-		return buff;

-	case SAUTO:

-	case SLABEL:

-	case STMP:

-	case SGLOB:

-	case SEXTRN:

-	case SPRIV:

-	case SLOCAL:

-		return symname(a->u.sym);

-	default:

-		abort();

-	}

-}

-

-static void

-binary(void)

-{

-	struct opdata *p = &optbl[pc->op];

-	char to[ADDR_LEN], from1[ADDR_LEN], from2[ADDR_LEN];

-

-	strcpy(to, addr2txt(&pc->to));

-	strcpy(from1, addr2txt(&pc->from1));

-	strcpy(from2, addr2txt(&pc->from2));

-	printf("\t%s =%c\t%s\t%s,%s\n", to, p->letter, p->txt, from1, from2);

-}

-

-static void

-ldir(void)

-{

-	struct opdata *p = &optbl[pc->op];

-	char to[ADDR_LEN], from[ADDR_LEN];

-	/* TODO: what type do we use for the size? */

-

-	/* TODO: it is pending */

-}

-

-static void

-store(void)

-{

-	struct opdata *p = &optbl[pc->op];

-	char to[ADDR_LEN], from[ADDR_LEN];

-

-	strcpy(to, addr2txt(&pc->to));

-	strcpy(from, addr2txt(&pc->from1));

-	printf("\t\t%s%c\t%s,%s\n", p->txt, p->letter, from, to);

-}

-

-static void

-unary(void)

-{

-	struct opdata *p = &optbl[pc->op];

-	char to[ADDR_LEN], from[ADDR_LEN];

-

-	strcpy(to, addr2txt(&pc->to));

-	strcpy(from, addr2txt(&pc->from1));

-	printf("\t%s =%c\t%s\t%s\n", to, p->letter, p->txt, from);

-}

-

-static void

-call(void)

-{

-	struct opdata *p = &optbl[pc->op];

-	char to[ADDR_LEN], from[ADDR_LEN];

-	Symbol *sym = pc->to.u.sym;

-

-	strcpy(to, addr2txt(&pc->to));

-	strcpy(from, addr2txt(&pc->from1));

-	printf("\t%s =%s\tcall\t%s(",

-	       to, size2stack(&sym->type), from);

-}

-

-static void

-param(void)

-{

-	Symbol *sym = pc->from2.u.sym;

-

-	printf(optbl[pc->op].txt,

-	       size2stack(&sym->type), addr2txt(&pc->from1));

-}

-

-static void

-ecall(void)

-{

-	struct opdata *p = &optbl[pc->op];

-

-	puts(p->txt);

-}

-

-static void

-ret(void)

-{

-	if (pc->from1.kind == SNONE)

-		puts("\t\tret");

-	else

-		printf("\t\tret\t%s\n", addr2txt(&pc->from1));

-}

-

-static void

-jmp(void)

-{

-	printf("\t\tjmp\t%s\n", addr2txt(&pc->from1));

-}

-

-static void

-branch(void)

-{

-	char to[ADDR_LEN], from1[ADDR_LEN], from2[ADDR_LEN];

-

-	strcpy(to, addr2txt(&pc->to));

-	strcpy(from1, addr2txt(&pc->from1));

-	strcpy(from2, addr2txt(&pc->from2));

-	printf("\t\tjnz\t%s,%s,%s\n", to, from1, from2);

-}

-

-static void

-vastart(void)

-{

-	printf("\t\tvastart %s\n", addr2txt(&pc->from1));

-}

-

-static void

-vaarg(void)

-{

-	Symbol *sym = pc->to.u.sym;

-	Type *tp = &sym->type;

-	char to[ADDR_LEN], from[ADDR_LEN];

-

-	strcpy(to, addr2txt(&pc->to));

-	strcpy(from, addr2txt(&pc->from1));

-	printf("\t\t%s =%s vaarg %s\n", to, size2asm(tp), from);

-}

-

-static void

-asalloc(void)

-{

-	Symbol *sym = pc->to.u.sym;

-	Type *tp = &sym->type;

-	extern Type ptrtype;

-

-	printf("\t%s =%s\talloc%lu\t%lu\n",

-	       symname(sym), size2asm(&ptrtype), tp->align+3 & ~3, tp->size);

-}

-

-static void

-form2local(void)

-{

-	Symbol *sym = pc->to.u.sym;

-	Type *tp = &sym->type;

-	char *name = symname(sym);

-

-	printf("\t\tstore%s\t%s.val,%s\n", size2asm(tp), name, name);

-}

-

-void

-endinit(void)

-{

-	puts("}");

-}

-

-void

-getbblocks(void)

-{

-	Inst *i;

-

-	if (!prog)

-		return;

-

-	prog->flags |= BBENTRY;

-	for (pc = prog; pc; pc = pc->next) {

-		switch (pc->op) {

-		case ASBRANCH:

-			i = pc->from2.u.sym->u.inst;

-			i->flags |= BBENTRY;

-		case ASJMP:

-			i = pc->from1.u.sym->u.inst;

-			i->flags |= BBENTRY;

-		case ASRET:

-			if (pc->next)

-				pc->next->flags |= BBENTRY;

-			break;

-		}

-	}

-}

--- a/src/cmd/cc2/target/qbe/optm.c

+++ /dev/null

@@ -1,58 +1,0 @@

-static char sccsid[] = "@(#) ./cc2/arch/qbe/optm.c";

-

-#include <stddef.h>

-

-#include <scc/scc.h>

-

-#include "../../cc2.h"

-

-Node *

-optm_dep(Node *np)

-{

-	int op = np->op;

-	Node *p, *dst, *next = np->next;

-	Symbol *sym, *osym;

-

-	switch (op) {

-	case OEFUN:

-		/*

-		 * In QBE we need at the end of a basic block

-		 * a jump, so we have to ensure that the last

-		 * statement of the function is a ret, a jmp

-		 * or a branch. In the same way, QBE does

-		 * not accept labels at the end of a function

-		 * (ONOP is used for labels) so we have to add

-		 * a ret there, and in the case of branches

-		 * we need a label for the next statement

-		 */

-		op = (np->prev) ? np->prev->op : 0;

-		if (!op || op == ONOP || op == OBRANCH || (op != ORET && op != OJMP))

-			addstmt(node(ORET), KEEPCUR);

-		break;

-	case OBRANCH:

-		if (!next->label) {

-			sym = getsym(TMPSYM);

-			sym->kind = SLABEL;

-			next->label = sym;

-		}

-	case OJMP:

-		for (;;) {

-			dst = np->u.sym->u.stmt;

-			if (dst->op != OJMP)

-				break;

-			np->u.sym = dst->u.sym;

-		}

-		for (p = np->next; p; p = p->next) {

-			if (p == dst)

-				return NULL;

-			if (p->op == ONOP ||

-			    p->op == OBLOOP ||

-			    p->op == OELOOP) {

-				continue;

-			}

-			break;

-		}

-		break;

-	}

-	return np;

-}

--- a/src/cmd/cc2/target/qbe_amd64-sysv/target.mk

+++ /dev/null

@@ -1,8 +1,0 @@

-OBJ-qbe_amd64-sysv = $(OBJS)  \

-        target/qbe/cgen.o \

-        target/qbe/optm.o \

-        target/qbe/code.o \

-        target/amd64-sysv/types.o

-

-$(LIBEXEC)/cc2-qbe_amd64-sysv: $(OBJ-qbe_amd64-sysv)

-	$(CC) $(SCC_LDFLAGS) $(OBJ-qbe_amd64-sysv) -lscc -o $@

--- a/src/cmd/cc2/target/qbe_arm64-sysv/target.mk

+++ /dev/null

@@ -1,5 +1,0 @@

-OBJ-qbe_arm64-sysv = $(OBJS)  \

-        target/qbe/cgen.o \

-        target/qbe/optm.o \

-        target/qbe/code.o \

-        target/arm64-sysv/types.o \

--- a/src/cmd/cc2/target/z80-scc/arch.h

+++ /dev/null

@@ -1,5 +1,0 @@

-enum asmop {

-	ASJMP = 0,

-	ASRET,

-	ASBRANCH,

-};

--- a/src/cmd/cc2/target/z80-scc/cgen.c

+++ /dev/null

@@ -1,161 +1,0 @@

-static char sccsid[] = "@(#) ./cc2/arch/z80/cgen.c";

-

-#include <stdlib.h>

-

-#include <scc/scc.h>

-

-#include "arch.h"

-#include "../../cc2.h"

-

-static void

-swtch(Node *idx)

-{

-}

-

-static Node *

-rhs(Node *np, Node *ret)

-{

-}

-

-static Node *

-field(Node *np, Node *ret, int islhs)

-{

-}

-

-static Node *

-lhs(Node *np, Node *new)

-{

-	switch (np->op) {

-	case OMEM:

-	case OAUTO:

-		*new = *np;

-		return new;

-	case OPTR:

-		return rhs(np->left, new);

-	case OFIELD:

-		return field(np, new, 1);

-	default:

-		abort();

-	}

-}

-

-static void

-bool(Node *np, Symbol *true, Symbol *false)

-{

-	Node *l = np->left, *r = np->right;

-	Node ret, ifyes, ifno;

-	Symbol *label;

-

-	switch (np->op) {

-	case ONEG:

-		bool(l, false, true);

-		break;

-	case OAND:

-		label = newlabel();

-		bool(l, label, false);

-		setlabel(label);

-		bool(r, true, false);

-		break;

-	case OOR:

-		label = newlabel();

-		bool(l, true, label);

-		setlabel(label);

-		bool(r, true, false);

-		break;

-	default:

-		label2node(&ifyes, true);

-		label2node(&ifno, false);

-		code(ASBRANCH, rhs(np, &ret), &ifyes, &ifno);

-		break;

-	}

-}

-

-Node *

-cgen(Node *np)

-{

-	Node aux, *p, *next;

-

-	setlabel(np->label);

-	switch (np->op) {

-	case OJMP:

-		label2node(&aux, np->u.sym);

-		code(ASJMP, NULL, &aux, NULL);

-		break;

-	case OBRANCH:

-		next = np->next;

-		if (!next->label)

-			next->label = newlabel();

-		bool(np->left, np->u.sym, next->label);

-		break;

-	case ORET:

-		p = np->left;

-		if (p)

-			p = rhs(np->left, &aux);

-		code(ASRET, NULL, p, NULL);

-		break;

-	case OBSWITCH:

-		swtch(rhs(np->left, &aux));

-		break;

-	default:

-		rhs(np, &aux);

-		break;

-	}

-	return NULL;

-}

-

-/*

- * This is strongly influenced by

- * http://plan9.bell-labs.com/sys/doc/compiler.ps (/sys/doc/compiler.ps)

- * calculate addresability as follows

- *     AUTO => 11          value+fp

- *     REG => 13           reg

- *     STATIC => 12        (value)

- *     CONST => 20         $value

- */

-Node *

-sethi(Node *np)

-{

-	Node *lp, *rp;

-

-	if (!np)

-		return np;

-

-	np->complex = 0;

-	np->address = 0;

-	lp = np->left;

-	rp = np->right;

-	switch (np->op) {

-	case OAUTO:

-		np->address = 11;

-		break;

-	case OREG:

-		np->address = 13;

-		break;

-	case OMEM:

-		np->address = 12;

-		break;

-	case OCONST:

-		np->address = 20;

-		break;

-	default:

-		sethi(lp);

-		sethi(rp);

-		break;

-	}

-

-	if (np->address > 10)

-		return np;

-	if (lp)

-		np->complex = lp->complex;

-	if (rp) {

-		int d = np->complex - rp->complex;

-

-		if (d == 0)

-			++np->complex;

-		else if (d < 0)

-			np->complex = rp->complex;

-	}

-	if (np->complex == 0)

-		++np->complex;

-	return np;

-}

--- a/src/cmd/cc2/target/z80-scc/code.c

+++ /dev/null

@@ -1,229 +1,0 @@

-static char sccsid[] = "@(#) ./cc2/arch/z80/code.c";

-

-#include <stdio.h>

-#include <stdlib.h>

-

-#include <scc/cstd.h>

-#include <scc/scc.h>

-

-#include "arch.h"

-#include "../../cc2.h"

-

-enum segment {

-	CODESEG,

-	DATASEG,

-	BSSSEG,

-	NOSEG

-};

-

-static int curseg = NOSEG;

-static unsigned long offpar, offvar;

-

-static void

-segment(int seg)

-{

-	static char *txt[] = {

-		[CODESEG] = "\tCSEG\n",

-		[DATASEG] = "\tDSEG\n",

-		[BSSSEG] = "\tASEG\n",

-	};

-

-	if (seg == curseg)

-		return;

-	fputs(txt[seg], stdout);

-	curseg = seg;

-}

-

-static char *

-symname(Symbol *sym)

-{

-	static char name[INTIDENTSIZ+1];

-

-	if (sym->name) {

-		switch (sym->kind) {

-		case SGLOB:

-		case SEXTRN:

-			snprintf(name, sizeof(name), "_%s", sym->name);

-			return name;

-		case SPRIV:

-			return sym->name;

-		}

-	}

-

-	sprintf(name, ".%d", sym->numid);

-

-	return name;

-}

-

-static void

-label(Symbol *sym)

-{

-	int seg;

-	char *name = symname(sym);

-

-	if (sym->type.flags & FUNF)

-		seg = CODESEG;

-	else if (sym->type.flags & INITF)

-		seg = DATASEG;

-	else

-		seg = BSSSEG;

-	segment(seg);

-

-	switch (sym->kind) {

-	case SEXTRN:

-		printf("\tEXTRN\t%s\n", name);

-		return;

-	case SGLOB:

-		printf("\tPUBLIC\t%s\n", name);

-		break;

-	}

-

-	printf("%s:\n", name);

-}

-

-static void

-emitconst(Node *np)

-{

-	switch (np->type.size) {

-	case 1:

-		printf("%d", (int) np->u.i & 0xFF);

-		break;

-	case 2:

-		printf("%d", (int) np->u.i & 0xFFFF);

-		break;

-	case 4:

-		printf("%ld", (long) np->u.i & 0xFFFFFFFF);

-		break;

-	default:

-		abort();

-	}

-}

-

-static void

-emittree(Node *np)

-{

-	if (!np)

-		return;

-

-	switch (np->op) {

-	case OSTRING:

-		printf("\"%s\"", np->u.s);

-		free(np->u.s);

-		np->u.s = NULL;

-		break;

-	case OCONST:

-		emitconst(np);

-		break;

-	case OADDR:

-		emittree(np->left);

-		break;

-	case OMEM:

-		fputs(symname(np->u.sym), stdout);

-		break;

-	default:

-		emittree(np->left);

-		printf(" %c ", np->op);

-		emittree(np->right);

-		break;

-	}

-}

-

-static void

-size2asm(Type *tp)

-{

-	char *s;

-

-	/*

-	 * In z80 we can ignore the alignment

-	 */

-	if (tp->flags & STRF) {

-		s = "\tDB\t";

-	} else {

-		switch (tp->size) {

-		case 1:

-			s = "\tDB\t";

-			break;

-		case 2:

-			s = "\tDW\t";

-			break;

-		case 4:

-			s = "\tDD\t";

-			break;

-		default:

-			s = "\tDS\t%lu,";

-			break;

-		}

-	}

-	printf(s, tp->size);

-}

-

-void

-newfun()

-{

-	offpar = offvar = 0;

-}

-

-void

-defpar(Symbol *sym)

-{

-	unsigned long align, size;

-

-	if (sym->kind != SREG && sym->kind != SAUTO)

-		return;

-	align = sym->type.align;

-	size = sym->type.size;

-

-	offpar -= align-1 & ~align;

-	sym->u.off = offpar;

-	offpar -= size;

-	sym->kind = SAUTO;

-}

-

-void

-defvar(Symbol *sym)

-{

-	unsigned long align, size;

-

-	if (sym->kind != SREG && sym->kind != SAUTO)

-		return;

-	align = sym->type.align;

-	size = sym->type.size;

-

-	offvar += align-1 & ~align;

-	sym->u.off = offvar;

-	offvar += size;

-	sym->kind = SAUTO;

-}

-

-void

-defglobal(Symbol *sym)

-{

-	label(sym);

-	if (sym->kind == SEXTRN || (sym->type.flags & INITF))

-		return;

-	size2asm(&sym->type);

-	puts("0");

-}

-

-void

-data(Node *np)

-{

-	size2asm(&np->type);

-	emittree(np);

-	putchar('\n');

-}

-

-void

-writeout(void)

-{

-}

-

-void

-endinit(void)

-{

-}

-

-void

-getbblocks(void)

-{

-}

--- a/src/cmd/cc2/target/z80-scc/optm.c

+++ /dev/null

@@ -1,11 +1,0 @@

-static char sccsid[] = "@(#) ./cc2/arch/z80/optm.c";

-

-#include <scc/scc.h>

-

-#include "../../cc2.h"

-

-Node *

-optm_dep(Node *np)

-{

-	return np;

-}

--- a/src/cmd/cc2/target/z80-scc/target.mk

+++ /dev/null

@@ -1,8 +1,0 @@

-OBJ-z80-scc = $(OBJS)  \

-        target/z80-scc/cgen.o \

-        target/z80-scc/optm.o \

-        target/z80-scc/code.o \

-        target/z80-scc/types.o \

-

-$(LIBEXEC)/cc2-z80-scc: $(OBJ-z80-scc)

-	$(CC) $(SCC_LDFLAGS) $(OBJ-z80-scc) -lscc -o $@

--- a/src/cmd/cc2/target/z80-scc/types.c

+++ /dev/null

@@ -1,95 +1,0 @@

-static char sccsid[] = "@(#) ./cc2/arch/z80/types.c";

-

-#include <scc/scc.h>

-

-#include "../../cc2.h"

-

-

-Type int8type = {

-	.flags  = SIGNF | INTF,

-	.size   = 1,

-	.align  = 1

-};

-

-Type int16type = {

-	.flags  = SIGNF | INTF,

-	.size   = 2,

-	.align  = 1

-};

-

-Type int32type = {

-	.flags  = SIGNF | INTF,

-	.size   = 4,

-	.align  = 1

-};

-

-Type int64type = {

-	.flags  = SIGNF | INTF,

-	.size   = 8,

-	.align  = 1

-};

-

-Type uint8type = {

-	.flags  = INTF,

-	.size   = 1,

-	.align  = 1

-};

-

-Type uint16type = {

-	.flags  = INTF,

-	.size   = 2,

-	.align  = 1

-};

-

-Type uint32type = {

-	.flags  = INTF,

-	.size   = 4,

-	.align  = 1

-};

-

-Type uint64type = {

-	.flags  = INTF,

-	.size   = 8,

-	.align  = 1

-};

-

-Type ptrtype = {

-	.flags  = INTF,

-	.size   = 2,

-	.align  = 1

-};

-

-Type booltype = {

-	.flags  = INTF,

-	.size   = 1,

-	.align  = 1

-};

-

-Type float32type = {

-	.flags  = FLOATF,

-	.size   = 4,

-	.align  = 1

-};

-

-Type float64type = {

-	.flags  = FLOATF,

-	.size   = 4,

-	.align  = 1

-};

-

-Type float80type = {

-	.flags  = FLOATF,

-	.size   = 4,

-	.align  = 1

-};

-

-Type voidtype = {

-	.size = 0,

-	.align = 0

-};

-

-/* this types is not going to be used in this arch */

-Type arg_type = {

-        .size = 0,

-        .align = 0

-};

--- /dev/null

+++ b/src/cmd/scc/Makefile

@@ -1,0 +1,14 @@

+.POSIX:

+

+PROJECTDIR = ../../..

+include $(PROJECTDIR)/scripts/rules.mk

+

+DIRS = cc1 cc2 $(DRIVER)

+

+all: $(DIRS)

+

+$(DIRS): FORCE

+	+@cd $@ && $(MAKE)

+

+clean:

+	$(FORALL)

--- /dev/null

+++ b/src/cmd/scc/cc1/Makefile

@@ -1,0 +1,38 @@

+.POSIX:

+

+PROJECTDIR = ../../../..

+include $(PROJECTDIR)/scripts/rules.mk

+

+OBJS = types.o \

+       decl.o \

+       lex.o \

+       error.o \

+       symbol.o \

+       main.o \

+       expr.o \

+       code.o \

+       stmt.o \

+       cpp.o \

+       fold.o \

+       init.o \

+       builtin.o \

+

+TARGET   = $(LIBEXEC)/cc1-amd64-sysv \

+           $(LIBEXEC)/cc1-arm64-sysv \

+           $(LIBEXEC)/cc1-i386-sysv \

+           $(LIBEXEC)/cc1-z80-scc \

+

+all: $(TARGET)

+

+$(TARGET): $(LIBDIR)/libscc.a

+

+dep: inc-dep

+

+clean:

+	rm -f target/*/*.o

+

+include target/amd64-sysv/arch.mk

+include target/arm64-sysv/arch.mk

+include target/i386-sysv/arch.mk

+include target/z80-scc/arch.mk

+include deps.mk

--- /dev/null

+++ b/src/cmd/scc/cc1/TODO

@@ -1,0 +1,14 @@

+* Implement bitfields

+* Rewrite error recovery code, and ensure correct state after recovery

+* Parse correctly all integer and float constants

+* Add C99 features (almost all the new features of C99 are missed)

+* Add correct emit for any kind of constant

+* Add warning when some ANSI limit is violated.

+* Free memory in emit after some error happened.

+* Rewrite initializers to deal with the idea of  "current object"

+* Add some test about pointer airthmetic.

+* Merge all the definitions of the same string

+* Do not assign identifierss until symbols are emitted. This change will

+  avoid identifiers that are not emitted.

+* Fix assignation abbreviations. They fail whe lhs type is smaller than

+  the type in rhs

--- /dev/null

+++ b/src/cmd/scc/cc1/builtin.c

@@ -1,0 +1,121 @@

+static char sccsid[] = "@(#) ./cc1/builtin.c";

+

+#include <stdio.h>

+

+#include <scc/scc.h>

+#include "cc1.h"

+

+static Node *

+builtin_va_arg(Symbol *sym)

+{

+	Node *np, *ap;

+	Type *tp;

+

+	ap = assign();

+	expect(',');

+	tp = typename();

+

+	if (!valid_va_list(ap->type)) {

+		errorp("incorrect parameters for va_arg");

+		goto error;

+	}

+	if (tp == booltype ||

+	    tp == chartype || tp == uchartype || tp == schartype ||

+	    tp == shortype || tp == ushortype) {

+		warn("bool, char and short are promoted to int when passed through '...'");

+		tp = (tp->prop & TSIGNED) ? inttype : uinttype;

+	}

+

+	np = node(OBUILTIN, tp, ap, NULL);

+	np->sym = sym;

+	return np;

+

+error:

+	return constnode(zero);

+}

+

+static Node *

+builtin_va_copy(Symbol *sym)

+{

+	Node *np, *src, *dst;

+

+	dst = assign();

+	expect(',');

+	src = assign();

+

+	if (!valid_va_list(dst->type) || !valid_va_list(src->type)) {

+		errorp("incorrect parameters for va_copy");

+		return constnode(zero);

+	}

+

+	np = node(OBUILTIN, voidtype, dst, src);

+	np->sym = sym;

+	return np;

+}

+

+static Node *

+builtin_va_start(Symbol *sym)

+{

+	Node *np, *ap, *last;

+	Symbol **p;

+	Type *tp;

+

+	ap = assign();

+	expect(',');

+	last = assign();

+	if (last->op != OSYM)

+		goto error;

+

+	if (!valid_va_list(ap->type) || !(last->sym->flags&SDECLARED))

+		 goto error;

+

+	for (p = curfun->u.pars; p && *p != last->sym; ++p)

+		;

+	if (!p || *p == NULL || p[1] == NULL || p[1]->type != ellipsistype)

+		warn("second parameter of 'va_start' not last named argument");

+

+	tp = last->type;

+	if (tp == booltype ||

+	    tp == chartype || tp == uchartype || tp == schartype ||

+	    tp == shortype || tp == ushortype) {

+		warn("last parameter before '...' must not be bool, char or short");

+	}

+

+	np = node(OBUILTIN, voidtype, ap, last);

+	np->sym = sym;

+	return np;

+

+error:

+	errorp("incorrect parameters for va_start");

+	return constnode(zero);

+}

+

+static Node *

+builtin_va_end(Symbol *sym)

+{

+	Node *ap, *np;

+

+	ap = assign();

+

+	if (!valid_va_list(ap->type)) {

+		errorp("incorrect parameters for va_end");

+		return constnode(zero);

+	}

+

+	np = node(OBUILTIN, voidtype, ap, NULL);

+	np->sym = sym;

+	return np;

+}

+

+void

+ibuilts(void)

+{

+	struct builtin built[] = {

+		{"__builtin_va_arg", builtin_va_arg},

+		{"__builtin_va_copy", builtin_va_copy},

+		{"__builtin_va_start", builtin_va_start},

+		{"__builtin_va_end", builtin_va_end},

+		{NULL}

+	};

+	builtins(built);

+}

--- /dev/null

+++ b/src/cmd/scc/cc1/cc1.h

@@ -1,0 +1,496 @@

+#define INPUTSIZ LINESIZ

+

+#define GLOBALCTX 0

+#define PARAMCTX  1

+

+#define NR_USWITCHES 20

+

+/*

+ * Definition of enumerations

+ */

+enum {

+	NOALLOC,

+	ALLOC

+};

+

+enum typeprops {

+	TDEFINED = 1 << 0,    /* type defined */

+	TSIGNED  = 1 << 1,    /* signedness of the type */

+	TINTEGER = 1 << 2,    /* the type is INT of enum */

+	TARITH   = 1 << 3,    /* the type is INT, ENUM or FLOAT */

+	TAGGREG  = 1 << 4,    /* the type is struct or union */

+	TK_R     = 1 << 5,    /* this is a K&R-function */

+	TELLIPSIS= 1 << 6,    /* this function has an ellipsis par */

+	TFUNDEF  = 1 << 7,    /* function definition */

+};

+

+enum inputtype {

+	IMACRO = 1 << 0,      /* macro expansion type */

+	IFILE  = 1 << 1,      /* input file type */

+	ISTDIN = 1 << 2,      /* stdin type */

+	IEOF   = 1 << 3,      /* EOF mark */

+	ITYPE  = IMACRO | IFILE | ISTDIN,

+};

+

+/* data type letters */

+enum ns {

+	L_INT8      = 'C',

+	L_INT16     = 'I',

+	L_INT32     = 'W',

+	L_INT64     = 'Q',

+	L_UINT8     = 'K',

+	L_UINT16    = 'N',

+	L_UINT32    = 'Z',

+	L_UINT64    = 'O',

+	L_BOOL      = 'B',

+

+	L_FLOAT     = 'J',

+	L_DOUBLE    = 'D',

+	L_LDOUBLE   = 'H',

+

+	L_ELLIPSIS  = 'E',

+	L_VOID      = '0',

+	L_POINTER   = 'P',

+	L_FUNCTION  = 'F',

+	L_ARRAY     = 'V',

+	L_UNION     = 'U',

+	L_STRUCT    = 'S',

+	L_VA_ARG    = '1',

+};

+

+/* recovery points */

+enum {

+	END_DECL,

+	END_LDECL,

+	END_COMP,

+	END_COND

+};

+

+/* type constructors */

+enum typeop {

+	FTN = 1,

+	PTR,

+	ARY,

+	KRFTN

+};

+

+/* namespaces */

+enum namespaces {

+	NS_DUMMY,

+	NS_IDEN,

+	NS_TAG,

+	NS_LABEL,

+	NS_CPP,

+	NS_KEYWORD,

+	NS_CPPCLAUSES,

+	NS_STRUCTS

+};

+

+/* symbol flags */

+enum {

+	SAUTO     = 1 << 0,

+	SREGISTER = 1 << 1,

+	SDECLARED = 1 << 2,

+	SFIELD    = 1 << 3,

+	SEXTERN   = 1 << 4,

+	SUSED     = 1 << 5,

+	SCONSTANT = 1 << 6,

+	SGLOBAL   = 1 << 7,

+	SPRIVATE  = 1 << 8,

+	SLOCAL    = 1 << 9,

+	SEMITTED  = 1 << 10,

+	SDEFINED  = 1 << 11,

+	SSTRING   = 1 << 12,

+	STYPEDEF  = 1 << 13,

+	SINITLST  = 1 << 14,

+	SHASINIT  = 1 << 15

+};

+

+/* node flags */

+enum {

+	NLVAL   = 1 << 0,

+	NCONST  = 1 << 1,

+	NEFFECT = 1 << 2

+};

+

+/* lexer mode, compiler or preprocessor directive */

+enum {

+	CCMODE,

+	CPPMODE

+};

+

+/* input tokens */

+enum tokens {

+	CONST      = 1 << 0,      /* type qualifier tokens are used as flags */

+	RESTRICT   = 1 << 1,

+	VOLATILE   = 1 << 2,

+	INLINE     = 1 << 3,

+	TQUALIFIER = 1 << 7,      /* this value is picked outside of ASCII range */

+	TYPE,

+	IDEN,

+	SCLASS,

+	CONSTANT,

+	STRING,

+	SIZEOF,

+	INDIR,

+	INC,

+	DEC,

+	SHL,

+	SHR,

+	LE,

+	GE,

+	EQ,

+	NE,

+	AND,

+	OR,

+	MUL_EQ,

+	DIV_EQ,

+	MOD_EQ,

+	ADD_EQ,

+	SUB_EQ,

+	AND_EQ,

+	XOR_EQ,

+	OR_EQ,

+	SHL_EQ,

+	SHR_EQ,

+	ELLIPSIS,

+	CASE,

+	DEFAULT,

+	IF,

+	ELSE,

+	SWITCH,

+	WHILE,

+	DO,

+	FOR,

+	GOTO,

+	VOID,

+	FLOAT,

+	INT,

+	BOOL,

+	VA_LIST,

+	STRUCT,

+	UNION,

+	CHAR,

+	DOUBLE,

+	SHORT,

+	LONG,

+	LLONG,

+	COMPLEX,

+	TYPEDEF,

+	EXTERN,

+	STATIC,

+	AUTO,

+	REGISTER,

+	ENUM,

+	TYPEIDEN,

+	UNSIGNED,

+	SIGNED,

+	CONTINUE,

+	BREAK,

+	RETURN,

+	DEFINE,

+	INCLUDE,

+	LINE,

+	PRAGMA,

+	ERROR,

+	IFDEF,

+	ELIF,

+	IFNDEF,

+	UNDEF,

+	ENDIF,

+	BUILTIN,

+	EOFTOK

+};

+

+/* operations */

+enum op {

+	OADD,

+	OMUL,

+	OSUB,

+	OINC,

+	ODEC,

+	ODIV,

+	OMOD,

+	OSHL,

+	OSHR,

+	OBAND,

+	OBXOR,

+	OBOR,

+	OSNEG,

+	ONEG,

+	OCPL,

+	OAND,

+	OOR,

+	OEQ,

+	ONE,

+	OLT,

+	OGE,

+	OLE,

+	OGT,

+	OASSIGN,

+	OA_MUL,

+	OA_DIV,

+	OA_MOD,

+	OA_ADD,

+	OA_SUB,

+	OA_SHL,

+	OA_SHR,

+	OA_AND,

+	OA_XOR,

+	OA_OR,

+	OADDR,

+	OCOMMA,

+	OCAST,

+	OPTR,

+	OSYM,

+	OASK,

+	OCOLON,

+	OFIELD,

+	OLABEL,

+	ODEFAULT,

+	OCASE,

+	OJUMP,

+	OBRANCH,

+	OEXPR,

+	OEFUN,

+	OELOOP,

+	OBLOOP,

+	OFUN,

+	OPAR,

+	OCALL,

+	OCALLE,

+	ORET,

+	ODECL,

+	OBSWITCH,

+	OESWITCH,

+	OINIT,

+	OBUILTIN,

+	OTYP,

+};

+

+/*

+ * Definition of structures

+ */

+typedef struct type Type;

+typedef struct symbol Symbol;

+typedef struct swtch Switch;

+typedef struct node Node;

+typedef struct input Input;

+

+struct limits {

+	union {

+		TUINT i;

+		TFLOAT f;

+	} max;

+	union {

+		TUINT i;

+		TFLOAT f;

+	} min;

+};

+

+struct builtin {

+	char *str;

+	Node *(*fun)(Symbol *);

+};

+

+struct keyword {

+	char *str;

+	unsigned char token, value;

+};

+

+struct type {

+	unsigned char op;           /* type builder operator */

+	unsigned char ns;           /* namespace for struct members */

+	short id;                   /* type id, used in dcls */

+	char letter;                /* letter of the type */

+	unsigned char prop;         /* type properties */

+	unsigned char align;        /* align of the type */

+	unsigned long size;         /* sizeof the type */

+	Type *type;                 /* base type */

+	Symbol *tag;                /* symbol of the strug tag */

+	union {

+		Type **pars;            /* Function type parameters */

+		Symbol **fields;        /* fields of aggregate type */

+	} p;

+	union {

+		unsigned char rank;     /* convertion rank */

+		TINT elem;              /* number of type parameters */

+	} n;

+	Type *next;                 /* local list pointer */

+	Type *h_next;               /* hash collision list */

+};

+

+struct symbol {

+	unsigned char ctx;

+	unsigned char hide;

+	char ns;

+	unsigned short id;

+	unsigned short flags;

+	char *name;

+	Type *type;

+	unsigned char token;

+	union {

+		TINT i;

+		TUINT u;

+		TFLOAT f;

+		char *s;

+		unsigned char token;

+		Node **init;

+		Symbol **pars;

+		Node *(*fun)(Symbol *);

+	} u;

+	struct symbol *next;

+	struct symbol *hash;

+};

+

+struct node {

+	unsigned char op;

+	unsigned char flags;

+	Type *type;

+	Symbol *sym;

+	struct node *left, *right;

+};

+

+struct swtch {

+	short nr;

+	char hasdef;

+};

+

+struct yystype {

+	Symbol *sym;

+	unsigned char token;

+};

+

+#ifdef stdin

+struct input {

+	char flags;

+	unsigned lineno;

+	char *filenam;

+	FILE *fp;

+	Symbol *hide;

+	char *line, *begin, *p;

+	struct input *next;

+};

+#endif

+

+/* error.c */

+extern void error(char *fmt, ...);

+extern void warn(char *fmt, ...);

+extern void unexpected(void);

+extern void errorp(char *fmt, ...);

+extern void cpperror(char *fmt, ...);

+extern Type *deftype(Type *tp);

+

+/* types.c */

+extern int eqtype(Type *tp1, Type *tp2, int eqflag);

+extern Type *ctype(int type, int sign, int size);

+extern Type *mktype(Type *tp, int op, TINT nelem, Type *data[]);

+extern Type *duptype(Type *base);

+extern struct limits *getlimits(Type *tp);

+extern void typesize(Type *tp);

+extern void flushtypes(void);

+

+/* symbol.c */

+extern void dumpstab(Symbol **tbl, char *msg);

+extern Symbol *lookup(int ns, char *name, int alloc);

+extern Symbol *nextsym(Symbol *sym, int ns);

+extern Symbol *install(int ns, Symbol *sym);

+extern Symbol *newsym(int ns, char *name);

+extern void pushctx(void), popctx(void);

+extern void killsym(Symbol *sym);

+extern Symbol *newlabel(void);

+extern void keywords(struct keyword *key, int ns);

+extern void builtins(struct builtin *builts);

+extern Symbol *newstring(char *s, size_t len);

+extern unsigned newid(void);

+

+/* stmt.c */

+extern void compound(Symbol *lbreak, Symbol *lcont, Switch *sw);

+

+/* decl.c */

+extern Type *typename(void);

+extern void decl(void);

+

+/* lex.c */

+extern int ahead(void);

+extern int next(void);

+extern void expect(int tok);

+extern void discard(void);

+extern void addinput(char *fname, Symbol *hide, char *buffer);

+extern void delinput(void);

+extern void setsafe(int type);

+extern void ilex(void);

+extern void setloc(char *fname, unsigned line);

+#define accept(t) ((yytoken == (t)) ? next() : 0)

+

+/* code.c */

+extern void prtree(Node *np);

+extern void emit(int, void *);

+extern Node *node(int op, Type *tp, Node *left, Node *rigth);

+extern Node *varnode(Symbol *sym);

+extern Node *constnode(Symbol *sym);

+extern Node *sizeofnode(Type *tp);

+extern void freetree(Node *np);

+extern void icode(void);

+#define BTYPE(np) ((np)->type->op)

+

+/* fold.c */

+extern Node *simplify(Node *np);

+extern TUINT ones(int nbytes);

+

+/* expr.c */

+extern Node *decay(Node *), *negate(Node *np), *assign(void);

+extern Node *convert(Node *np, Type *tp1, int iscast);

+extern Node *constexpr(void), *condexpr(int neg), *expr(void);

+extern int isnodecmp(int op);

+extern int negop(int op);

+extern int cmpnode(Node *np, TUINT val);

+

+/* init.c */

+extern void initializer(Symbol *sym, Type *tp);

+extern Node *initlist(Type *tp);

+

+/* cpp.c */

+extern void icpp(void);

+extern int cpp(void);

+extern int expand(char *begin, Symbol *sym);

+extern void incdir(char *dir);

+extern void outcpp(void);

+extern void defdefine(char *macro, char *val, char *source);

+extern void undefmacro(char *s);

+extern void ppragmaln(void);

+

+/* builtin.c */

+extern void ibuilts(void);

+

+/* arch.c */

+extern void iarch(void);

+extern int valid_va_list(Type *tp);

+

+/*

+ * Definition of global variables

+ */

+extern struct yystype yylval;

+extern char yytext[];

+extern int yytoken;

+extern unsigned short yylen;

+extern int disexpand;

+extern unsigned cppctx;

+extern Input *input;

+extern int lexmode, namespace;

+extern int onlycpp, onlyheader;

+extern unsigned curctx;

+extern Symbol *curfun, *zero, *one;

+extern char *infile;

+extern unsigned lineno;

+extern char filenam[];

+

+extern Type *voidtype, *pvoidtype, *booltype,

+            *uchartype,   *chartype, *schartype,

+            *uinttype,    *inttype,

+            *sizettype, *pdifftype,

+            *ushortype,   *shortype,

+            *longtype,    *ulongtype,

+            *ullongtype,  *llongtype,

+            *floattype,   *doubletype,  *ldoubletype,

+            *ellipsistype, *va_list_type, *va_type;

--- /dev/null

+++ b/src/cmd/scc/cc1/code.c

@@ -1,0 +1,550 @@

+static char sccsid[] = "@(#) ./cc1/code.c";

+#include <ctype.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <stdarg.h>

+

+#include <scc/scc.h>

+#include "cc1.h"

+

+static void emitbin(int, void *),

+            emitcast(int, void *),

+            emitsym(int, void *),

+            emitexp(int, void *),

+            emitsymid(int, void *),

+            emittext(int, void *),

+            emitfun(int, void *),

+            emitdcl(int, void *),

+            emitinit(int, void *),

+            emittype(int, void *),

+            emitbuilt(int, void *);

+

+char *optxt[] = {

+	[OADD] = "+",

+	[OSUB] = "-",

+	[OMUL] = "*",

+	[OINC] = ":i",

+	[ODEC] =  ":d",

+	[OPTR] = "@",

+	[OMOD] = "%",

+	[ODIV] = "/",

+	[OSHL] = "l",

+	[OSHR]  = "r",

+	[OLT] = "<",

+	[OGT] = ">",

+	[OGE] = "]",

+	[OLE] =  "[",

+	[OEQ] = "=",

+	[ONE] = "!",

+	[OBAND] = "&",

+	[OBXOR]  = "^",

+	[OBOR] = "|",

+	[OASSIGN] = ":",

+	[OA_MUL] = ":*",

+	[OA_DIV] = ":/",

+	[OA_MOD] = ":%",

+	[OA_ADD] = ":+",

+	[OA_SUB] = ":-",

+	[OA_SHL] = ":l",

+	[OA_SHR] = ":r",

+	[OA_AND] = ":&",

+	[OA_XOR] = ":^",

+	[OA_OR] = ":|",

+	[OADDR] = "'",

+	[OSNEG] = "_",

+	[ONEG] = "n",

+	[OCPL] = "~",

+	[OAND] = "a",

+	[OOR] = "o",

+	[OASK] = "?",

+	[OCOMMA] = ",",

+	[OLABEL] = "L%d\n",

+	[ODEFAULT] = "\tf\tL%d\n",

+	[OBSWITCH] = "\ts",

+	[OESWITCH] = "\tt\tL%d\n",

+	[OCASE] = "\tv\tL%d",

+	[OJUMP] = "\tj\tL%d\n",

+	[OBRANCH] = "\ty\tL%d",

+	[OEFUN] = "}\n",

+	[OELOOP] = "\tb\n",

+	[OBLOOP] = "\te\n",

+	[ORET] = "\th",

+	[OPAR] = "p",

+	[OCALL] = "c",

+	[OCALLE] = "z",

+	[OFIELD] = "."

+};

+

+void (*opcode[])(int, void *) = {

+	[OADD] = emitbin,

+	[OSUB] = emitbin,

+	[OMUL] = emitbin,

+	[OINC] = emitbin,

+	[ODEC] =  emitbin,

+	[OPTR] = emitbin,

+	[OMOD] = emitbin,

+	[ODIV] = emitbin,

+	[OSHL] = emitbin,

+	[OSHR]  = emitbin,

+	[OLT] = emitbin,

+	[OGT] = emitbin,

+	[OGE] = emitbin,

+	[OLE] =  emitbin,

+	[OEQ] = emitbin,

+	[ONE] = emitbin,

+	[OBAND] = emitbin,

+	[OBXOR]  = emitbin,

+	[OBOR] = emitbin,

+	[OASSIGN] = emitbin,

+	[OA_MUL] = emitbin,

+	[OA_DIV] = emitbin,

+	[OA_MOD] = emitbin,

+	[OA_ADD] = emitbin,

+	[OA_SUB] = emitbin,

+	[OA_SHL] = emitbin,

+	[OA_SHR] = emitbin,

+	[OA_AND] = emitbin,

+	[OA_XOR] = emitbin,

+	[OA_OR] = emitbin,

+	[OADDR] = emitbin,

+	[OSNEG] = emitbin,

+	[ONEG] = emitbin,

+	[OCPL] = emitbin,

+	[OAND] = emitbin,

+	[OOR] = emitbin,

+	[OCOMMA] = emitbin,

+	[OCAST] = emitcast,

+	[OSYM] = emitsym,

+	[OASK] = emitbin,

+	[OCOLON] = emitbin,

+	[OFIELD]= emitbin,

+	[OEXPR] = emitexp,

+	[OLABEL] = emitsymid,

+	[ODEFAULT] = emitsymid,

+	[OCASE] = emitsymid,

+	[OJUMP] = emitsymid,

+	[OBRANCH] = emitsymid,

+	[OEFUN] = emittext,

+	[OELOOP] = emittext,

+	[OBLOOP] = emittext,

+	[OFUN] = emitfun,

+	[ORET] = emittext,

+	[ODECL] = emitdcl,

+	[OBSWITCH] = emittext,

+	[OESWITCH] = emitsymid,

+	[OPAR] = emitbin,

+	[OCALL] = emitbin,

+	[OCALLE] = emitbin,

+	[OINIT] = emitinit,

+	[OBUILTIN] = emitbuilt,

+	[OTYP] = emittype,

+};

+

+static FILE *outfp;

+

+void

+icode(void)

+{

+	outfp = stdout;

+}

+

+void

+freetree(Node *np)

+{

+	if (!np)

+		return;

+	freetree(np->left);

+	freetree(np->right);

+	free(np);

+}

+

+static void

+emitnode(Node *np)

+{

+	if (np)

+		(*opcode[np->op])(np->op, np);

+}

+

+void

+prtree(Node *np)

+{

+	outfp = stderr;

+	fputs("DBG prtree", outfp);

+	emitnode(np);

+	putc('\n', outfp);

+	outfp = stdout;

+}

+

+void

+emit(int op, void *arg)

+{

+	extern int failure;

+

+	if (failure || onlycpp || onlyheader)

+		return;

+	(*opcode[op])(op, arg);

+}

+

+static void

+emitvar(Symbol *sym)

+{

+	int c;

+	short flags = sym->flags;

+

+	if (flags & SLOCAL)

+		c = 'T';

+	else if (flags & SPRIVATE)

+		c =  'Y';

+	else if (flags & SGLOBAL)

+		c = 'G';

+	else if (flags & SREGISTER)

+		c = 'R';

+	else if (flags & SFIELD)

+		c = 'M';

+	else if (flags & SEXTERN)

+		c = 'X';

+	else

+		c = 'A';

+	fprintf(outfp, "%c%u", c, sym->id);

+}

+

+static void

+emitconst(Node *np)

+{

+	Symbol *sym = np->sym;

+	Type *tp = np->type;

+	TUINT u;

+

+	switch (tp->op) {

+	case PTR:

+	case INT:

+	case ENUM:

+		u = (tp->prop & TSIGNED) ? (TUINT) sym->u.i : sym->u.u;

+		fprintf(outfp,

+		        "#%c%llX",

+		        np->type->letter,

+		        (long long) u & ones(tp->size));

+		break;

+	default:

+		abort();

+	}

+}

+

+static void

+emitsym(int op, void *arg)

+{

+	Node *np = arg;

+

+	if ((np->sym->flags & SINITLST) == 0) {

+		/*

+		 * When we have a compound literal we are going

+		 * to call to emitnode for every element of it,

+		 * and it means that we will have two '\t'

+		 * for the first element

+		 */

+		putc('\t', outfp);

+	}

+	(np->flags & NCONST) ? emitconst(np) : emitvar(np->sym);

+}

+

+static void

+emitletter(Type *tp)

+{

+	int letter;

+

+	letter = (tp->prop&TELLIPSIS) ? 'E' : tp->letter;

+	putc(letter, outfp);

+	switch (tp->op) {

+	case ARY:

+	case STRUCT:

+	case UNION:

+		fprintf(outfp, "%u", tp->id);

+	}

+}

+

+static void

+emittype(int op, void *arg)

+{

+	TINT n;

+	Symbol **sp;

+	char *tag;

+	Type *tp = arg;

+

+	if (!(tp->prop & TDEFINED))

+		return;

+

+	switch (tp->op) {

+	case ARY:

+		emitletter(tp);

+		putc('\t', outfp);

+		emitletter(tp->type);

+		fprintf(outfp,

+		        "\t#%c%llX\n",

+		        sizettype->letter, (long long) tp->n.elem);

+		return;

+	case UNION:

+	case STRUCT:

+		emitletter(tp);

+		tag = tp->tag->name;

+		fprintf(outfp,

+		       "\t\"%s\t#%c%lX\t#%c%X\n",

+		       (tag) ? tag : "",

+		       sizettype->letter,

+		       tp->size,

+		       sizettype->letter,

+		       tp->align);

+		n = tp->n.elem;

+		for (sp = tp->p.fields; n-- > 0; ++sp)

+			emit(ODECL, *sp);

+		break;

+	case PTR:

+	case FTN:

+	case ENUM:

+		return;

+	default:

+		abort();

+	}

+}

+

+static void

+emitstring(Symbol *sym, Type *tp)

+{

+	char *bp, *s, *lim;

+	int n;

+

+	bp = sym->u.s;

+	lim = &sym->u.s[tp->n.elem];

+	while (bp < lim) {

+		s = bp;

+		while (bp < lim && isprint(*bp))

+			++bp;

+		if ((n = bp - s) > 1)

+			fprintf(outfp, "\t#\"%.*s\n", n, s);

+		else

+			bp = s;

+		if (bp == lim)

+			break;

+		do {

+			fprintf(outfp,

+			        "\t#%c%02X\n",

+			        chartype->letter, (*bp++) & 0xFF);

+		} while (bp < lim && !isprint(*bp));

+	}

+}

+

+static void

+emitdesig(Node *np, Type *tp)

+{

+	Symbol *sym;

+	size_t n; /* TODO: This should be SIZET */

+	Node *aux;

+	Type *p;

+

+	if (!np) {

+		sym = NULL;

+	} else {

+		if (!np->sym)

+			goto emit_expression;

+		sym = np->sym;

+		if (sym->flags & SSTRING) {

+			emitstring(sym, tp);

+			return;

+		}

+		if ((sym->flags & SINITLST) == 0)

+			goto emit_expression;

+	}

+

+	switch (tp->op) {

+	case PTR:

+	case INT:

+	case ENUM:

+		aux = (sym) ? *sym->u.init : convert(constnode(zero), tp, 0);

+		emitexp(OEXPR, aux);

+		break;

+	case UNION:

+		n = tp->n.elem-1;

+		aux = (sym) ? sym->u.init[0] : NULL;

+		emitdesig(aux, aux->type);

+		break;

+	case STRUCT:

+	case ARY:

+		for (n = 0; n < tp->n.elem; ++n) {

+			aux = (sym) ? sym->u.init[n] : NULL;

+			p = (tp->op == ARY) ? tp->type : tp->p.fields[n]->type;

+			emitdesig(aux, p);

+		}

+		break;

+	default:

+		abort();

+	}

+

+	if (sym) {

+		free(sym->u.init);

+		sym->u.init = NULL;

+	}

+	freetree(np);

+	return;

+

+emit_expression:

+	emitexp(OEXPR, np);

+}

+

+static void

+emitinit(int op, void *arg)

+{

+	Node *np = arg;

+

+	fputs("\t(\n", outfp);

+	emitdesig(np, np->type);

+	fputs(")\n", outfp);

+}

+

+static void

+emitdcl(int op, void *arg)

+{

+	Symbol *sym = arg;

+

+	if (sym->flags & SEMITTED)

+		return;

+	emitvar(sym);

+	putc('\t', outfp);

+	if (sym->type->op == FTN) {

+		emitletter(sym->type->type);

+		putc('\t', outfp);

+	}

+	emitletter(sym->type);

+	fprintf(outfp, "\t\"%s", (sym->name) ? sym->name : "");

+	if (sym->flags & SFIELD)

+		fprintf(outfp, "\t#%c%llX", sizettype->letter, sym->u.i);

+	sym->flags |= SEMITTED;

+	if ((sym->flags & SHASINIT) == 0)

+		putc('\n', outfp);

+}

+

+static void

+emitcast(int op, void *arg)

+{

+	Node *np = arg, *lp = np->left;

+

+	emitnode(lp);

+	if (np->type != voidtype)

+		fprintf(outfp, "\tg%c", np->type->letter);

+}

+

+static void

+emitbin(int op, void *arg)

+{

+	Node *np = arg;

+	char *s;

+

+	emitnode(np->left);

+	emitnode(np->right);

+	if ((s = optxt[op]) != NULL)  {      /* do not print in OCOLON case */

+		fprintf(outfp, "\t%s", s);

+		emitletter(np->type);

+	}

+}

+

+static void

+emitbuilt(int op, void *arg)

+{

+	Node *np = arg;

+

+	emitnode(np->left);

+	emitnode(np->right);

+	fprintf(outfp, "\t\"%s\tm", np->sym->name);

+	emitletter(np->type);

+}

+

+

+static void

+emitexp(int op, void *arg)

+{

+	Node *np = arg;

+

+	emitnode(np);

+	putc('\n', outfp);

+	freetree(np);

+}

+

+static void

+emitfun(int op, void *arg)

+{

+	Symbol *sym = arg, **sp;

+

+	emitdcl(op, arg);

+	fputs("{\n", outfp);

+

+	for (sp = sym->u.pars; sp && *sp; ++sp)

+		emit(ODECL, *sp);

+	fputs("\\\n", outfp);

+}

+

+static void

+emittext(int op, void *arg)

+{

+	fputs(optxt[op], outfp);

+}

+

+static void

+emitsymid(int op, void *arg)

+{

+	Symbol *sym = arg;

+	fprintf(outfp, optxt[op], sym->id);

+}

+

+Node *

+node(int op, Type *tp, Node *lp, Node *rp)

+{

+	Node *np;

+

+	np = xmalloc(sizeof(*np));

+	np->op = op;

+	np->type = tp;

+	np->sym = NULL;

+	np->flags = 0;

+	np->left = lp;

+	np->right = rp;

+

+	if (lp)

+		np->flags |= lp->flags & NEFFECT;

+	if (rp)

+		np->flags |= rp->flags & NEFFECT;

+	return np;

+}

+

+Node *

+varnode(Symbol *sym)

+{

+	Node *np;

+	Type *tp = sym->type;

+

+	np = node(OSYM, sym->type, NULL, NULL);

+	np->type = sym->type;

+	np->flags = (tp->op != FTN && tp->op != ARY) ? NLVAL : 0;

+	np->sym = sym;

+	return np;

+}

+

+Node *

+constnode(Symbol *sym)

+{

+	Node *np;

+

+	np = node(OSYM, sym->type, NULL, NULL);

+	np->type = sym->type;

+	np->flags = NCONST;

+	np->sym = sym;

+	return np;

+}

+

+Node *

+sizeofnode(Type *tp)

+{

+	Symbol *sym;

+

+	sym = newsym(NS_IDEN, NULL);

+	sym->type = sizettype;

+	sym->u.i = tp->size;

+	return constnode(sym);

+}

--- /dev/null

+++ b/src/cmd/scc/cc1/cpp.c

@@ -1,0 +1,839 @@

+static char sccsid[] = "@(#) ./cc1/cpp.c";

+#include <ctype.h>

+#include <limits.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include <time.h>

+

+#include <scc/cstd.h>

+#include <scc/scc.h>

+#include "cc1.h"

+

+static char *argp, *macroname;

+static unsigned arglen;

+static unsigned ncmdlines;

+static Symbol *symline, *symfile;

+static unsigned char ifstatus[NR_COND];

+static int cppoff;

+static struct items dirinclude;

+

+unsigned cppctx;

+int disexpand;

+

+void

+defdefine(char *macro, char *val, char *source)

+{

+	char *def, *fmt = "#define %s %s\n";

+	Symbol dummy = {.flags = SDECLARED};

+

+	if (!val)

+		val = "";

+	def = xmalloc(strlen(fmt) + strlen(macro) + strlen(val));

+

+	sprintf(def, fmt, macro, val);

+	lineno = ++ncmdlines;

+	addinput(source, &dummy, def);

+	cpp();

+	delinput();

+}

+

+void

+undefmacro(char *s)

+{

+	killsym(lookup(NS_CPP, s, NOALLOC));

+}

+

+void

+icpp(void)

+{

+	static char sdate[14], stime[11];

+	struct tm *tm;

+	time_t t;

+	static char **bp, *list[] = {

+		"__STDC__",

+		"__STDC_HOSTED__",

+		"__SCC__",

+		NULL

+	};

+	static struct keyword keys[] = {

+		{"define", DEFINE, DEFINE},

+		{"include", INCLUDE, INCLUDE},

+		{"line", LINE, LINE},

+		{"ifdef", IFDEF, IFDEF},

+		{"if", IF, IF},

+		{"elif", ELIF, ELIF},

+		{"else", ELSE, ELSE},

+		{"ifndef", IFNDEF, IFNDEF},

+		{"endif", ENDIF, ENDIF},

+		{"undef", UNDEF, UNDEF},

+		{"pragma", PRAGMA, PRAGMA},

+		{"error", ERROR, ERROR},

+		{NULL, 0, 0}

+	};

+

+	keywords(keys, NS_CPPCLAUSES);

+

+	t = time(NULL);

+	tm = localtime(&t);

+	strftime(sdate, sizeof(sdate), "\"%b %d %Y\"", tm);

+	strftime(stime, sizeof(stime), "\"%H:%M:%S\"", tm);

+	defdefine("__DATE__", sdate, "built-in");

+	defdefine("__TIME__", stime, "built-in");

+	defdefine("__STDC_VERSION__", STDC_VERSION, "built-in");

+	defdefine("__LINE__", NULL, "built-in");

+	defdefine("__FILE__", NULL, "built-in");

+

+	symline = lookup(NS_CPP, "__LINE__", ALLOC);

+	symfile = lookup(NS_CPP, "__FILE__", ALLOC);

+

+	for (bp = list; *bp; ++bp)

+		defdefine(*bp, "1", "built-in");

+

+	ncmdlines = 0;

+}

+

+static void

+nextcpp(void)

+{

+	next();

+	if (yytoken == EOFTOK)

+		error("unterminated argument list invoking macro \"%s\"",

+		      macroname);

+	if (yylen + 1 > arglen)

+		error("argument overflow invoking macro \"%s\"",

+		      macroname);

+	if (yytoken == IDEN)

+		yylval.sym->flags |= SUSED;

+	memcpy(argp, yytext, yylen);

+	argp += yylen;

+	*argp++ = ' ';

+	arglen -= yylen + 1;

+}

+

+static void

+paren(void)

+{

+	for (;;) {

+		nextcpp();

+		switch (yytoken) {

+		case ')':

+			return;

+		case '(':

+			paren();

+			break;

+		}

+	}

+}

+

+static void

+parameter(void)

+{

+	for (;;) {

+		nextcpp();

+		switch (yytoken) {

+		case ')':

+		case ',':

+			argp -= 3;  /* remove " , "  or " ) "*/

+			*argp++ = '\0';

+			return;

+		case '(':

+			paren();

+			break;

+		}

+	}

+}

+

+static int

+parsepars(char *buffer, char **listp, int nargs)

+{

+	int n;

+

+	if (nargs == -1)

+		return -1;

+	if (ahead() != '(' && nargs > 0)

+		return 0;

+

+	disexpand = 1;

+	next();

+	n = 0;

+	argp = buffer;

+	arglen = INPUTSIZ;

+	if (ahead() == ')') {

+		next();

+	} else {

+		do {

+			*listp++ = argp;

+			parameter();

+		} while (++n < NR_MACROARG && yytoken == ',');

+	}

+	if (yytoken != ')')

+		error("incorrect macro function-alike invocation");

+	disexpand = 0;

+

+	if (n == NR_MACROARG)

+		error("too many parameters in macro \"%s\"", macroname);

+	if (n != nargs) {

+		error("macro \"%s\" received %d arguments, but it takes %d",

+		      macroname, n, nargs);

+	}

+

+	return 1;

+}

+

+static size_t

+copymacro(char *buffer, char *s, size_t bufsiz, char *arglist[])

+{

+	int delim, prevc, c;

+	char *p, *arg, *bp = buffer;

+	size_t size;

+

+	for (prevc = '\0'; c = *s; prevc = c, ++s) {

+		switch (c) {

+		case '$':

+			while (bp[-1] == ' ')

+				--bp, ++bufsiz;

+			while (s[1] == ' ')

+				++s;

+		case '#':

+			break;

+		case '\'':

+			delim = '\'';

+			goto search_delim;

+		case '\"':

+			delim = '"';

+		search_delim:

+			for (p = s; *++s != delim; )

+				;

+			size = s - p + 1;

+			if (size > bufsiz)

+				goto expansion_too_long;

+			memcpy(bp, p, size);

+			bufsiz -= size;

+			bp += size;

+			break;

+		case '@':

+			if (prevc == '#')

+				bufsiz -= 2;

+			arg = arglist[atoi(++s)];

+			size = strlen(arg);

+			if (size > bufsiz)

+				goto expansion_too_long;

+			if (prevc == '#')

+				*bp++ = '"';

+			memcpy(bp, arg, size);

+			bp += size;

+			if (prevc == '#')

+				*bp++ = '"';

+			bufsiz -= size;

+			s += 2;

+			break;

+		default:

+			if (bufsiz-- == 0)

+				goto expansion_too_long;

+			*bp++ = c;

+			break;

+		}

+	}

+	*bp = '\0';

+

+	return bp - buffer;

+

+expansion_too_long:

+	error("macro expansion of \"%s\" too long", macroname);

+}

+

+int

+expand(char *begin, Symbol *sym)

+{

+	size_t elen;

+	int n, i;

+	char *s = sym->u.s;

+	char *arglist[NR_MACROARG], arguments[INPUTSIZ], buffer[INPUTSIZ];

+

+	macroname = sym->name;

+	if (sym == symfile) {

+		elen = sprintf(buffer, "\"%s\" ", filenam);

+		goto substitute;

+	}

+	if (sym == symline) {

+		elen = sprintf(buffer, "%d ", lineno);

+		goto substitute;

+	}

+	if (!s)

+		return 1;

+

+	n = atoi(s);

+	if (!parsepars(arguments, arglist, n))

+		return 0;

+	for (i = 0; i < n; ++i)

+		DBG("MACRO par%d:%s", i, arglist[i]);

+

+	elen = copymacro(buffer, s+3, INPUTSIZ-1, arglist);

+

+substitute:

+	DBG("MACRO '%s' expanded to :'%s'", macroname, buffer);

+	buffer[elen] = '\0';

+	addinput(filenam, sym, xstrdup(buffer));

+

+	return 1;

+}

+

+static int

+getpars(Symbol *args[NR_MACROARG])

+{

+	int n, c;

+	Symbol *sym;

+

+	c = *input->p;

+	next();

+	if (c != '(')

+		return -1;

+	next(); /* skip the '(' */

+	if (accept(')'))

+		return 0;

+

+	n = 0;

+	do {

+		if (n == NR_MACROARG) {

+			cpperror("too many parameters in macro");

+			return NR_MACROARG;

+		}

+		if (accept(ELLIPSIS)) {

+			args[n++] = NULL;

+			break;

+		}

+		if (yytoken != IDEN) {

+			cpperror("macro arguments must be identifiers");

+			return NR_MACROARG;

+		}

+		sym = install(NS_IDEN, yylval.sym);

+		sym->flags |= SUSED;

+		args[n++] = sym;

+		next();

+	} while (accept(','));

+	expect(')');

+

+	return n;

+}

+

+static int

+getdefs(Symbol *args[NR_MACROARG], int nargs, char *bp, size_t bufsiz)

+{

+	Symbol **argp;

+	size_t len;

+	int prevc = 0, ispar;

+

+	if (yytoken == '$') {

+		cpperror("'##' cannot appear at either ends of a macro expansion");

+		return 0;

+	}

+

+	for (;;) {

+		ispar = 0;

+		if (yytoken == IDEN && nargs >= 0) {

+			for (argp = args; argp < &args[nargs]; ++argp) {

+				if (*argp == yylval.sym)

+					break;

+			}

+			if (argp != &args[nargs]) {

+				sprintf(yytext, "@%02d@", (int) (argp - args));

+				ispar = 1;

+			}

+		}

+		if (prevc == '#' && !ispar) {

+			cpperror("'#' is not followed by a macro parameter");

+			return 0;

+		}

+		if (yytoken == '\n')

+			break;

+

+		if ((len = strlen(yytext)) >= bufsiz) {

+			cpperror("macro too long");

+			return 0;

+		}

+		if (yytoken == '$') {

+			*bp++ = '$';

+			 --bufsiz;

+		} else {

+			memcpy(bp, yytext, len);

+			bp += len;

+			bufsiz -= len;

+		}

+		if ((prevc = yytoken) != '#') {

+			*bp++ = ' ';

+			--bufsiz;

+		}

+		next();

+	}

+	*bp = '\0';

+	return 1;

+}

+

+static void

+define(void)

+{

+	Symbol *sym,*args[NR_MACROARG];

+	char buff[LINESIZ+1];

+	int n;

+

+	if (cppoff)

+		return;

+

+	namespace = NS_CPP;

+	next();

+

+	if (yytoken != IDEN) {

+		cpperror("macro names must be identifiers");

+		return;

+	}

+	sym = yylval.sym;

+	if (sym->flags & SDECLARED) {

+		warn("'%s' redefined", yytext);

+		free(sym->u.s);

+	} else {

+		sym = install(NS_CPP, sym);

+		sym->flags |= SDECLARED|SSTRING;

+	}

+

+	namespace = NS_IDEN;       /* Avoid polution in NS_CPP */

+	if ((n = getpars(args)) == NR_MACROARG)

+		goto delete;

+	if (n > 0 && !args[n-1])  /* it is a variadic function */

+		--n;

+	sprintf(buff, "%02d#", n);

+	if (!getdefs(args, n, buff+3, LINESIZ-3))

+		goto delete;

+	sym->u.s = xstrdup(buff);

+	DBG("MACRO '%s' defined as '%s'", sym->name, buff);

+	return;

+

+delete:

+	killsym(sym);

+}

+

+void

+incdir(char *dir)

+{

+	if (!dir || *dir == '\0')

+		die("cc1: incorrect -I flag");

+	newitem(&dirinclude, dir);

+}

+

+static int

+includefile(char *dir, char *file, size_t filelen)

+{

+	size_t dirlen;

+	char path[FILENAME_MAX];

+

+	if (!dir) {

+		dirlen = 0;

+		if (filelen > FILENAME_MAX-1)

+			return 0;

+	} else {

+		dirlen = strlen(dir);

+		if (dirlen + filelen > FILENAME_MAX-2)

+			return 0;

+		memcpy(path, dir, dirlen);

+		if (dir[dirlen-1] != '/')

+			path[dirlen++] = '/';

+	}

+	memcpy(path+dirlen, file, filelen);

+	path[dirlen + filelen] = '\0';

+

+	addinput(path, NULL, NULL);

+	return 1;

+}

+

+static char *

+cwd(char *buf)

+{

+	char *p, *s = filenam;

+	size_t len;

+

+	if ((p = strrchr(s, '/')) == NULL)

+		return NULL;

+	if ((len = p - s) >= FILENAME_MAX)

+		die("cc1: current work directory too long");

+	memcpy(buf, s, len);

+	buf[len] = '\0';

+	return buf;

+}

+

+static void

+include(void)

+{

+	char dir[FILENAME_MAX], file[FILENAME_MAX], *p, **bp;

+	size_t filelen;

+	int n;

+

+	if (cppoff)

+		return;

+

+	namespace = NS_IDEN;

+	next();

+

+	switch (*yytext) {

+	case '<':

+		if ((p = strchr(input->begin, '>')) == NULL || p[-1] == '<')

+			goto bad_include;

+		filelen = p - input->begin;

+		if (filelen >= FILENAME_MAX)

+			goto too_long;

+		memcpy(file, input->begin, filelen);

+		file[filelen] = '\0';

+

+		input->begin = input->p = p+1;

+		if (next() != '\n')

+			goto trailing_characters;

+

+		break;

+	case '"':

+		if (yylen < 3)

+			goto bad_include;

+		filelen = yylen-2;

+		if (filelen >= FILENAME_MAX)

+			goto too_long;

+		memcpy(file, yytext+1, filelen);

+		file[filelen] = '\0';

+

+		if (next() != '\n')

+			goto trailing_characters;

+

+		if (includefile(cwd(dir), file, filelen))

+			goto its_done;

+		break;

+	default:

+		goto bad_include;

+	}

+

+	n = dirinclude.n;

+	for (bp = dirinclude.s; n--; ++bp) {

+		if (includefile(*bp, file, filelen))

+			goto its_done;

+	}

+	cpperror("included file '%s' not found", file);

+

+its_done:

+	return;

+

+trailing_characters:

+	cpperror("trailing characters after preprocessor directive");

+	return;

+

+too_long:

+	cpperror("too long file name in #include");

+	return;

+

+bad_include:

+	cpperror("#include expects \"FILENAME\" or <FILENAME>");

+	return;

+}

+

+static void

+line(void)

+{

+	long n;

+	char *endp, *fname;

+

+	if (cppoff)

+		return;

+

+	disexpand = 0;

+	next();

+	n = strtol(yytext, &endp, 10);

+	if (n <= 0 || n > USHRT_MAX || *endp != '\0') {

+		cpperror("first parameter of #line is not a positive integer");

+		return;

+	}

+

+	next();

+	if (yytoken == '\n') {

+		fname = NULL;

+	} else {

+		if (*yytext != '\"' || yylen == 1) {

+			cpperror("second parameter of #line is not a valid filename");

+			return;

+		}

+		fname = yylval.sym->u.s;

+	}

+	setloc(fname, n - 1);

+	if (yytoken != '\n')

+		next();

+}

+

+static void

+pragma(void)

+{

+	if (cppoff)

+		return;

+	next();

+	warn("ignoring pragma '%s'", yytext);

+	*input->p = '\0';

+	next();

+}

+

+static void

+usererr(void)

+{

+	if (cppoff)

+		return;

+	cpperror("#error %s", input->p);

+	*input->p = '\0';

+	next();

+}

+

+static void

+ifclause(int negate, int isifdef)

+{

+	Symbol *sym;

+	unsigned n;

+	int status;

+	Node *expr;

+

+	if (cppctx == NR_COND-1)

+		error("too many nesting levels of conditional inclusion");

+

+	n = cppctx++;

+	namespace = NS_CPP;

+	next();

+

+	if (isifdef) {

+		if (yytoken != IDEN) {

+			cpperror("no macro name given in #%s directive",

+			         (negate) ? "ifndef" : "ifdef");

+			return;

+		}

+		sym = yylval.sym;

+		next();

+		status = (sym->flags & SDECLARED) != 0;

+		if (!status)

+			killsym(sym);

+	} else {

+		/* TODO: catch recovery here */

+		if ((expr = constexpr()) == NULL) {

+			cpperror("parameter of #if is not an integer constant expression");

+			return;

+		}

+		status = expr->sym->u.i != 0;

+		freetree(expr);

+	}

+

+	if (negate)

+		status = !status;

+	if ((ifstatus[n] = status) == 0)

+		++cppoff;

+}

+

+static void

+cppif(void)

+{

+	disexpand = 0;

+	ifclause(0, 0);

+}

+

+static void

+ifdef(void)

+{

+	ifclause(0, 1);

+}

+

+static void

+ifndef(void)

+{

+	ifclause(1, 1);

+}

+

+static void

+elseclause(void)

+{

+	int status;

+

+	if (cppctx == 0) {

+		cpperror("#else without #ifdef/ifndef");

+		return;

+	}

+

+	status = ifstatus[cppctx-1];

+	ifstatus[cppctx-1] = !status;

+	cppoff += (status) ? 1 : -1;

+}

+

+static void

+cppelse(void)

+{

+	elseclause();

+	next();

+}

+

+static void

+elif(void)

+{

+	elseclause();

+	if (ifstatus[cppctx-1]) {

+		--cppctx;

+		cppif();

+	}

+}

+

+static void

+endif(void)

+{

+	if (cppctx == 0)

+		error("#endif without #if");

+	if (!ifstatus[--cppctx])

+		--cppoff;

+	next();

+}

+

+static void

+undef(void)

+{

+	if (cppoff)

+		return;

+

+	namespace = NS_CPP;

+	next();

+	if (yytoken != IDEN) {

+		error("no macro name given in #undef directive");

+		return;

+	}

+	killsym(yylval.sym);

+	next();

+}

+

+int

+cpp(void)

+{

+	static struct {

+		unsigned char token;

+		void (*fun)(void);

+	} *bp, clauses [] = {

+		{DEFINE, define},

+		{INCLUDE, include},

+		{LINE, line},

+		{IFDEF, ifdef},

+		{IF, cppif},

+		{ELIF, elif},

+		{IFNDEF, ifndef},

+		{ELSE, cppelse},

+		{ENDIF, endif},

+		{UNDEF, undef},

+		{PRAGMA, pragma},

+		{ERROR, usererr},

+		{0, NULL}

+	};

+	int ns;

+	char *p;

+

+	for (p = input->p; isspace(*p); ++p)

+		;

+

+	if (*p != '#')

+		return cppoff;

+	input->p = p+1;

+

+	disexpand = 1;

+	lexmode = CPPMODE;

+	ns = namespace;

+	namespace = NS_CPPCLAUSES;

+	next();

+	namespace = NS_IDEN;

+

+	for (bp = clauses; bp->token && bp->token != yytoken; ++bp)

+		;

+	if (!bp->token) {

+		errorp("incorrect preprocessor directive '%s'", yytext);

+		goto error;

+	}

+

+	DBG("CPP %s", yytext);

+

+	pushctx();              /* create a new context to avoid polish */

+	(*bp->fun)();           /* the current context, and to get all  */

+	popctx();               /* the symbols freed at the  end        */

+

+	/*

+	 * #include changes the content of input->line, so the correctness

+	 * of the line must be checked in the own include(), and we have

+	 * to skip this tests. For the same reason include() is the only

+	 * function which does not prepare the next token

+	 */

+	if (yytoken != '\n' && !cppoff && bp->token != INCLUDE)

+		errorp("trailing characters after preprocessor directive");

+

+error:

+	disexpand = 0;

+	lexmode = CCMODE;

+	namespace = ns;

+

+	return 1;

+}

+

+void

+ppragmaln(void)

+{

+	static char file[FILENAME_MAX];

+	static unsigned nline;

+	char *s;

+

+	putchar('\n');

+	if (strcmp(file, filenam)) {

+		strcpy(file, filenam);

+		s = "#line %u \"%s\"\n";

+	} else if (nline+1 != lineno) {

+		s = "#line %u\n";

+	} else {

+		s = "";

+	}

+	nline = lineno;

+	printf(s, nline, file);

+}

+

+void

+outcpp(void)

+{

+	int c;

+	char *s, *t;

+

+	for (next(); yytoken != EOFTOK; next()) {

+		if (onlyheader)

+			continue;

+		if (yytoken != STRING) {

+			printf("%s ", yytext);

+			continue;

+		}

+		for (s = yytext; c = *s; ++s) {

+			switch (c) {

+			case '\n':

+				t = "\\n";

+				goto print_str;

+			case '\v':

+				t = "\\v";

+				goto print_str;

+			case '\b':

+				t = "\\b";

+				goto print_str;

+			case '\t':

+				t = "\\t";

+				goto print_str;

+			case '\a':

+				t = "\\a";

+			print_str:

+				fputs(t, stdout);

+				break;

+			case '\\':

+				putchar('\\');

+			default:

+				if (!isprint(c))

+					printf("\\x%x", c);

+				else

+					putchar(c);

+				break;

+			}

+		}

+		putchar(' ');

+	}

+	putchar('\n');

+}

+

--- /dev/null

+++ b/src/cmd/scc/cc1/decl.c

@@ -1,0 +1,967 @@

+static char sccsid[] = "@(#) ./cc1/decl.c";

+#include <stdarg.h>

+#include <stdlib.h>

+#include <string.h>

+

+#include <scc/cstd.h>

+#include <scc/scc.h>

+#include "cc1.h"

+

+#define NOSCLASS  0

+

+#define NOREP 0

+#define REP 1

+#define QUIET   1

+#define NOQUIET 0

+

+#define NR_DCL_TYP (NR_DECLARATORS+NR_FUNPARAM)

+#define NR_DCL_SYM (NR_DECLARATORS+NR_FUNPARAM+1)

+

+struct declarators {

+	unsigned nr;

+	unsigned ns;

+	struct decl *dcl;

+	unsigned nr_types;

+	Type **tpars;

+	Symbol **pars;

+	struct declarator {

+		unsigned char op;

+		TINT  nelem;

+		Symbol *sym;

+		Type **tpars;

+		Symbol **pars;

+	} d [NR_DECLARATORS];

+};

+

+struct decl {

+	unsigned ns;

+	int sclass;

+	int qualifier;

+	Symbol *sym;

+	Type *type;

+	Type *parent;

+	Symbol **pars;

+	Symbol *bufpars[NR_DCL_SYM];

+	Type *buftpars[NR_DCL_TYP];

+};

+

+

+static void

+endfundcl(Type *tp, Symbol **pars)

+{

+	if (tp->prop&TK_R && *pars)

+		warn("parameter names (without types) in function declaration");

+	/*

+	 * avoid non used warnings in prototypes

+	 */

+	while (*pars)

+		(*pars++)->flags |= SUSED;

+	popctx();

+}

+

+static void

+push(struct declarators *dp, int op, ...)

+{

+	va_list va;

+	unsigned n;

+	struct declarator *p;

+

+	va_start(va, op);

+	if ((n = dp->nr++) == NR_DECLARATORS)

+		error("too many declarators");

+

+	p = &dp->d[n];

+	p->op = op;

+	p->tpars = NULL;

+

+	switch (op) {

+	case ARY:

+		p->nelem = va_arg(va, TINT);

+		break;

+	case KRFTN:

+	case FTN:

+		p->nelem = va_arg(va, unsigned);

+		p->tpars = va_arg(va, Type **);

+		p->pars = va_arg(va, Symbol **);

+		break;

+	case IDEN:

+		p->sym = va_arg(va, Symbol *);

+		break;

+	}

+	va_end(va);

+}

+

+static int

+pop(struct declarators *dp, struct decl *dcl)

+{

+	struct declarator *p;

+

+	if (dp->nr == 0)

+		return 0;

+

+	p = &dp->d[--dp->nr];

+	if (p->op == IDEN) {

+		dcl->sym = p->sym;

+		return 1;

+	}

+

+	if (dcl->type->op == FTN)

+		endfundcl(dcl->type, dcl->pars);

+	dcl->pars = p->pars;

+

+	dcl->type = mktype(dcl->type, p->op, p->nelem, p->tpars);

+	return 1;

+}

+

+static void

+arydcl(struct declarators *dp)

+{

+	Node *np = NULL;

+	TINT n = 0;

+

+	expect('[');

+	if (yytoken != ']') {

+		if ((np = constexpr()) == NULL) {

+			errorp("invalid storage size");

+		} else {

+			if ((n = np->sym->u.i) <= 0) {

+				errorp("array size is not a positive number");

+				n = 1;

+			}

+			freetree(np);

+		}

+	}

+	expect(']');

+

+	push(dp, ARY, n);

+}

+

+static int

+empty(Symbol *sym, Type *tp, int param)

+{

+	if (!sym->name) {

+		sym->type = tp;

+		switch (tp->op) {

+		default:

+			 /* warn if it is not a parameter */

+			if (!param)

+				warn("empty declaration");

+		case STRUCT:

+		case UNION:

+		case ENUM:

+			return 1;

+		}

+	}

+	return 0;

+}

+

+static void

+bad_storage(Type *tp, char *name)

+{

+	if (tp->op != FTN)

+		errorp("incorrect storage class for file-scope declaration");

+	else

+		errorp("invalid storage class for function '%s'", name);

+}

+

+static Symbol *

+redcl(Symbol *sym, Type *tp, int sclass)

+{

+	int flags;

+	char *name = sym->name;

+

+	if (!eqtype(sym->type, tp, 1)) {

+		errorp("conflicting types for '%s'", name);

+		return sym;

+	}

+

+	if (sym->token == TYPEIDEN && sclass != TYPEDEF ||

+	    sym->token != TYPEIDEN && sclass == TYPEDEF) {

+		goto redeclaration;

+	}

+	if (curctx != GLOBALCTX && tp->op != FTN) {

+		/* is it the redeclaration of a local variable? */

+		if ((sym->flags & SEXTERN) && sclass == EXTERN)

+			return sym;

+		goto redeclaration;

+	}

+

+	flags = sym->flags;

+	switch (sclass) {

+	case REGISTER:

+	case AUTO:

+		bad_storage(tp, name);

+		break;

+	case NOSCLASS:

+		if ((flags & SPRIVATE) == 0) {

+			if (flags & SEXTERN)

+				flags &= ~(SEXTERN|SEMITTED);

+			flags |= SGLOBAL;

+			break;

+		}

+		errorp("non-static declaration of '%s' follows static declaration",

+		       name);

+		break;

+	case TYPEDEF:

+		/* Only C11 allows multiple definitions of a typedef. */

+		goto redeclaration;

+	case EXTERN:

+		break;

+	case STATIC:

+		if ((flags & (SGLOBAL|SEXTERN)) == 0) {

+			flags |= SPRIVATE;

+			break;

+		}

+		errorp("static declaration of '%s' follows non-static declaration",

+		       name);

+		break;

+	}

+	sym->flags = flags;

+

+	return sym;

+

+redeclaration:

+	errorp("redeclaration of '%s'", name);

+	return sym;

+}

+

+static Symbol *

+identifier(struct decl *dcl)

+{

+	Symbol *sym = dcl->sym;

+	Type *tp = dcl->type;

+	int sclass = dcl->sclass;

+	char *name = sym->name;

+

+	if (empty(sym, tp, 0))

+		return sym;

+

+	/* TODO: Add warning about ANSI limits */

+	if (!(tp->prop & TDEFINED)                &&

+	    sclass != EXTERN && sclass != TYPEDEF &&

+	    !(tp->op == ARY && yytoken == '=')) {

+		errorp("declared variable '%s' of incomplete type", name);

+	}

+

+	if (tp->op == FTN) {

+		if (sclass == NOSCLASS)

+			sclass = EXTERN;

+		if (!strcmp(name, "main") && tp->type != inttype) {

+			errorp("main shall be defined with a return type of int");

+			errorp("please contact __20h__ on irc.freenode.net (#bitreich-en) via IRC");

+		}

+	}

+

+	if (sym->flags & SDECLARED) {

+		sym = redcl(dcl->sym, tp, sclass);

+	} else {

+		int flags = sym->flags | SDECLARED;

+

+		sym->type = tp;

+

+		switch (sclass) {

+		case REGISTER:

+		case AUTO:

+			if (curctx != GLOBALCTX && tp->op != FTN) {

+				flags |= (sclass == REGISTER) ? SREGISTER : SAUTO;

+				break;

+			}

+			bad_storage(tp, name);

+		case NOSCLASS:

+			if (tp->op == FTN)

+				flags |= SEXTERN;

+			else

+				flags |= (curctx == GLOBALCTX) ? SGLOBAL : SAUTO;

+			break;

+		case EXTERN:

+			flags |= SEXTERN;

+			break;

+		case STATIC:

+			flags |= (curctx == GLOBALCTX) ? SPRIVATE : SLOCAL;

+			break;

+		case TYPEDEF:

+			flags |= STYPEDEF;

+			sym->u.token = sym->token = TYPEIDEN;

+			break;

+		}

+		sym->flags = flags;

+	}

+

+	if (accept('='))

+		initializer(sym, sym->type);

+	if (!(sym->flags & (SGLOBAL|SEXTERN)) && tp->op != FTN)

+		sym->flags |= SDEFINED;

+	if (sym->token == IDEN && tp->op != FTN)

+		emit(ODECL, sym);

+	return sym;

+}

+

+static Symbol *

+parameter(struct decl *dcl)

+{

+	Symbol *sym = dcl->sym;

+	Type *funtp = dcl->parent, *tp = dcl->type;

+	char *name = sym->name;

+	int flags;

+

+	flags = 0;

+	switch (dcl->sclass) {

+	case STATIC:

+	case EXTERN:

+	case AUTO:

+		errorp("bad storage class in function parameter");

+		break;

+	case REGISTER:

+		flags |= SREGISTER;

+		break;

+	case NOSCLASS:

+		flags |= SAUTO;

+		break;

+	}

+

+	switch (tp->op) {

+	case VOID:

+		funtp->n.elem = 1;

+		if (dcl->sclass)

+			errorp("void as unique parameter may not be qualified");

+		return NULL;

+	case ARY:

+		tp = mktype(tp->type, PTR, 0, NULL);

+		break;

+	case FTN:

+		errorp("incorrect function type for a function parameter");

+		return NULL;

+	}

+	if (!empty(sym, tp, 1)) {

+		int isdcl = sym->flags&SDECLARED, isk_r = funtp->prop & TK_R;

+		if (isdcl && !isk_r) {

+			errorp("redefinition of parameter '%s'", name);

+			return NULL;

+		}

+		if (!isdcl && isk_r) {

+			errorp("declaration for parameter '%s' but no such parameter",

+			       sym->name);

+			return NULL;

+		}

+		sym->flags |= SDECLARED;

+	}

+

+	sym->type = tp;

+	sym->flags &= ~(SAUTO|SREGISTER);

+	sym->flags |= flags;

+	return sym;

+}

+

+static Symbol *dodcl(int rep,

+                     Symbol *(*fun)(struct decl *),

+                     unsigned ns,

+                     Type *type);

+

+static int

+krpars(struct declarators *dp)

+{

+	Symbol *sym;

+	int toomany = 0;

+	unsigned npars = 0;

+

+	do {

+		sym = yylval.sym;

+		expect(IDEN);

+		sym->flags |= SAUTO;

+		if ((sym = install(NS_IDEN, sym)) == NULL) {

+			errorp("redefinition of parameter '%s'",

+			       yylval.sym->name);

+			continue;

+		}

+		if (npars < NR_FUNPARAM) {

+			++npars;

+			*dp->pars++ = sym;

+			continue;

+		}

+		if (!toomany)

+		toomany = 1;

+	} while (accept(','));

+

+	return toomany;

+}

+

+static unsigned

+krfun(struct declarators *dp)

+{

+	int toomany = 0;

+

+

+	if (yytoken != ')')

+		toomany = krpars(dp);

+

+	if (dp->nr_types == NR_DCL_TYP) {

+		toomany = 1;

+	} else {

+		++dp->nr_types;

+		*dp->tpars++ = ellipsistype;

+	}

+

+	if (toomany)

+		errorp("too many parameters in function definition");

+	return 1;

+}

+

+static unsigned

+ansifun(struct declarators *dp)

+{

+	Symbol *sym;

+	unsigned npars, ntype, toomany, distoomany, voidpar;

+	Type type, *tp;

+

+	type.n.elem = 0;

+	type.prop = 0;

+	npars = ntype = toomany = distoomany = voidpar = 0;

+

+	do {

+		if (accept(ELLIPSIS)) {

+			if (ntype < 1)

+				errorp("a named argument is requiered before '...'");

+			if (yytoken != ')')

+				errorp("... must be the last parameter");

+			sym = NULL;

+			tp = ellipsistype;

+		} else if ((sym = dodcl(NOREP, parameter, NS_IDEN, &type)) == NULL) {

+			if (type.n.elem == 1 && ntype > 1)

+				voidpar = 1;

+			sym = NULL;

+			tp = NULL;

+		} else {

+			tp = sym->type;

+		}

+

+		if (sym) {

+			if (npars == NR_FUNPARAM) {

+				toomany = 1;

+			} else {

+				npars++;

+				*dp->pars++ = sym;

+			}

+		}

+

+		if (tp) {

+			if (dp->nr_types == NR_DCL_TYP) {

+				toomany = 1;

+			} else {

+				ntype++;

+				dp->nr_types++;

+				*dp->tpars++ = tp;

+			}

+		}

+

+	} while (accept(','));

+

+	if (toomany == 1)

+		errorp("too many parameters in function definition");

+	if (voidpar && ntype > 1)

+		errorp("'void' must be the only parameter");

+	return ntype;

+}

+

+static int

+funbody(Symbol *sym, Symbol *pars[])

+{

+	Type *tp;

+	Symbol **bp, *p;

+

+	if (!sym)

+		return 0;

+	tp = sym->type;

+	if (tp->op != FTN)

+		return 0;

+

+	switch (yytoken) {

+	case '{':

+	case TYPE:

+	case TYPEIDEN:

+		if (curctx != PARAMCTX)

+			errorp("nested function declaration");

+		if (sym && sym->ns == NS_IDEN)

+			break;

+	default:

+		emit(ODECL, sym);

+		endfundcl(tp, pars);

+		return  0;

+	}

+

+	tp->prop |= TFUNDEF;

+	curfun = sym;

+	if (sym->type->prop & TK_R) {

+		while (yytoken != '{') {

+			dodcl(REP, parameter, NS_IDEN, sym->type);

+			expect(';');

+		}

+		for (bp = pars; p = *bp; ++bp) {

+			if (p->type == NULL) {

+				warn("type of '%s' defaults to int", p->name);

+				p->type = inttype;

+			}

+		}

+	}

+	if (sym->flags & STYPEDEF)

+		errorp("function definition declared 'typedef'");

+	if (sym->flags & SDEFINED)

+		errorp("redefinition of '%s'", sym->name);

+	if (sym->flags & SEXTERN) {

+		sym->flags &= ~SEXTERN;

+		sym->flags |= SGLOBAL;

+	}

+	sym->flags |= SDEFINED;

+	sym->flags &= ~SEMITTED;

+	sym->u.pars = pars;

+	emit(OFUN, sym);

+	compound(NULL, NULL, NULL);

+	emit(OEFUN, NULL);

+	popctx();

+	flushtypes();

+	curfun = NULL;

+	return 1;

+}

+

+static void

+fundcl(struct declarators *dp)

+{

+	Type **types = dp->tpars;

+	unsigned ntypes, typefun;

+	Symbol **pars = dp->pars;

+	unsigned (*fun)(struct declarators *);

+

+	pushctx();

+	expect('(');

+	if (yytoken == ')' || yytoken == IDEN) {

+		typefun = KRFTN;

+		fun = krfun;

+	} else {

+		typefun = FTN;

+		fun = ansifun;

+	}

+	ntypes = (*fun)(dp);

+	*dp->pars++= NULL;

+	expect(')');

+

+	push(dp, typefun, ntypes, types, pars);

+}

+

+static void declarator(struct declarators *dp);

+

+static void

+directdcl(struct declarators *dp)

+{

+	Symbol *p, *sym;

+	static int nested;

+

+	if (accept('(')) {

+		if (nested == NR_SUBTYPE)

+			error("too many declarators nested by parentheses");

+		++nested;

+		declarator(dp);

+		--nested;

+		expect(')');

+	} else {

+		if (yytoken == IDEN || yytoken == TYPEIDEN) {

+			sym = yylval.sym;

+			if (p = install(dp->ns, sym)) {

+				sym = p;

+				sym->flags &= ~SDECLARED;

+			}

+			next();

+		} else {

+			sym = newsym(dp->ns, NULL);

+		}

+		push(dp, IDEN, sym);

+	}

+

+	for (;;) {

+		switch (yytoken) {

+		case '(':  fundcl(dp); break;

+		case '[':  arydcl(dp); break;

+		default:   return;

+		}

+	}

+}

+

+static void

+declarator(struct declarators *dp)

+{

+	unsigned  n;

+

+	for (n = 0; accept('*'); ++n) {

+		while (accept(TQUALIFIER))

+			;

+	}

+

+	directdcl(dp);

+

+	while (n--)

+		push(dp, PTR);

+}

+

+static Type *structdcl(void), *enumdcl(void);

+

+static Type *

+specifier(int *sclass, int *qualifier)

+{

+	Type *tp = NULL;

+	unsigned spec, qlf, sign, type, cls, size;

+

+	spec = qlf = sign = type = cls = size = 0;

+

+	for (;;) {

+		unsigned *p = NULL;

+		Type *(*dcl)(void) = NULL;

+

+		switch (yytoken) {

+		case SCLASS:

+			p = &cls;

+			break;

+		case TQUALIFIER:

+			qlf |= yylval.token;

+			next();

+			continue;

+		case TYPEIDEN:

+			if (type)

+				goto return_type;

+			tp = yylval.sym->type;

+			p = &type;

+			break;

+		case TYPE:

+			switch (yylval.token) {

+			case ENUM:

+				dcl = enumdcl;

+				p = &type;

+				break;

+			case STRUCT:

+			case UNION:

+				dcl = structdcl;

+				p = &type;

+				break;

+			case VA_LIST:

+			case VOID:

+			case BOOL:

+			case CHAR:

+			case INT:

+			case FLOAT:

+			case DOUBLE:

+				p = &type;

+				break;

+			case SIGNED:

+			case UNSIGNED:

+				p = &sign;

+				break;

+			case LONG:

+				if (size == LONG) {

+					yylval.token = LLONG;

+					size = 0;

+				}

+			case SHORT:

+				p = &size;

+				break;

+			}

+			break;

+		default:

+			goto return_type;

+		}

+		if (*p)

+			errorp("invalid type specification");

+		*p = yylval.token;

+		if (dcl) {

+			if (size || sign)

+				errorp("invalid type specification");

+			tp = (*dcl)();

+			goto return_type;

+		} else {

+			next();

+		}

+		spec = 1;

+	}

+

+return_type:

+	*sclass = cls;

+	*qualifier = qlf;

+	if (!tp) {

+		if (spec) {

+			tp = ctype(type, sign, size);

+		} else {

+			if (curctx != GLOBALCTX)

+				unexpected();

+			warn("type defaults to 'int' in declaration");

+			tp = inttype;

+		}

+	}

+	return tp;

+}

+

+static Symbol *

+newtag(void)

+{

+	Symbol *sym;

+	int ns, op, tag = yylval.token;

+	static unsigned tpns = NS_STRUCTS;

+

+	ns = namespace;

+	namespace = NS_TAG;

+	next();

+	namespace = ns;

+

+	switch (yytoken) {

+	case IDEN:

+	case TYPEIDEN:

+		sym = yylval.sym;

+		if ((sym->flags & SDECLARED) == 0)

+			install(NS_TAG, yylval.sym);

+		next();

+		break;

+	default:

+		sym = newsym(NS_TAG, NULL);

+		break;

+	}

+	if (!sym->type) {

+		Type *tp;

+

+		if (tpns == NS_STRUCTS + NR_MAXSTRUCTS)

+			error("too many tags declared");

+		tp = mktype(NULL, tag, 0, NULL);

+		tp->ns = tpns++;

+		sym->type = tp;

+		tp->tag = sym;

+		DBG("declared tag '%s' with ns = %d\n",

+		    (sym->name) ? sym->name : "anonymous", tp->ns);

+	}

+

+	if ((op = sym->type->op) != tag &&  op != INT)

+		error("'%s' defined as wrong kind of tag", sym->name);

+	return sym;

+}

+

+static void fieldlist(Type *tp);

+

+static Type *

+structdcl(void)

+{

+	Symbol *sym;

+	Type *tp;

+	static int nested;

+	int ns;

+

+	sym = newtag();

+	tp = sym->type;

+

+	if (!accept('{'))

+		return tp;

+

+	ns = namespace;

+	namespace = tp->ns;

+

+	if (tp->prop & TDEFINED && sym->ctx == curctx)

+		error("redefinition of struct/union '%s'", sym->name);

+

+	if (nested == NR_STRUCT_LEVEL)

+		error("too many levels of nested structure or union definitions");

+

+	++nested;

+	while (yytoken != '}') {

+		fieldlist(tp);

+	}

+	--nested;

+

+	deftype(tp);

+	namespace = ns;

+	expect('}');

+	return tp;

+}

+

+static Type *

+enumdcl(void)

+{

+	Type *tp;

+	Symbol *sym, *tagsym;

+	int ns, val, toomany;

+	unsigned nctes;

+

+	ns = namespace;

+	tagsym = newtag();

+	tp = tagsym->type;

+

+	if (!accept('{'))

+		goto restore_name;

+	if (tp->prop & TDEFINED)

+		errorp("redefinition of enumeration '%s'", tagsym->name);

+	deftype(tp);

+	namespace = NS_IDEN;

+

+	/* TODO: check incorrect values in val */

+	for (nctes = val = 0; yytoken != '}'; ++nctes, ++val) {

+		if (yytoken != IDEN)

+			unexpected();

+		sym = yylval.sym;

+		next();

+		if (nctes == NR_ENUM_CTES && !toomany) {

+			errorp("too many enum constants in a single enum");

+			toomany = 1;

+		}

+		if (accept('=')) {

+			Node *np = constexpr();

+

+			if (np == NULL)

+				errorp("invalid enumeration value");

+			else

+				val = np->sym->u.i;

+			freetree(np);

+		}

+		if ((sym = install(NS_IDEN, sym)) == NULL) {

+			errorp("'%s' redeclared as different kind of symbol",

+			       yytext);

+		} else {

+			sym->u.i = val;

+			sym->flags |= SCONSTANT;

+			sym->type = inttype;

+		}

+		if (!accept(','))

+			break;

+	}

+	expect('}');

+

+restore_name:

+	namespace = ns;

+	return tp;

+}

+

+static Symbol *

+type(struct decl *dcl)

+{

+	Symbol *sym = dcl->sym;

+

+	if (dcl->sclass)

+		error("class storage in type name");

+	if (sym->name)

+		error("unexpected identifier in type name");

+	sym->type = dcl->type;

+

+	return sym;

+}

+

+static Symbol *

+field(struct decl *dcl)

+{

+	static char *anon = "<anonymous>";

+	Symbol *sym = dcl->sym;

+	char *name = (sym->name) ? sym->name : anon;

+	Type *structp = dcl->parent, *tp = dcl->type;

+	TINT n = structp->n.elem;

+	int err = 0;

+

+	if (accept(':')) {

+		Node *np;

+		TINT n;

+

+		if ((np = constexpr()) == NULL) {

+			unexpected();

+			n = 0;

+		} else {

+			n = np->sym->u.i;

+			freetree(np);

+		}

+		if (n == 0 && name != anon)

+			errorp("zero width for bit-field '%s'", name);

+		if (tp != booltype && tp != inttype && tp != uinttype)

+			errorp("bit-field '%s' has invalid type", name);

+		if (n < 0)

+			errorp("negative width in bit-field '%s'", name);

+		else if (n > tp->size*8)

+			errorp("width of '%s' exceeds its type", name);

+	} else if (empty(sym, tp, 0)) {

+		return sym;

+	}

+

+	if (tp->op == FTN) {

+		errorp("invalid type '%s' in struct/union", name);

+		err = 1;

+	}

+	if (dcl->sclass) {

+		errorp("storage class in struct/union field '%s'", name);

+		err = 1;

+	}

+	if (!(tp->prop & TDEFINED)) {

+		error("field '%s' has incomplete type", name);

+		err = 1;

+	}

+	if (err)

+		return sym;

+

+	if (sym->flags & SDECLARED)

+		error("duplicated member '%s'", name);

+	sym->flags |= SFIELD|SDECLARED;

+	sym->type = tp;

+

+	if (n == NR_FIELDS)

+		error("too many fields in struct/union");

+	DBG("New field '%s' in namespace %d\n", name, structp->ns);

+	structp->p.fields = xrealloc(structp->p.fields, ++n * sizeof(*sym));

+	structp->p.fields[n-1] = sym;

+	structp->n.elem = n;

+

+	return sym;

+}

+

+static Symbol *

+dodcl(int rep, Symbol *(*fun)(struct decl *), unsigned ns, Type *parent)

+{

+	Symbol *sym;

+	Type *base;

+	struct decl dcl;

+	struct declarators stack;

+

+	dcl.ns = ns;

+	dcl.parent = parent;

+	base = specifier(&dcl.sclass, &dcl.qualifier);

+

+	do {

+		dcl.type = base;

+		stack.nr_types = stack.nr = 0;

+		stack.tpars = dcl.buftpars;

+		stack.pars = dcl.bufpars;

+		stack.dcl = &dcl;

+		stack.ns = ns;

+

+		declarator(&stack);

+

+		while (pop(&stack, &dcl))

+			;

+		sym = (*fun)(&dcl);

+		if (funbody(sym, dcl.pars))

+			return sym;

+	} while (rep && accept(','));

+

+	return sym;

+}

+

+void

+decl(void)

+{

+	Symbol *sym;

+

+	if (accept(';'))

+		return;

+	sym = dodcl(REP, identifier, NS_IDEN, NULL);

+	if (sym->type->prop & TFUNDEF)

+		return;

+	expect(';');

+}

+

+static void

+fieldlist(Type *tp)

+{

+	if (yytoken != ';')

+		dodcl(REP, field, tp->ns, tp);

+	expect(';');

+}

+

+Type *

+typename(void)

+{

+	return dodcl(NOREP, type, NS_DUMMY, NULL)->type;

+}

--- /dev/null

+++ b/src/cmd/scc/cc1/deps.mk

@@ -1,0 +1,44 @@

+#deps

+builtin.o: $(INCDIR)/scc/scc/scc.h

+builtin.o: cc1.h

+code.o: $(INCDIR)/scc/scc/scc.h

+code.o: cc1.h

+cpp.o: $(INCDIR)/scc/scc/cstd.h

+cpp.o: $(INCDIR)/scc/scc/scc.h

+cpp.o: cc1.h

+decl.o: $(INCDIR)/scc/scc/cstd.h

+decl.o: $(INCDIR)/scc/scc/scc.h

+decl.o: cc1.h

+error.o: $(INCDIR)/scc/scc/scc.h

+error.o: cc1.h

+expr.o: $(INCDIR)/scc/scc/cstd.h

+expr.o: $(INCDIR)/scc/scc/scc.h

+expr.o: cc1.h

+fold.o: $(INCDIR)/scc/scc/scc.h

+fold.o: cc1.h

+init.o: $(INCDIR)/scc/scc/cstd.h

+init.o: $(INCDIR)/scc/scc/scc.h

+init.o: cc1.h

+lex.o: $(INCDIR)/scc/scc/cstd.h

+lex.o: $(INCDIR)/scc/scc/scc.h

+lex.o: cc1.h

+main.o: $(INCDIR)/scc/scc/arg.h

+main.o: $(INCDIR)/scc/scc/scc.h

+main.o: cc1.h

+stmt.o: $(INCDIR)/scc/scc/cstd.h

+stmt.o: $(INCDIR)/scc/scc/scc.h

+stmt.o: cc1.h

+symbol.o: $(INCDIR)/scc/scc/cstd.h

+symbol.o: $(INCDIR)/scc/scc/scc.h

+symbol.o: cc1.h

+target/amd64-sysv/arch.o: $(INCDIR)/scc/scc/scc.h

+target/amd64-sysv/arch.o: target/amd64-sysv/../../cc1.h

+target/arm64-sysv/arch.o: $(INCDIR)/scc/scc/scc.h

+target/arm64-sysv/arch.o: target/arm64-sysv/../../cc1.h

+target/i386-sysv/arch.o: $(INCDIR)/scc/scc/scc.h

+target/i386-sysv/arch.o: target/i386-sysv/../../cc1.h

+target/z80-scc/arch.o: $(INCDIR)/scc/scc/scc.h

+target/z80-scc/arch.o: target/z80-scc/../../cc1.h

+types.o: $(INCDIR)/scc/scc/cstd.h

+types.o: $(INCDIR)/scc/scc/scc.h

+types.o: cc1.h

--- /dev/null

+++ b/src/cmd/scc/cc1/error.c

@@ -1,0 +1,85 @@

+static char sccsid[] = "@(#) ./cc1/error.c";

+#include <stdarg.h>

+#include <stdio.h>

+#include <stdlib.h>

+

+#include <scc/scc.h>

+#include "cc1.h"

+

+#define MAXERRNUM 10

+

+extern int failure;

+static unsigned nerrors;

+

+static void

+warn_error(int flag, char *fmt, va_list va)

+{

+	if (flag == 0)

+		return;

+	fprintf(stderr, "%s:%u: %s: ",

+	       filenam, lineno,

+	       (flag < 0) ? "error" : "warning");

+	vfprintf(stderr, fmt, va);

+	putc('\n', stderr);

+

+	if (flag < 0) {

+		if (!failure)

+			fclose(stdout);

+		failure = 1;

+		if (++nerrors == MAXERRNUM) {

+			fputs("too many errors\n", stderr);

+			exit(1);

+		}

+	}

+}

+

+void

+warn(char *fmt, ...)

+{

+	extern int warnings;

+

+	va_list va;

+	va_start(va, fmt);

+	warn_error(warnings, fmt, va);

+	va_end(va);

+}

+

+void

+error(char *fmt, ...)

+{

+	va_list va;

+

+	va_start(va, fmt);

+	warn_error(-1, fmt, va);

+	va_end(va);

+	exit(1);

+	discard();

+}

+

+void

+errorp(char *fmt, ...)

+{

+	va_list va;

+	va_start(va, fmt);

+	warn_error(-1, fmt, va);

+	va_end(va);

+}

+

+void

+cpperror(char *fmt, ...)

+{

+	va_list va;

+	va_start(va, fmt);

+	warn_error(-1, fmt, va);

+	va_end(va);

+

+	/* discard input until the end of the line */

+	*input->p = '\0';

+	next();

+}

+

+void

+unexpected(void)

+{

+	error("unexpected '%s'", yytext);

+}

--- /dev/null

+++ b/src/cmd/scc/cc1/expr.c

@@ -1,0 +1,1185 @@

+static char sccsid[] = "@(#) ./cc1/expr.c";

+#include <assert.h>

+#include <stdlib.h>

+#include <string.h>

+

+#include <scc/cstd.h>

+#include <scc/scc.h>

+#include "cc1.h"

+

+#define XCHG(lp, rp, np) (np = lp, lp = rp, rp = np)

+

+static Node *xexpr(void), *xassign(void);

+

+int

+cmpnode(Node *np, TUINT val)

+{

+	Symbol *sym;

+	Type *tp;

+	TUINT mask, nodeval;

+

+	if (!np || !(np->flags & NCONST) || !np->sym)

+		return 0;

+	sym = np->sym;

+	tp = sym->type;

+

+	switch (tp->op) {

+	case PTR:

+	case INT:

+		mask = (val > 1) ? ones(np->type->size) : -1;

+		nodeval = (tp->prop & TSIGNED) ? sym->u.i : sym->u.u;

+		return (nodeval & mask) == (val & mask);

+	case FLOAT:

+		return sym->u.f == val;

+	}

+	return 0;

+}

+

+static Node *

+promote(Node *np)

+{

+	Type *tp;

+	Node *new;

+	struct limits *lim, *ilim;

+

+	tp = np->type;

+

+	switch (tp->op) {

+	case ENUM:

+	case INT:

+		if (tp->n.rank >= inttype->n.rank)

+			return np;

+		lim = getlimits(tp);

+		ilim = getlimits(inttype);

+		tp = (lim->max.i <= ilim->max.i) ? inttype : uinttype;

+		break;

+	case FLOAT:

+		/* TODO: Add support for C99 float math */

+		tp = doubletype;

+		break;

+	default:

+		abort();

+	}

+	if ((new = convert(np, tp, 1)) != NULL)

+		return new;

+	return np;

+}

+

+static void

+arithconv(Node **p1, Node **p2)

+{

+	int to = 0, s1, s2;

+	unsigned r1, r2;

+	Type *tp1, *tp2;

+	Node *np1, *np2;

+	struct limits *lp1, *lp2;

+

+	np1 = promote(*p1);

+	np2 = promote(*p2);

+

+	tp1 = np1->type;

+	tp2 = np2->type;

+

+	if (tp1 == tp2)

+		goto set_p1_p2;

+

+	s1 = (tp1->prop & TSIGNED) != 0;

+	r1 = tp1->n.rank;

+	lp1 = getlimits(tp1);

+

+	s2 = (tp2->prop & TSIGNED) != 0;

+	r2 = tp2->n.rank;

+	lp2 = getlimits(tp2);

+

+	if (s1 == s2 || tp1->op == FLOAT || tp2->op == FLOAT) {

+		to = r1 - r2;

+	} else if (!s1) {

+		if (r1 >= r2 || lp1->max.i >= lp2->max.i)

+			to = 1;

+		else

+			to = -1;

+	} else {

+		if (r2 >= r1 || lp2->max.i >= lp1->max.i)

+			to = -1;

+		else

+			to = 1;

+	}

+

+	if (to > 0)

+		np2 = convert(np2, tp1, 1);

+	else if (to < 0)

+		np1 = convert(np1, tp2, 1);

+		

+set_p1_p2:

+	*p1 = np1;

+	*p2 = np2;

+}

+

+static int

+null(Node *np)

+{

+	if (np->type != pvoidtype || np->op != OCAST)

+		return 0;

+

+	np = np->left;

+	if (np->type != inttype)

+		return 0;

+

+	return cmpnode(np, 0);

+}

+

+static Node *

+chkternary(Node *yes, Node *no)

+{

+	/*

+	 * FIXME:

+	 * We are ignoring type qualifiers here,

+	 * but the standard has strong rules about this.

+	 * take a look to 6.5.15

+	 */

+

+	if (!eqtype(yes->type, no->type, 1)) {

+		if ((yes->type->prop & TARITH) && (no->type->prop & TARITH)) {

+			arithconv(&yes, &no);

+		} else if (yes->type->op != PTR && no->type->op != PTR) {

+			goto wrong_type;

+		} else {

+			/* convert integer 0 to NULL */

+			if ((yes->type->prop & TINTEGER) && cmpnode(yes, 0))

+				yes = convert(yes, pvoidtype, 0);

+			if ((no->type->prop & TINTEGER) && cmpnode(no, 0))

+				no = convert(no, pvoidtype, 0);

+			/*

+			 * At this point the type of both should be

+			 * a pointer to something, or we have don't

+			 * compatible types

+			 */

+			if (yes->type->op != PTR || no->type->op != PTR)

+				goto wrong_type;

+			/*

+			 * If we have a null pointer constant then

+			 * convert to the another type

+			 */

+			if (null(yes))

+				yes = convert(yes, no->type, 0);

+			if (null(no))

+				no = convert(no, yes->type, 0);

+

+			if (!eqtype(yes->type, no->type, 1))

+				goto wrong_type;

+		}

+	}

+	return node(OCOLON, yes->type, yes, no);

+

+wrong_type:

+	errorp("type mismatch in conditional expression");

+	freetree(yes);

+	freetree(no);

+	return constnode(zero);

+}

+

+static void

+chklvalue(Node *np)

+{

+	if (!(np->flags & NLVAL))

+		errorp("lvalue required in operation");

+	if (np->type == voidtype)

+		errorp("invalid use of void expression");

+}

+

+Node *

+decay(Node *np)

+{

+	Node *new;

+	Type *tp = np->type;

+

+	switch (tp->op) {

+	case ARY:

+		tp = tp->type;

+		if (np->op == OPTR) {

+			new = np->left;

+			free(np);

+			new->type = mktype(tp, PTR, 0, NULL);

+			return new;

+		}

+	case FTN:

+		new = node(OADDR, mktype(tp, PTR, 0, NULL), np, NULL);

+		if (np->sym && np->sym->flags & (SGLOBAL|SLOCAL|SPRIVATE))

+			new->flags |= NCONST;

+		return new;

+	default:

+		return np;

+	}

+}

+

+static Node *

+integerop(int op, Node *lp, Node *rp)

+{

+	if (!(lp->type->prop & TINTEGER) || !(rp->type->prop & TINTEGER))

+		error("operator requires integer operands");

+	arithconv(&lp, &rp);

+	return node(op, lp->type, lp, rp);

+}

+

+static Node *

+integeruop(int op, Node *np)

+{

+	if (!(np->type->prop & TINTEGER))

+		error("unary operator requires integer operand");

+	np = promote(np);

+	return node(op, np->type, np, NULL);

+}

+

+static Node *

+numericaluop(int op, Node *np)

+{

+	if (!(np->type->prop & TARITH))

+		error("unary operator requires numerical operand");

+	np = promote(np);

+	return node(op, np->type, np, NULL);

+}

+

+Node *

+convert(Node *np, Type *newtp, int iscast)

+{

+	Type *oldtp = np->type;

+

+	if (eqtype(newtp, oldtp, 0))

+		return np;

+

+	switch (oldtp->op) {

+	case ENUM:

+	case INT:

+	case FLOAT:

+		switch (newtp->op) {

+		case PTR:

+			if (oldtp->op == FLOAT || !cmpnode(np, 0) && !iscast)

+				return NULL;

+		case INT:

+		case FLOAT:

+		case ENUM:

+			break;

+		default:

+			return NULL;

+		}

+		break;

+	case PTR:

+		switch (newtp->op) {

+		case ENUM:

+		case INT:

+		case VOID:

+			if (!iscast)

+				return NULL;

+			break;

+		case PTR:

+			if (eqtype(newtp, oldtp, 1) ||

+			    iscast ||

+			    newtp == pvoidtype || oldtp == pvoidtype) {

+				np->type = newtp;

+				return np;

+			}

+		default:

+			return NULL;

+		}

+		break;

+	default:

+		return NULL;

+	}

+	return node(OCAST, newtp, np, NULL);

+}

+

+static Node *

+parithmetic(int op, Node *lp, Node *rp)

+{

+	Type *tp;

+	Node *size, *np;

+

+	if (lp->type->op != PTR)

+		XCHG(lp, rp, np);

+

+	tp = rp->type;

+	if (tp->op == PTR && !(tp->type->prop & TDEFINED))

+		goto incomplete;

+	tp = lp->type;

+	if (!(tp->type->prop & TDEFINED))

+		goto incomplete;

+	size = sizeofnode(tp->type);

+

+	if (op == OSUB && BTYPE(rp) == PTR) {

+		if ((rp = convert(rp, lp->type, 0)) == NULL)

+			goto incorrect;

+		lp = node(OSUB, pdifftype, lp, rp);

+		return node(ODIV, inttype, lp, size);

+	}

+	if (!(rp->type->prop & TINTEGER))

+		goto incorrect;

+

+	rp = convert(promote(rp), sizettype, 0);

+	rp = node(OMUL, sizettype, rp, size);

+	rp = convert(rp, tp, 1);

+

+	return node(op, tp, lp, rp);

+

+incomplete:

+	errorp("invalid use of undefined type");

+	return lp;

+incorrect:

+	errorp("incorrect arithmetic operands");

+	return lp;

+

+}

+

+static Node *

+arithmetic(int op, Node *lp, Node *rp)

+{

+	Type *ltp = lp->type, *rtp = rp->type;

+

+	if ((ltp->prop & TARITH) && (rtp->prop & TARITH)) {

+		arithconv(&lp, &rp);

+		return node(op, lp->type, lp, rp);

+	} else if ((ltp->op == PTR || rtp->op == PTR)) {

+		switch (op) {

+		case OADD:

+		case OSUB:

+		case OA_ADD:

+		case OA_SUB:

+		case OINC:

+		case ODEC:

+			return parithmetic(op, lp, rp);

+		}

+	}

+	errorp("incorrect arithmetic operands");

+}

+

+static Node *

+pcompare(int op, Node *lp, Node *rp)

+{

+	Node *np;

+

+	if (lp->type->prop & TINTEGER)

+		XCHG(lp, rp, np);

+	else if (eqtype(lp->type, pvoidtype, 1))

+		XCHG(lp, rp, np);

+

+	if ((np = convert(rp, lp->type, 0)) != NULL)

+		rp = np;

+	else

+		errorp("incompatible types in comparison");

+	return convert(node(op, pvoidtype, lp, rp), inttype, 1);

+}

+

+static Node *

+compare(int op, Node *lp, Node *rp)

+{

+	Type *ltp, *rtp;

+

+	ltp = lp->type;

+	rtp = rp->type;

+

+	if (ltp->op == PTR || rtp->op == PTR) {

+		return pcompare(op, rp, lp);

+	} else if ((ltp->prop & TARITH) && (rtp->prop & TARITH)) {

+		arithconv(&lp, &rp);

+		return convert(node(op, lp->type, lp, rp), inttype, 1);;

+	} else {

+		errorp("incompatible types in comparison");

+		freetree(lp);

+		freetree(rp);

+		return constnode(zero);

+	}

+}

+

+int

+negop(int op)

+{

+	switch (op) {

+	case OEQ:  return ONE;

+	case ONE:  return OEQ;

+	case OLT:  return OGE;

+	case OGE:  return OLT;

+	case OLE:  return OGT;

+	case OGT:  return OLE;

+	default:   abort();

+	}

+	return op;

+}

+

+static Node *

+exp2cond(Node *np, int neg)

+{

+	if (np->type->prop & TAGGREG) {

+		errorp("used struct/union type value where scalar is required");

+		return constnode(zero);

+	}

+	switch (np->op) {

+	case ONEG:

+	case OOR:

+	case OAND:

+		return (neg) ? node(ONEG, inttype, np, NULL) : np;

+	case OEQ:

+	case ONE:

+	case OLT:

+	case OGE:

+	case OLE:

+	case OGT:

+		if (neg)

+			np->op = negop(np->op);

+		return np;

+	default:

+		return compare((neg) ?  OEQ : ONE, np, constnode(zero));

+	}

+}

+

+static Node *

+logic(int op, Node *lp, Node *rp)

+{

+	lp = exp2cond(lp, 0);

+	rp = exp2cond(rp, 0);

+	return node(op, inttype, lp, rp);

+}

+

+static Node *

+field(Node *np)

+{

+	Symbol *sym;

+

+	namespace = np->type->ns;

+	next();

+	namespace = NS_IDEN;

+

+	sym = yylval.sym;

+	if (yytoken != IDEN)

+		unexpected();

+	next();

+

+	if (!(np->type->prop & TAGGREG)) {

+		errorp("request for member '%s' in something not a structure or union",

+		      yylval.sym->name);

+		goto free_np;

+	}

+	if ((sym->flags & SDECLARED) == 0) {

+		errorp("incorrect field in struct/union");

+		goto free_np;

+	}

+	np = node(OFIELD, sym->type, np, varnode(sym));

+	np->flags |= NLVAL;

+	return np;

+

+free_np:

+	freetree(np);

+	return constnode(zero);

+}

+

+static Node *

+content(int op, Node *np)

+{

+	if (BTYPE(np) != PTR) {

+		errorp("invalid argument of memory indirection");

+	} else {

+		if (np->op == OADDR) {

+			Node *new = np->left;

+			new->type = np->type->type;

+			free(np);

+			np = new;

+		} else {

+			np = node(op, np->type->type, np, NULL);

+		}

+		np->flags |= NLVAL;

+	}

+	return np;

+}

+

+static Node *

+array(Node *lp, Node *rp)

+{

+	Type *tp;

+	Node *np;

+

+	if (!(lp->type->prop & TINTEGER) && !(rp->type->prop & TINTEGER))

+		error("array subscript is not an integer");

+	np = arithmetic(OADD, lp, rp);

+	tp = np->type;

+	if (tp->op != PTR)

+		errorp("subscripted value is neither array nor pointer");

+	return content(OPTR, np);

+}

+

+static Node *

+assignop(int op, Node *lp, Node *rp)

+{

+	if ((rp = convert(rp, lp->type, 0)) == NULL) {

+		errorp("incompatible types when assigning");

+		return lp;

+	}

+

+	return node(op, lp->type, lp, rp);

+}

+

+static Node *

+incdec(Node *np, int op)

+{

+	Type *tp = np->type;

+	Node *inc;

+

+	chklvalue(np);

+	np->flags |= NEFFECT;

+

+	if (!(tp->prop & TDEFINED)) {

+		errorp("invalid use of undefined type");

+		return np;

+	} else if (tp->op == PTR && !(tp->type->prop & TDEFINED)) {

+		errorp("%s of pointer to an incomplete type",

+		       (op == OINC || op == OA_ADD) ? "increment" : "decrement");

+		return np;

+	} else if (tp->op == PTR || (tp->prop & TARITH)) {

+		inc = constnode(one);

+	} else {

+		errorp("wrong type argument to increment or decrement");

+		return np;

+	}

+	return arithmetic(op, np, inc);

+}

+

+static Node *

+address(int op, Node *np)

+{

+	Node *new;

+

+	/*

+	 * ansi c accepts & applied to a function name, and it generates

+	 * a function pointer

+	 */

+	if (np->op == OSYM) {

+		if (np->type->op == FTN)

+			return decay(np);

+		if (np->type->op == ARY)

+			goto dont_check_lvalue;

+	}

+	chklvalue(np);

+

+dont_check_lvalue:

+	if (np->sym && (np->sym->flags & SREGISTER))

+		errorp("address of register variable '%s' requested", yytext);

+	new = node(op, mktype(np->type, PTR, 0, NULL), np, NULL);

+	if (np->sym && np->sym->flags & (SGLOBAL|SLOCAL|SPRIVATE))

+		new->flags |= NCONST;

+	return new;

+}

+

+static Node *

+negation(int op, Node *np)

+{

+	if (!(np->type->prop & TARITH) && np->type->op != PTR) {

+		errorp("invalid argument of unary '!'");

+		return constnode(zero);

+	}

+	return exp2cond(np, 1);

+}

+

+static Symbol *

+notdefined(Symbol *sym)

+{

+	int isdef;

+

+	if (namespace == NS_CPP && !strcmp(sym->name, "defined")) {

+		disexpand = 1;

+		next();

+		expect('(');

+		sym = yylval.sym;

+		expect(IDEN);

+		expect(')');

+

+		isdef = (sym->flags & SDECLARED) != 0;

+		sym = newsym(NS_IDEN, NULL);

+		sym->type = inttype;

+		sym->flags |= SCONSTANT;

+		sym->u.i = isdef;

+		disexpand = 0;

+		return sym;

+	}

+	errorp("'%s' undeclared", yytext);

+	sym->type = inttype;

+	return install(sym->ns, yylval.sym);

+}

+

+static Symbol *

+adjstrings(Symbol *sym)

+{

+	char *s, *t;

+	size_t len, n;

+	Type *tp;

+

+	tp = sym->type;

+	s = sym->u.s;

+	for (len = strlen(s);; len += n) {

+		next();

+		if (yytoken != STRING)

+			break;

+		t = yylval.sym->u.s;

+		n = strlen(t);

+		s = xrealloc(s, len + n + 1);

+		memcpy(s+len, t, n);

+		s[len + n] = '\0';

+		killsym(yylval.sym);

+	}

+	++len;

+	if (tp->n.elem != len) {

+		sym->type = mktype(chartype, ARY, len, NULL);

+		sym->u.s = s;

+	}

+	return sym;

+}

+

+/*************************************************************

+ * grammar functions                                         *

+ *************************************************************/

+static Node *

+primary(void)

+{

+	Node *np;

+	Symbol *sym;

+	Node *(*fun)(Symbol *);

+

+	sym = yylval.sym;

+	switch (yytoken) {

+	case STRING:

+		np = constnode(adjstrings(sym));

+		sym->flags |= SHASINIT;

+		emit(ODECL, sym);

+		emit(OINIT, np);

+		return varnode(sym);

+	case BUILTIN:

+		fun = sym->u.fun;

+		next();

+		expect('(');

+		np = (*fun)(sym);

+		expect(')');

+

+		/* do not call to next */

+		return np;

+	case CONSTANT:

+		np = constnode(sym);

+		break;

+	case IDEN:

+		assert((sym->flags & SCONSTANT) == 0);

+		if ((sym->flags & SDECLARED) == 0) {

+			if (namespace == NS_CPP) {

+				np = constnode(zero);

+				break;

+			}

+			sym = notdefined(sym);

+		}

+		sym->flags |= SUSED;

+		np = varnode(sym);

+		break;

+	default:

+		unexpected();

+	}

+	next();

+

+	return np;

+}

+

+static Node *

+arguments(Node *np)

+{

+	int toomany, n, op;

+	Node *par = NULL, *arg;

+	Type *argtype, **targs, *tp = np->type, *rettype;

+

+	if (tp->op == PTR && tp->type->op == FTN) {

+		np = content(OPTR, np);

+		tp = np->type;

+	}

+	if (tp->op != FTN) {

+		targs = (Type *[]) {ellipsistype};

+		n = 1;

+		rettype = inttype;

+		errorp("function or function pointer expected");

+	} else {

+		targs = tp->p.pars;

+		n = tp->n.elem;

+		rettype = tp->type;

+	}

+

+	expect('(');

+	if (yytoken == ')')

+		goto no_pars;

+	toomany = 0;

+

+	do {

+		arg = xassign();

+		argtype = *targs;

+		if (argtype == ellipsistype) {

+			n = 0;

+			switch (arg->type->op) {

+			case INT:

+				arg = promote(arg);

+				break;

+			case FLOAT:

+				if (arg->type == floattype)

+					arg = convert(arg, doubletype, 1);

+				break;

+			}

+			par = node(OPAR, arg->type, par, arg);

+			continue;

+		}

+		if (--n < 0) {

+			if (!toomany)

+				errorp("too many arguments in function call");

+			toomany = 1;

+			continue;

+		}

+		++targs;

+		if ((arg = convert(arg, argtype, 0)) != NULL) {

+			par = node(OPAR, arg->type, par, arg);

+			continue;

+		}

+		errorp("incompatible type for argument %d in function call",

+		       tp->n.elem - n + 1);

+	} while (accept(','));

+

+no_pars:

+	expect(')');

+	if (n > 0 && *targs != ellipsistype)

+		errorp("too few arguments in function call");

+

+	op = (tp->prop&TELLIPSIS) ? OCALLE : OCALL;

+	return node(op, rettype, np, par);

+}

+

+static Node *unary(int);

+

+static Type *

+typeof(Node *np)

+{

+	Type *tp;

+

+	if (np == NULL)

+		unexpected();

+	tp = np->type;

+	freetree(np);

+	return tp;

+}

+

+static Type *

+sizeexp(void)

+{

+	Type *tp;

+

+	expect('(');

+	switch (yytoken) {

+	case TYPE:

+	case TYPEIDEN:

+		tp = typename();

+		break;

+	default:

+		tp = typeof(unary(0));

+		break;

+	}

+	expect(')');

+	return tp;

+}

+

+static Node *

+postfix(Node *lp)

+{

+	Node *rp;

+

+	for (;;) {

+		switch (yytoken) {

+		case '[':

+		case DEC:

+		case INC:

+		case INDIR:

+		case '.':

+		case '(':

+			lp = decay(lp);

+			switch (yytoken) {

+			case '[':

+				next();

+				rp = xexpr();

+				expect(']');

+				lp = array(lp, rp);

+				break;

+			case DEC:

+			case INC:

+				lp = incdec(lp, (yytoken == INC) ? OINC : ODEC);

+				next();

+				break;

+			case INDIR:

+				lp = content(OPTR, lp);

+			case '.':

+				lp = field(lp);

+				break;

+			case '(':

+				lp = arguments(lp);

+				lp->flags |= NEFFECT;

+				break;

+			}

+			break;

+		default:

+			return lp;

+		}

+	}

+}

+

+static Node *

+defined(void)

+{

+	Symbol *sym;

+	int paren;

+

+	disexpand = 1;

+	next();

+	paren = accept('(');

+	if (yytoken != IDEN && yytoken != TYPEIDEN)

+		cpperror("operator 'defined' requires an identifier");

+	if (yytoken == TYPEIDEN || !(yylval.sym->flags & SDECLARED))

+		sym = zero;

+	else

+		sym = one;

+	disexpand = 0;

+	next();

+	if (paren)

+		expect(')');

+	return constnode(sym);

+}

+

+static Node *cast(int);

+

+static Node *

+unary(int needdecay)

+{

+	Node *(*fun)(int, Node *), *np;

+	int op;

+	Type *tp;

+

+	switch (yytoken) {

+	case '!': op = 0;     fun = negation;     break;

+	case '+': op = OADD;  fun = numericaluop; break;

+	case '-': op = OSNEG; fun = numericaluop; break;

+	case '~': op = OCPL;  fun = integeruop;   break;

+	case '&': op = OADDR; fun = address;      break;

+	case '*': op = OPTR;  fun = content;      break;

+	case SIZEOF:

+		next();

+		tp = (yytoken == '(') ? sizeexp() : typeof(unary(0));

+		if (!(tp->prop & TDEFINED))

+			errorp("sizeof applied to an incomplete type");

+		return sizeofnode(tp);

+	case INC:

+	case DEC:

+		op = (yytoken == INC) ? OA_ADD : OA_SUB;

+		next();

+		np = incdec(unary(1), op);

+		goto chk_decay;

+	case IDEN:

+	case TYPEIDEN:

+		if (lexmode == CPPMODE && !strcmp(yylval.sym->name, "defined"))

+			return defined();

+	default:

+		np = postfix(primary());

+		goto chk_decay;

+	}

+

+	next();

+	np = (*fun)(op, cast(op != OADDR));

+

+chk_decay:

+	if (needdecay)

+		np = decay(np);

+	return np;

+}

+

+static Node *

+cast(int needdecay)

+{

+	Node *lp, *rp;

+	Type *tp;

+	static int nested;

+

+	if (!accept('('))

+		return unary(needdecay);

+

+	switch (yytoken) {

+	case TQUALIFIER:

+	case TYPE:

+	case TYPEIDEN:

+		tp = typename();

+		expect(')');

+

+		if (yytoken == '{')

+			return initlist(tp);

+

+		switch (tp->op) {

+		case ARY:

+			error("cast specifies an array type");

+		default:

+			lp = cast(needdecay);

+			if ((rp = convert(lp,  tp, 1)) == NULL)

+				error("bad type conversion requested");

+			rp->flags &= ~NLVAL;

+			rp->flags |= lp->flags & NLVAL;

+		}

+		break;

+	default:

+		if (nested == NR_SUBEXPR)

+			error("too many expressions nested by parentheses");

+		++nested;

+		rp = xexpr();

+		--nested;

+		expect(')');

+		rp = postfix(rp);

+		break;

+	}

+

+	return rp;

+}

+

+static Node *

+mul(void)

+{

+	Node *np, *(*fun)(int, Node *, Node *);

+	int op;

+

+	np = cast(1);

+	for (;;) {

+		switch (yytoken) {

+		case '*': op = OMUL; fun = arithmetic; break;

+		case '/': op = ODIV; fun = arithmetic; break;

+		case '%': op = OMOD; fun = integerop;  break;

+		default: return np;

+		}

+		next();

+		np = (*fun)(op, np, cast(1));

+	}

+}

+

+static Node *

+add(void)

+{

+	int op;

+	Node *np;

+

+	np = mul();

+	for (;;) {

+		switch (yytoken) {

+		case '+': op = OADD; break;

+		case '-': op = OSUB; break;

+		default:  return np;

+		}

+		next();

+		np = arithmetic(op, np, mul());

+	}

+}

+

+static Node *

+shift(void)

+{

+	int op;

+	Node *np;

+

+	np = add();

+	for (;;) {

+		switch (yytoken) {

+		case SHL: op = OSHL; break;

+		case SHR: op = OSHR; break;

+		default:  return np;

+		}

+		next();

+		np = integerop(op, np, add());

+	}

+}

+

+static Node *

+relational(void)

+{

+	int op;

+	Node *np;

+

+	np = shift();

+	for (;;) {

+		switch (yytoken) {

+		case '<': op = OLT; break;

+		case '>': op = OGT; break;

+		case GE:  op = OGE; break;

+		case LE:  op = OLE; break;

+		default:  return np;

+		}

+		next();

+		np = compare(op, np, shift());

+	}

+}

+

+static Node *

+eq(void)

+{

+	int op;

+	Node *np;

+

+	np = relational();

+	for (;;) {

+		switch (yytoken) {

+		case EQ: op = OEQ; break;

+		case NE: op = ONE; break;

+		default: return np;

+		}

+		next();

+		np = compare(op, np, relational());

+	}

+}

+

+static Node *

+bit_and(void)

+{

+	Node *np;

+

+	np = eq();

+	while (accept('&'))

+		np = integerop(OBAND, np, eq());

+	return np;

+}

+

+static Node *

+bit_xor(void)

+{

+	Node *np;

+

+	np = bit_and();

+	while (accept('^'))

+		np = integerop(OBXOR,  np, bit_and());

+	return np;

+}

+

+static Node *

+bit_or(void)

+{

+	Node *np;

+

+	np = bit_xor();

+	while (accept('|'))

+		np = integerop(OBOR, np, bit_xor());

+	return np;

+}

+

+static Node *

+and(void)

+{

+	Node *np;

+

+	np = bit_or();

+	while (accept(AND))

+		np = logic(OAND, np, bit_or());

+	return np;

+}

+

+static Node *

+or(void)

+{

+	Node *np;

+

+	np = and();

+	while (accept(OR))

+		np = logic(OOR, np, and());

+	return np;

+}

+

+static Node *

+ternary(void)

+{

+	Node *cond;

+

+	cond = or();

+	while (accept('?')) {

+		Node *ifyes, *ifno, *np;

+

+		cond = exp2cond(cond, 0);

+		ifyes = xexpr();

+		expect(':');

+		ifno = ternary();

+		np = chkternary(ifyes, ifno);

+		cond = node(OASK, np->type, cond, np);

+	}

+	return cond;

+}

+

+static Node *

+xassign(void)

+{

+	Node *np, *(*fun)(int , Node *, Node *);

+	int op;

+

+	np = ternary();

+	for (;;) {

+		switch (yytoken) {

+		case '=':    op = OASSIGN; fun = assignop;   break;

+		case MUL_EQ: op = OA_MUL;  fun = arithmetic; break;

+		case DIV_EQ: op = OA_DIV;  fun = arithmetic; break;

+		case MOD_EQ: op = OA_MOD;  fun = integerop;  break;

+		case ADD_EQ: op = OA_ADD;  fun = arithmetic; break;

+		case SUB_EQ: op = OA_SUB;  fun = arithmetic; break;

+		case SHL_EQ: op = OA_SHL;  fun = integerop;  break;

+		case SHR_EQ: op = OA_SHR;  fun = integerop;  break;

+		case AND_EQ: op = OA_AND;  fun = integerop;  break;

+		case XOR_EQ: op = OA_XOR;  fun = integerop;  break;

+		case OR_EQ:  op = OA_OR;   fun = integerop;  break;

+		default: return np;

+		}

+		chklvalue(np);

+		np->flags |= NEFFECT;

+		next();

+		np = (fun)(op, np, assign());

+	}

+}

+

+static Node *

+xexpr(void)

+{

+	Node *lp, *rp;

+

+	lp = xassign();

+	while (accept(',')) {

+		rp = xassign();

+		lp = node(OCOMMA, rp->type, lp, rp);

+	}

+	return lp;

+}

+

+Node *

+assign(void)

+{

+	return simplify(xassign());

+}

+

+Node *

+constexpr(void)

+{

+	Node *np;

+

+	np = ternary();

+	if (np && np->type->op == INT) {

+		np = simplify(convert(np, inttype, 0));

+		if (np->flags & NCONST)

+			return np;

+	}

+	freetree(np);

+	return NULL;

+}

+

+Node *

+expr(void)

+{

+	return simplify(xexpr());

+}

+

+Node *

+condexpr(int neg)

+{

+	Node *np;

+

+	np = exp2cond(xexpr(), neg);

+	if (np->flags & NCONST)

+		warn("conditional expression is constant");

+	return simplify(np);

+}

--- /dev/null

+++ b/src/cmd/scc/cc1/fold.c

@@ -1,0 +1,685 @@

+static char sccsid[] = "@(#) ./cc1/fold.c";

+#include <assert.h>

+#include <stdlib.h>

+

+#include <scc/scc.h>

+#include "cc1.h"

+

+

+TUINT

+ones(int nbytes)

+{

+	return (nbytes == 8) ? -1 : ~(-1ull << nbytes * 8);

+}

+

+static int

+addi(TINT l, TINT r, Type *tp)

+{

+	struct limits *lim = getlimits(tp);

+	TINT max = lim->max.i, min = -lim->min.i;

+

+	if (l < 0 && r < 0 && l >= min - r ||

+	    l == 0 ||

+	    r == 0 ||

+	    l < 0 && r > 0 ||

+	    l > 0 && r < 0 ||

+	    l > 0 && r > 0 && l <= max - r) {

+		return 1;

+	}

+	warn("overflow in constant expression");

+	return 0;

+}

+

+static int

+addf(TFLOAT l, TFLOAT r, Type *tp)

+{

+	struct limits *lim = getlimits(tp);

+	TFLOAT max = lim->max.f, min = lim->min.f;

+

+	if (l < 0 && r < 0 && l >= min - r ||

+	    l == 0 ||

+	    r == 0 ||

+	    l < 0 && r > 0 ||

+	    l > 0 && r < 0 ||

+	    l > 0 && r > 0 && l <= max - r) {

+		return 1;

+	}

+	warn("overflow in constant expression");

+	return 0;

+}

+

+static int

+subi(TINT l, TINT r, Type *tp)

+{

+	return addi(l, -r, tp);

+}

+

+static int

+subf(TFLOAT l, TFLOAT r, Type *tp)

+{

+	return addf(l, -r, tp);

+}

+

+static int

+muli(TINT l, TINT r, Type *tp)

+{

+	struct limits *lim = getlimits(tp);

+	TINT max = lim->max.i, min = -lim->min.i;

+

+	if (l > -1 && l <= 1 ||

+	    r > -1 && r <= 1 ||

+	    l < 0 && r < 0 && -l <= max/-r ||

+	    l < 0 && r > 0 &&  l >= min/r  ||

+	    l > 0 && r < 0 &&  r >= min/l  ||

+	    l > 0 && r > 0 &&  l <= max/r) {

+			return 1;

+	}

+	warn("overflow in constant expression");

+	return 0;

+}

+

+static int

+mulf(TFLOAT l, TFLOAT r, Type *tp)

+{

+	struct limits *lim = getlimits(tp);

+	TFLOAT max = lim->max.f, min = lim->min.f;

+

+	if (l > -1 && l <= 1 ||

+	    r > -1 && r <= 1 ||

+	    l < 0 && r < 0 && -l <= max/-r ||

+	    l < 0 && r > 0 &&  l >= min/r  ||

+	    l > 0 && r < 0 &&  r >= min/l  ||

+	    l > 0 && r > 0 &&  l <= max/r) {

+			return 1;

+	}

+	warn("overflow in constant expression");

+	return 0;

+}

+

+static int

+divi(TINT l, TINT r,  Type *tp)

+{

+	struct limits *lim = getlimits(tp);

+

+	if (r == 0 || l == -lim->min.i && r == -1) {

+		warn("overflow in constant expression");

+		return 0;

+	}

+	return 1;

+}

+

+static int

+divf(TFLOAT l, TFLOAT r,  Type *tp)

+{

+	struct limits *lim = getlimits(tp);

+

+	if (l < 0) l = -l;

+	if (r < 0) r = -r;

+

+	if (r == 0.0 || r < 1.0 && l > lim->max.f * r) {

+		warn("overflow in constant expression");

+		return 0;

+	}

+	return 1;

+}

+

+static int

+lshi(TINT l, TINT r, Type *tp)

+{

+	if (r < 0 || r >= tp->size * 8) {

+		warn("shifting %d bits is undefined", r);

+		return 0;

+	}

+	return muli(l, 1 << r, tp);

+}

+

+static int

+rshi(TINT l, TINT r, Type *tp)

+{

+	if (r < 0 || r >= tp->size * 8) {

+		warn("shifting %d bits is undefined", r);

+		return 0;

+	}

+	return 1;

+}

+

+static int

+foldint(int op, Symbol *res, TINT l, TINT r)

+{

+	TINT i;

+	Type *tp = res->type;

+	int (*validate)(TINT, TINT, Type *tp);

+

+	switch (op) {

+	case OADD: validate = addi; break;

+	case OSUB: validate = subi; break;

+	case OMUL: validate = muli; break;

+	case ODIV: validate = divi; break;

+	case OSHL: validate = lshi; break;

+	case OSHR: validate = rshi; break;

+	case OMOD: validate = divi; break;

+	default:   validate = NULL; break;

+	}

+

+	if (validate && !(*validate)(l, r, tp))

+		return 0;

+

+	switch (op) {

+	case OADD:  i = l + r;  break;

+	case OSUB:  i = l - r;  break;

+	case OMUL:  i = l * r;  break;

+	case ODIV:  i = l / r;  break;

+	case OMOD:  i = l % r;  break;

+	case OSHL:  i = l << r; break;

+	case OSHR:  i = l >> r; break;

+	case OBAND: i = l & r;  break;

+	case OBXOR: i = l ^ r;  break;

+	case OBOR:  i = l | r;  break;

+	case OAND:  i = l && r; break;

+	case OOR:   i = l || r; break;

+	case OLT:   i = l < r;  break;

+	case OGT:   i = l > r;  break;

+	case OGE:   i = l >= r; break;

+	case OLE:   i = l <= r; break;

+	case OEQ:   i = l == r; break;

+	case ONE:   i = l != r; break;

+	case ONEG:  i = !l;     break;

+	case OSNEG: i = -l;     break;

+	case OCPL:  i = ~l;     break;

+	default:    return 0;

+	}

+	res->u.i = i;

+

+	DBG("FOLD i l=%lld %d r=%lld = %lld", l, op, r, i);

+	return 1;

+}

+

+static int

+folduint(int op, Symbol *res, TUINT l, TUINT r)

+{

+	TINT i;

+	TUINT u;

+

+	switch (op) {

+	case OADD:  u = l + r;  break;

+	case OSUB:  u = l - r;  break;

+	case OMUL:  u = l * r;  break;

+	case ODIV:  u = l / r;  break;

+	case OMOD:  u = l % r;  break;

+	case OSHL:  u = l << r; break;

+	case OSHR:  u = l >> r; break;

+	case OBAND: u = l & r;  break;

+	case OBXOR: u = l ^ r;  break;

+	case OBOR:  u = l | r;  break;

+	case ONEG:  u = !l;     break;

+	case OSNEG: u = -l;     break;

+	case OCPL:  u = ~l;     break;

+	case OAND:  i = l && r; goto sign;

+	case OOR:   i = l || r; goto sign;

+	case OLT:   i = l < r;  goto sign;

+	case OGT:   i = l > r;  goto sign;

+	case OGE:   i = l >= r; goto sign;

+	case OLE:   i = l <= r; goto sign;

+	case OEQ:   i = l == r; goto sign;

+	case ONE:   i = l != r; goto sign;

+	default:    return 0;

+	}

+	res->u.u = u & ones(res->type->size);

+

+	DBG("FOLD ui l=%llu %d r=%llu = %llu", l, op, r, u);

+	return 1;

+

+sign:

+	res->u.i = i;

+

+	DBG("FOLD sui %llu %d %llu = %llu", l, op, r, i);

+	return 1;

+}

+

+static int

+foldfloat(int op, Symbol *res, TFLOAT l, TFLOAT r)

+{

+	TFLOAT f;

+	TINT i;

+	int (*validate)(TFLOAT, TFLOAT, Type *tp);

+

+	switch (op) {

+	case OADD: validate = addf; break;

+	case OSUB: validate = subf; break;

+	case OMUL: validate = mulf; break;

+	case ODIV: validate = divf; break;

+	default:   validate = NULL; break;

+	}

+

+	if (validate && !(*validate)(l, r, res->type))

+		return 0;

+

+	switch (op) {

+	case OADD: f = l + r;  break;

+	case OSUB: f = l - r;  break;

+	case OMUL: f = l * r;  break;

+	case ODIV: f = l / r;  break;

+	case OLT:  i = l < r;  goto comparison;

+	case OGT:  i = l > r;  goto comparison;

+	case OGE:  i = l >= r; goto comparison;

+	case OLE:  i = l <= r; goto comparison;

+	case OEQ:  i = l == r; goto comparison;

+	case ONE:  i = l != r; goto comparison;

+	default:   return 0;

+	}

+	res->u.f = f;

+

+	DBG("FOLD f l=%lf %d r=%lf = %lf", l, op, r, f);

+	return 1;

+

+comparison:

+	res->u.i = i;

+

+	DBG("FOLD if l=%lf %d r=%lf = %lld", l, op, r, i);

+	return 1;

+}

+

+static Node *

+foldconst(int type, int op, Type *tp, Symbol *ls, Symbol *rs)

+{

+	Symbol *sym, aux;

+	TINT i;

+	TUINT u;

+	TFLOAT f;

+

+	aux.type = tp;

+	switch (type) {

+	case INT:

+		i = (rs) ? rs->u.i : 0;

+		if (!foldint(op, &aux, ls->u.i, i))

+			return NULL;

+		break;

+	case UNSIGNED:

+		u = (rs) ? rs->u.u : 0u;

+		if (!folduint(op, &aux, ls->u.u, u))

+			return NULL;

+		break;

+	case FLOAT:

+		f = (rs) ? rs->u.f : 0.0;

+		if (!foldfloat(op, &aux, ls->u.f, f))

+			return NULL;

+		break;

+	}

+	sym = newsym(NS_IDEN, NULL);

+	sym->flags |= SCONSTANT;

+	sym->type = tp;

+	sym->u = aux.u;

+	return constnode(sym);

+}

+

+static Node *

+foldcast(Node *np, Node *l)

+{

+	TUINT negmask, mask, u;

+	Type *newtp = np->type, *oldtp = l->type;

+	Symbol aux, *sym, *osym = l->sym;

+

+	if (!(l->flags & NCONST))

+		return np;

+

+	switch (newtp->op) {

+	case PTR:

+	case INT:

+	case ENUM:

+		switch (oldtp->op) {

+		case PTR:

+		case INT:

+		case ENUM:

+			u = (oldtp->prop & TSIGNED) ? osym->u.i : osym->u.u;

+			break;

+		case FLOAT:

+			oldtp = newtp;

+			u = osym->u.f;

+			break;

+		default:

+			return  np;

+		}

+		mask = ones(newtp->size);

+		if (newtp->prop & TSIGNED) {

+			negmask = ~mask;

+			if (u & (negmask >> 1) & mask)

+				u |= negmask;

+			aux.u.i = u;

+		} else {

+			aux.u.u = u & mask;

+		}

+		break;

+	case FLOAT:

+		/* FIXME: The cast can be from another float type */

+		aux.u.f = (oldtp->prop & TSIGNED) ? osym->u.i : osym->u.u;

+		break;

+	default:

+		return np;

+	}

+	DBG("FOLD cast %c->%c", oldtp->letter, newtp->letter);

+	freetree(np);

+	sym = newsym(NS_IDEN, NULL);

+	sym->flags |= SCONSTANT;

+	sym->type = newtp;

+	sym->u = aux.u;

+	return constnode(sym);

+}

+

+static Node *

+foldunary(Node *np, Node *l)

+{

+	int op = l->op;

+	Node *aux;

+

+	switch (np->op) {

+	case ONEG:

+		if (l->op == ONEG)

+			break;

+		return NULL;

+	case OADD:

+		DBG("FOLD unary delete %d", np->op);

+		np->left = NULL;

+		freetree(np);

+		return l;

+	case OCAST:

+		if (op != OCAST)

+			return foldcast(np, l);

+		/* TODO: This is wrong: (float)(int) 7.2 */

+		DBG("FOLD unary collapse %d", np->op);

+		np->left = l->left;

+		l->left = NULL;

+		freetree(l);

+		return np;

+	case OSNEG:

+	case OCPL:

+		if (op != np->op)

+			return NULL;

+		break;

+	case OPTR:

+		if (op != OADDR || np->type != l->left->type)

+			return NULL;

+		break;

+	case OADDR:

+		if (op != OPTR)

+			return NULL;

+		break;

+	default:

+		return NULL;

+	}

+	DBG("FOLD unary cancel %d", np->op);

+	aux = l->left;

+	l->left = NULL;

+	freetree(np);

+	return aux;

+}

+

+static Node *

+fold(Node *np)

+{

+	Symbol *rs, *ls;

+	Type *optype;

+	int type;

+	int op = np->op;

+	Node *p, *lp = np->left, *rp = np->right;

+	Type *tp = np->type;

+

+	assert(lp && rp);

+	if ((op == ODIV || op == OMOD) && cmpnode(rp, 0)) {

+		warn("division by 0");

+		return NULL;

+	}

+	/*

+	 * Return if any of the children is no constant,

+	 * or it is a constant generated when

+	 * the address of a static variable is taken

+	 * (when we don't know the physical address so

+	 * we cannot fold it)

+	 */

+	if (!rp) {

+		rs = NULL;

+	} else {

+		if (!(rp->flags & NCONST) || !rp->sym)

+			return NULL;

+		rs = rp->sym;

+	}

+

+	if (!(lp->flags & NCONST) || !lp->sym)

+		return NULL;

+	optype = lp->type;

+	ls = lp->sym;

+

+	switch (type = optype->op) {

+	case ENUM:

+	case INT:

+		if (!(optype->prop & TSIGNED))

+			type = UNSIGNED;

+	case PTR:

+	case FLOAT:

+		if ((p = foldconst(type, op, tp, ls, rs)) == NULL)

+			return NULL;

+		freetree(np);

+		return p;

+	default:

+		return NULL;

+	}

+}

+

+static void

+commutative(Node *np, Node *l, Node *r)

+{

+	int op = np->op;

+

+	if (r == NULL || r->flags&NCONST || !(l->flags&NCONST))

+		return;

+

+	switch (op) {

+	case OLT:

+	case OGT:

+	case OGE:

+	case OLE:

+		DBG("FOLD neg commutative %d", np->op);

+		np->op = negop(op);

+	case OEQ:

+	case ONE:

+	case OADD:

+	case OMUL:

+	case OBAND:

+	case OBXOR:

+	case OBOR:

+		DBG("FOLD commutative %d", np->op);

+		np->left = r;

+		np->right = l;

+		break;

+	}

+}

+

+static Node *

+identity(Node *np)

+{

+	int iszeror, isoner;

+	int iszerol, isonel;

+	Node *lp = np->left, *rp = np->right;

+

+	if (!rp)

+		return NULL;

+

+	iszeror = cmpnode(rp, 0);

+	isoner = cmpnode(rp, 1),

+	iszerol = cmpnode(lp, 0);

+	isonel = cmpnode(lp, 1);

+

+	switch (np->op) {

+	case OOR:

+		/*

+		 * 1 || i => 1    (free right)

+		 * i || 0 => i    (free right)

+		 * 0 || i => i    (free left)

+		 * i || 1 => i,1  (comma)

+		 */

+		if (isonel | iszeror)

+			goto free_right;

+		if (iszerol)

+			goto free_left;

+		if (isoner)

+			goto change_to_comma;

+		return NULL;

+	case OAND:

+		/*

+		 * 0 && i => 0    (free right)

+		 * i && 1 => i    (free right)

+		 * 1 && i => i    (free left)

+		 * i && 0 => i,0  (comma)

+		 */

+		if (iszerol | isoner)

+			goto free_right;

+		if (isonel)

+			goto free_left;

+		if (iszeror)

+			goto change_to_comma;

+		return NULL;

+	case OSHL:

+	case OSHR:

+		/*

+		 * i >> 0 => i    (free right)

+		 * i << 0 => i    (free right)

+		 * 0 >> i => 0    (free right)

+		 * 0 << i => 0    (free right)

+		 */

+		if (iszeror | iszerol)

+			goto free_right;

+		return NULL;

+	case OBXOR:

+	case OADD:

+	case OBOR:

+	case OSUB:

+		/*

+		 * i + 0  => i

+		 * i - 0  => i

+		 * i | 0  => i

+		 * i ^ 0  => i

+		 */

+		if (iszeror)

+			goto free_right;

+		return NULL;

+	case OMUL:

+		/*

+		 * i * 0  => i,0

+		 * i * 1  => i

+		 */

+		if (iszeror)

+			goto change_to_comma;

+		if (isoner)

+			goto free_right;

+		return NULL;

+	case ODIV:

+		/* i / 1  => i */

+		if (isoner)

+			goto free_right;

+		return NULL;

+	case OBAND:

+		/* i & ~0 => i */

+		if (cmpnode(rp, -1))

+			goto free_right;

+		return NULL;

+	case OMOD:

+		/* i % 1  => i,1 */

+		/* TODO: i % 2^n => i & n-1 */

+		if (isoner)

+			goto change_to_comma;

+	default:

+		return NULL;

+	}

+

+free_right:

+	DBG("FOLD identity %d", np->op);

+	np->left = NULL;

+	freetree(np);

+	return lp;

+

+free_left:

+	DBG("FOLD identity %d", np->op);

+	np->right = NULL;

+	freetree(np);

+	return rp;

+

+change_to_comma:

+	DBG("FOLD identity %d", np->op);

+	np->op = OCOMMA;

+	return np;

+}

+

+static Node *

+foldternary(Node *np, Node *cond, Node *body)

+{

+	if (!(cond->flags & NCONST))

+		return np;

+	if (cmpnode(cond, 0)) {

+		np = body->right;

+		freetree(body->left);

+	} else {

+		np = body->left;

+		freetree(body->right);

+	}

+

+	DBG("FOLD ternary");

+	body->left = NULL;

+	body->right = NULL;

+	freetree(cond);

+	free(body);

+	return np;

+}

+

+/* TODO: fold OCOMMA */

+

+Node *

+simplify(Node *np)

+{

+	Node *p, *l, *r;

+

+	if (!np)

+		return NULL;

+	if (debug)

+		prtree(np);

+

+	l = np->left = simplify(np->left);

+	r = np->right = simplify(np->right);

+

+	switch (np->op) {

+	case OASK:

+		return foldternary(np, l, r);

+	case OCALL:

+	case OPAR:

+	case OSYM:

+	case OASSIGN:

+	case OA_MUL:

+	case OA_DIV:

+	case OA_MOD:

+	case OA_ADD:

+	case OA_SUB:

+	case OA_SHL:

+	case OA_SHR:

+	case OA_AND:

+	case OA_XOR:

+	case OA_OR:

+		return np;

+	case OSNEG:

+	case OCPL:

+	case OADDR:

+	case OPTR:

+	case INC:

+	case DEC:

+	case OCAST:

+	case ONEG:

+		assert(!r);

+		if ((p = foldunary(np, l)) != NULL)

+			return p;

+		return np;

+	default:

+		commutative(np, l, r);

+		if ((p = fold(np)) != NULL)

+			return p;

+		if ((p = identity(np)) != NULL)

+			return p;

+		return np;

+	}

+}

--- /dev/null

+++ b/src/cmd/scc/cc1/init.c

@@ -1,0 +1,378 @@

+static char sccsid[] = "@(#) ./cc1/init.c";

+#include <stdint.h>

+#include <stdlib.h>

+#include <string.h>

+

+#include <scc/cstd.h>

+#include <scc/scc.h>

+#include "cc1.h"

+

+

+typedef struct init Init;

+

+struct designator {

+	TINT pos;

+	Node *expr;

+	struct designator *next;

+};

+

+struct init {

+	TUINT pos;

+	TUINT max;

+	struct designator *tail;

+	struct designator *head;

+};

+

+static TINT

+arydesig(Type *tp, Init *ip)

+{

+	TINT npos;

+	Node *np;

+

+	if (tp->op != ARY)

+		errorp("array index in non-array initializer");

+	next();

+	np = constexpr();

+	npos = np->sym->u.i;

+	if (npos < 0 || (tp->prop & TDEFINED) && npos >= tp->n.elem) {

+		errorp("array index in initializer exceeds array bounds");

+		npos = 0;

+	}

+	freetree(np);

+	expect(']');

+	return npos;

+}

+

+static TINT

+fielddesig(Type *tp, Init *ip)

+{

+	int ons;

+	Symbol *sym, **p;

+

+	if (!(tp->prop & TAGGREG))

+		errorp("field name not in record or union initializer");

+	ons = namespace;

+	namespace = tp->ns;

+	next();

+	namespace = ons;

+	if (yytoken != IDEN)

+		unexpected();

+	sym = yylval.sym;

+	next();

+	if ((sym->flags & SDECLARED) == 0) {

+		errorp("unknown field '%s' specified in initializer",

+		      sym->name);

+		return 0;

+	}

+	for (p = tp->p.fields; *p != sym; ++p)

+		;

+	return p - tp->p.fields;

+}

+

+static Init *

+init(Init *ip)

+{

+	ip->tail = ip->head = NULL;

+	ip->pos = ip->max = 0;

+	return ip;

+}

+

+static Node *

+str2ary(Type *tp)

+{

+	Node *np;

+	Type *btp = tp->type;;

+	Symbol *sym;

+	size_t len;

+	char *s;

+

+	np = assign();

+	sym = np->left->sym;

+	if (btp != chartype && btp != uchartype && btp != schartype) {

+		errorp("array of inappropriate type initialized from string constant");

+		return constnode(zero);

+	}

+

+	len = sym->type->n.elem-1;

+	if (!(tp->prop & TDEFINED)) {

+		tp->n.elem = len+1;

+		deftype(tp);

+	} else if (tp->n.elem < len) {

+		warn("initializer-string for array of chars is too long");

+	}

+

+	len = tp->n.elem;

+	s = sym->u.s;

+	sym = newstring(NULL, len);

+	strncpy(sym->u.s, s, len);

+	np->sym = sym;

+	np->type = sym->type;

+

+	return np;

+}

+

+static Node *

+initialize(Type *tp)

+{

+	Node *np;

+	Symbol *sym;

+

+	if (tp->op == ARY && yytoken == STRING)

+		return str2ary(tp);

+

+	if (yytoken == '{' || tp->op == STRUCT || tp->op == ARY)

+		return initlist(tp);

+

+	np = assign();

+	if (eqtype(tp, np->type, 1))

+		return np;

+

+	np = convert(decay(np), tp, 0);

+	if (!np) {

+		errorp("incorrect initializer");

+		return constnode(zero);

+	}

+

+	return simplify(np);

+}

+

+static Node *

+mkcompound(Init *ip, Type *tp)

+{

+	Node **v, **p;

+	size_t n;

+	struct designator *dp, *next;

+	Symbol *sym;

+

+	if (tp->op == UNION) {

+		Node *np = NULL;

+

+		v = xmalloc(sizeof(*v));

+		for (dp = ip->head; dp; dp = next) {

+			freetree(np);

+			np = dp->expr;

+			next = dp->next;

+			free(dp);

+		}

+		*v = np;

+	} else {

+		n = (tp->prop&TDEFINED) ? tp->n.elem : ip->max;

+		if (n == 0) {

+			v = NULL;

+		} else if (n > SIZE_MAX / sizeof(*v)) {

+			errorp("compound literal too big");

+			return constnode(zero);

+		} else {

+			n *= sizeof(*v);

+			v = memset(xmalloc(n), 0, n);

+

+			for (dp = ip->head; dp; dp = next) {

+				p = &v[dp->pos];

+				freetree(*p);

+				*p = dp->expr;

+				next = dp->next;

+				free(dp);

+			}

+		}

+	}

+

+	sym = newsym(NS_IDEN, NULL);

+	sym->u.init = v;

+	sym->type = tp;

+	sym->flags |= SINITLST;

+

+	return constnode(sym);

+}

+

+static void

+newdesig(Init *ip, Node *np)

+{

+	struct designator *dp;

+

+	dp = xmalloc(sizeof(*dp));

+	dp->pos = ip->pos;

+	dp->expr = np;

+	dp->next = NULL;

+

+	if (ip->head == NULL) {

+		ip->head = ip->tail = dp;

+	} else {

+		ip->tail->next = dp;

+		ip->tail = dp;

+	}

+

+	if (ip->pos+1 > ip->max)

+		ip->max = ip->pos+1;

+}

+

+Node *

+initlist(Type *tp)

+{

+	Init in;

+	Node *np;

+	Type *curtp;

+	int braces, scalar, toomany, outbound;

+	TINT nelem = tp->n.elem;

+	static int depth;

+

+	if (depth == NR_SUBTYPE)

+		error("too many nested initializers");

+	++depth;

+	init(&in);

+	braces = scalar = toomany = 0;

+

+	if (accept('{'))

+		braces = 1;

+

+	do {

+		curtp = inttype;

+		switch (yytoken) {

+		case '[':

+			in.pos = arydesig(tp, &in);

+			curtp = tp->type;

+			goto desig_list;

+		case '.':

+			in.pos = fielddesig(tp, &in);

+			if (in.pos < nelem)

+				curtp = tp->p.fields[in.pos]->type;

+		desig_list:

+			if (yytoken == '[' || yytoken == '.') {

+				np = initlist(curtp);

+				goto new_desig;

+			}

+			expect('=');

+		default:

+			outbound = 0;

+

+			switch (tp->op) {

+			case ARY:

+				curtp = tp->type;

+				if (!(tp->prop & TDEFINED) || in.pos < tp->n.elem)

+					break;

+				if (!toomany)

+					warn("excess elements in array initializer");

+				toomany = 1;

+				outbound = 1;

+				break;

+			case UNION:

+			case STRUCT:

+				if (in.pos < nelem) {

+					curtp = tp->p.fields[in.pos]->type;

+					break;

+				}

+				if (!toomany)

+					warn("excess elements in struct initializer");

+				toomany = 1;

+				outbound = 1;

+				break;

+			default:

+				curtp = tp;

+				if (!scalar)

+					warn("braces around scalar initializer");

+				scalar = 1;

+				if (in.pos == 0)

+					break;

+				if (!toomany)

+					warn("excess elements in scalar initializer");

+				toomany = 1;

+				outbound = 1;

+				break;

+			}

+			np = initialize(curtp);

+			if (outbound) {

+				freetree(np);

+				np = NULL;

+			}

+		}

+

+new_desig:

+		if (np)

+			newdesig(&in, np);

+		if (++in.pos == 0)

+			errorp("compound literal too big");

+		if (nelem == in.pos && !braces)

+			break;

+	} while (accept(','));

+

+	if (braces)

+		expect('}');

+

+

+	if (tp->op == ARY && !(tp->prop & TDEFINED)) {

+		tp->n.elem = in.max;

+		deftype(tp);

+	}

+	if (in.max == 0) {

+		errorp("empty braced initializer");

+		return constnode(zero);

+	}

+

+	return mkcompound(&in, tp);

+}

+

+static void

+autoinit(Symbol *sym, Node *np)

+{

+	Symbol *hidden;

+	Type *tp = sym->type;

+	size_t n; /* FIXME: It should be SIZET */

+

+repeat:

+	switch (tp->op) {

+	case UNION:

+		np = np->sym->u.init[0];

+		tp = np->type;

+		goto repeat;

+	case ARY:

+	case STRUCT:

+		if (!(np->flags & NCONST))

+			abort(); /* TODO */

+		hidden = newsym(NS_IDEN, NULL);

+		hidden->type = sym->type;

+		hidden->flags |= SLOCAL | SHASINIT;

+		emit(ODECL, hidden);

+		emit(OINIT, np);

+		emit(ODECL, sym);

+		emit(OEXPR,

+		     node(OASSIGN, tp, varnode(sym), varnode(hidden)));

+		break;

+	default:

+		emit(ODECL, sym);

+		np = node(OASSIGN, tp, varnode(sym), np);

+		emit(OEXPR, np);

+		break;

+	}

+}

+

+void

+initializer(Symbol *sym, Type *tp)

+{

+	Node *np;

+	int flags = sym->flags;

+

+	if (tp->op == FTN) {

+		errorp("function '%s' initialized like a variable",

+		       sym->name);

+		tp = inttype;

+	}

+	np = initialize(tp);

+

+	if (flags & SDEFINED) {

+		errorp("redeclaration of '%s'", sym->name);

+	} else if ((flags & (SGLOBAL|SLOCAL|SPRIVATE)) != 0) {

+		if (!(np->flags & NCONST)) {

+			errorp("initializer element is not constant");

+			return;

+		}

+		sym->flags |= SHASINIT;

+		sym->flags &= ~SEMITTED;

+		emit(ODECL, sym);

+		emit(OINIT, np);

+		sym->flags |= SDEFINED;

+	} else if ((flags & (SEXTERN|STYPEDEF)) != 0) {

+		errorp("'%s' has both '%s' and initializer",

+		       sym->name, (flags&SEXTERN) ? "extern" : "typedef");

+	} else {

+		autoinit(sym, np);

+	}

+}

--- /dev/null

+++ b/src/cmd/scc/cc1/ir.md

@@ -1,0 +1,443 @@

+# scc intermediate representation #

+

+The scc IR tries to be be a simple and easily parseable intermediate

+representation, and it makes it a bit terse and cryptic. The main

+characteristic of the IR is that all the types and operations are

+represented with only one letter, so parsing tables can be used

+to parse it.

+

+The language is composed of lines, representing statements.

+Each statement is composed of tab-separated fields.

+Declaration statements begin in column 0, expressions and

+control flow begin with a tabulator.

+When the frontend detects an error, it closes the output stream.

+

+## Types ##

+

+Types are represented with uppercase letters:

+

+* C -- signed    8-Bit integer

+* I -- signed   16-Bit integer

+* W -- signed   32-Bit integer

+* Q -- signed   64-Bit integer

+* K -- unsigned  8-Bit integer

+* N -- unsigned 16-Bit integer

+* Z -- unsigned 32-Bit integer

+* O -- unsigned 64-Bit integer

+* 0 -- void

+* P -- pointer

+* F -- function

+* V -- vector

+* U -- union

+* S -- struct

+* B -- bool

+* J -- float

+* D -- double

+* H -- long double

+

+This list has been built for the original Z80 backend, where 'int'

+has the same size as 'short'. Several types (S, F, V, U and others) need

+an identifier after the type letter for better differentiation

+between multiple structs, functions, vectors and unions (S1, V12 ...)

+naturally occuring in a C-program.

+

+## Storage classes ##

+

+The storage classes are represented using uppercase letters:

+

+* A -- automatic

+* R -- register

+* G -- public (global variable declared in the module)

+* X -- extern (global variable declared in another module)

+* Y -- private (variable in file-scope)

+* T -- local (static variable in function-scope)

+* M -- member (struct/union member)

+* L -- label

+

+## Declarations/definitions ##

+

+Variable names are composed of a storage class and an identifier

+(e.g. A1, R2, T3).

+Declarations and definitions are composed of a variable

+name, a type and the name of the variable:

+

+	A1	I	maxweight

+	R2	C	flag

+	A3	S4	statstruct

+

+### Type declarations ###

+

+Some declarations (e.g. structs) involve the declaration of member

+variables.

+Struct members are declared normally after the type declaration in

+parentheses.

+

+For example the struct declaration

+

+	struct foo {

+		int i;

+		long c;

+	} var1;

+

+generates

+

+	S2      foo     (

+	M3      I       i

+	M4      W       c

+	)

+	G5      S2      var1

+

+## Functions ##

+

+A function prototype

+

+	int printf(char *cmd, int flag, void *data);

+

+will generate a type declaration and a variable declaration

+

+	F5	P	I	P

+	X1	F5	printf

+

+The first line gives the function-type specification 'F' with

+an identifier '5' and subsequently lists the types of the

+function parameters.

+The second line declares the 'printf' function as a publicly

+scoped variable.

+

+Analogously, a statically declared function in file scope

+

+	static int printf(char *cmd, int flag, void *data);

+

+generates

+

+	F5      P       I       P

+	T1      F5      printf

+

+Thus, the 'printf' variable  went into local scope ('T').

+

+A '{' in the first column starts the body of the previously

+declared function:

+

+	int printf(char *cmd, int flag, void *data) {}

+

+generates

+

+	F5      P       I       P

+	G1      F5      printf

+	{

+	A2      P       cmd

+	A3      I       flag

+	A4      P       data

+	-

+	}

+

+Again, the frontend must ensure that '{' appears only after the

+declaration of a function. The character '-' marks the separation

+between parameters and local variables:

+

+	int printf(register char *cmd, int flag, void *data) {int i;};

+

+generates

+

+	F5      P       I       P

+	G1      F5      printf

+	{

+	R2      P       cmd

+	A3      I       flag

+	A4      P       data

+	-

+	A6      I       i

+	}

+

+### Expressions ###

+

+Expressions are emitted in reverse polish notation, simplifying

+parsing and converting into a tree representation.

+

+#### Operators ####

+

+Operators allowed in expressions are:

+

+* \+ -- addition

+* \- -- substraction

+* \* -- multiplication

+* % -- modulo

+* / -- division

+* l -- left shift

+* r -- right shift

+* < -- less than

+* > -- greather than

+* ] -- greather or equal than

+* [ -- less or equal than

+* = -- equal than

+* ! -- different than

+* & -- bitwise and

+* | -- bitwise or

+* ^ -- bitwise xor

+* ~ -- bitwise complement

+* : -- asignation

+* _ -- unary negation

+* c -- function call

+* p -- parameter

+* . -- field

+* , -- comma operator

+* ? -- ternary operator

+* ' -- take address

+* a -- logical shortcut and

+* o -- logical shortcut or

+* @ -- content of pointer

+

+Assignation has some suboperators:

+

+* :/ -- divide and assign

+* :% -- modulo and assign

+* :+ -- addition and assign

+* :- -- substraction and assign

+* :l -- left shift and assign

+* :r -- right shift and assign

+* :& -- bitwise and and assign

+* :^ -- bitwise xor and assign

+* :| -- bitwise or and assign

+* :i -- post increment

+* :d -- post decrement

+

+Every operator in an expression has a type descriptor.

+

+#### Constants ####

+

+Constants are introduced with the character '#'. For instance, 10 is

+translated to #IA (all constants are emitted in hexadecimal),

+where I indicates that it is an integer constant.

+Strings are a special case because they are represented with

+the " character.

+The constant "hello" is emitted as "68656C6C6F. For example

+

+	int

+	main(void)

+	{

+		int i, j;

+

+		i = j+2*3;

+	}

+

+generates

+

+	F1

+	G1	F1	main

+	{

+	-

+	A2      I	i

+	A3      I	j

+		A2	A3	#I6	+I	:I

+	}

+

+Type casts are expressed with a tuple denoting the

+type conversion

+

+        int

+	main(void)

+	{

+		int i;

+		long j;

+

+		j = (long)i;

+	}

+

+generates

+

+	F1

+	G1      F1      main

+	{

+	-

+	A2      I       i

+	A3      W       j

+	        A2      A3      WI      :I

+	}

+

+### Statements ###

+#### Jumps #####

+

+Jumps have the following form:

+

+	j	L#	[expression]

+

+the optional expression field indicates some condition which

+must be satisfied to jump. Example:

+

+	int

+	main(void)

+	{

+		int i;

+

+		goto    label;

+	label:

+		i -= i;

+	}

+

+generates

+

+	F1

+	G1      F1      main

+	{

+	-

+	A2	I	i

+		j	L3

+	L3

+		A2	A2	:-I

+	}

+

+Another form of jump is the return statement, which uses the

+letter 'y' followed by a type identifier.

+Depending on the type, an optional expression follows.

+

+	int

+	main(void)

+	{

+		return 16;

+	}

+

+generates

+

+	F1

+	G1	F1	main

+	{

+	-

+		yI	#I10

+	}

+

+

+#### Loops ####

+

+There are two special characters that are used to indicate

+to the backend that the following statements are part of

+a loop body.

+

+* b -- beginning of loop

+* e -- end of loop

+

+#### Switch statement ####

+

+Switches are represented using a table, in which the labels

+where to jump for each case are indicated. Common cases are

+represented with 'v' and default with 'f'.

+The switch statement itself is represented with 's' followed

+by the label where the jump table is located, and the

+expression of the switch:

+

+	int

+	func(int n)

+	{

+		switch (n+1) {

+		case 1:

+		case 2:

+		case 3:

+		default:

+			++n;

+		}

+	}

+

+generates

+

+	F2	I

+	G1	F2	func

+	{

+	A1	I	n

+	-

+		s	L4	A1	#I1	+I

+	L5

+	L6

+	L7

+	L8

+		A1	#I1	:+I

+		j	L3

+	L4

+		t	#4

+		v	L7	#I3

+		v	L6	#I2

+		v	L5	#I1

+		f	L8

+	L3

+	}

+

+The beginning of the jump table is indicated by the the letter 't',

+followed by the number of cases (including default case) of the

+switch.

+

+## Resumen ##

+

+* C -- signed    8-Bit integer

+* I -- signed   16-Bit integer

+* W -- signed   32-Bit integer

+* O -- signed   64-Bit integer

+* M -- unsigned  8-Bit integer

+* N -- unsigned 16-Bit integer

+* Z -- unsigned 32-Bit integer

+* Q -- unsigned 64-Bit integer

+* 0 -- void

+* P -- pointer

+* F -- function

+* V -- vector

+* U -- union

+* S -- struct

+* B -- bool

+* J -- float

+* D -- double

+* H -- long double

+* A -- automatic

+* R -- register

+* G -- public (global variable declared in the module)

+* X -- extern (global variable declared in another module)

+* Y -- private (variable in file-scope)

+* T -- local (static variable in function-scope)

+* M -- member (struct/union member)

+* L -- label

+* { -- beginning of function body

+* } -- end of function body

+* \\ -- end of function parameters

+* \+ -- addition

+* \- -- substraction

+* \* -- multiplication

+* % -- modulo

+* / -- division

+* l -- left shift

+* r -- right shift

+* < -- less than

+* > -- greather than

+* ] -- greather or equal than

+* [ -- less or equal than

+* = -- equal than

+* ! -- different than

+* & -- bitwise and

+* | -- bitwise or

+* ^ -- bitwise xor

+* ~ -- bitwise complement

+* : -- asignation

+* _ -- unary negation

+* c -- function call

+* p -- parameter

+* . -- field

+* , -- comma operator

+* ? -- ternary operator

+* ' -- take address

+* a -- logical shortcut and

+* o -- logical shortcut or

+* @ -- content of pointer

+* :/ -- divide and assign

+* :% -- modulo and assign

+* :+ -- addition and assign

+* :- -- substraction and assign

+* :l -- left shift and assign

+* :r -- right shift and assign

+* :& -- bitwise and and assign

+* :^ -- bitwise xor and assign

+* :| -- bitwise or and assign

+* ;+ -- post increment

+* ;- -- post decrement

+* j -- jump

+* y -- return

+* b -- begin of loop

+* d -- end of loop

+* s -- switch statement

+* t -- switch table

+* v -- case entry in switch table

+* f -- default entry in switch table

--- /dev/null

+++ b/src/cmd/scc/cc1/lex.c

@@ -1,0 +1,801 @@

+static char sccsid[] = "@(#) ./cc1/lex.c";

+#include <assert.h>

+#include <ctype.h>

+#include <errno.h>

+#include <limits.h>

+#include <setjmp.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+

+#include <scc/cstd.h>

+#include <scc/scc.h>

+#include "cc1.h"

+

+int yytoken;

+struct yystype yylval;

+char yytext[STRINGSIZ+3];

+unsigned short yylen;

+int lexmode = CCMODE;

+unsigned lineno;

+char filenam[FILENAME_MAX];

+

+int namespace = NS_IDEN;

+static int safe;

+Input *input;

+

+void

+ilex(void)

+{

+	static struct keyword keys[] = {

+		{"auto", SCLASS, AUTO},

+		{"break", BREAK, BREAK},

+		{"_Bool", TYPE, BOOL},

+		{"__builtin_va_list", TYPE, VA_LIST},

+		{"case", CASE, CASE},

+		{"char", TYPE, CHAR},

+		{"const", TQUALIFIER, CONST},

+		{"continue", CONTINUE, CONTINUE},

+		{"default", DEFAULT, DEFAULT},

+		{"do", DO, DO},

+		{"double", TYPE, DOUBLE},

+		{"else", ELSE, ELSE},

+		{"enum", TYPE, ENUM},

+		{"extern", SCLASS, EXTERN},

+		{"float", TYPE, FLOAT},

+		{"for", FOR, FOR},

+		{"goto", GOTO, GOTO},

+		{"if", IF, IF},

+		{"inline", TQUALIFIER, INLINE},

+		{"int", TYPE, INT},

+		{"long", TYPE, LONG},

+		{"register", SCLASS, REGISTER},

+		{"restrict", TQUALIFIER, RESTRICT},

+		{"return", RETURN, RETURN},

+		{"short", TYPE, SHORT},

+		{"signed", TYPE, SIGNED},

+		{"sizeof", SIZEOF, SIZEOF},

+		{"static", SCLASS, STATIC},

+		{"struct", TYPE, STRUCT},

+		{"switch", SWITCH, SWITCH},

+		{"typedef", SCLASS, TYPEDEF},

+		{"union", TYPE, UNION},

+		{"unsigned", TYPE, UNSIGNED},

+		{"void", TYPE, VOID},

+		{"volatile", TQUALIFIER, VOLATILE},

+		{"while", WHILE, WHILE},

+		{NULL, 0, 0},

+	};

+	keywords(keys, NS_KEYWORD);

+}

+

+void

+setloc(char *fname, unsigned line)

+{

+	size_t len;

+

+	if ((len = strlen(fname)) >= FILENAME_MAX)

+		die("cc1: %s: file name too long", fname);

+	memmove(filenam, fname, len);

+	filenam[len] = '\0';

+

+	free(input->filenam);

+	input->filenam = xstrdup(fname);

+	lineno = input->lineno = line;

+}

+

+void

+addinput(char *fname, Symbol *hide, char *buffer)

+{

+	FILE *fp;

+	char *extp;

+	unsigned flags;

+	int infileln;

+	Input *newip, *curip = input;

+

+	if (hide) {

+		/* this is a macro expansion */

+		fp = NULL;

+		if (hide->hide == UCHAR_MAX)

+			die("cc1: too many macro expansions");

+		++hide->hide;

+		flags = IMACRO;

+	} else  if (fname) {

+		/* a new file */

+		if ((fp = fopen(fname, "r")) == NULL)

+			die("cc1: %s: %s", fname, strerror(errno));

+		flags = IFILE;

+		if (curip && onlyheader) {

+			infileln = strlen(infile);

+			if (extp = strrchr(infile, '.'))

+				infileln -= strlen(extp);

+			printf("%.*s.o: %s %s\n",

+			       infileln, infile, infile, fname);

+		}

+	} else {

+		/* reading from stdin */

+		fp = stdin;

+		fname = "<stdin>";

+		flags = ISTDIN;

+	}

+

+	newip = xmalloc(sizeof(*newip));

+

+	if (!buffer) {

+		buffer = xmalloc(INPUTSIZ);

+		buffer[0] = '\0';

+	}

+

+	if (curip)

+		curip->lineno = lineno;

+

+	newip->p = newip->begin = newip->line = buffer;

+	newip->filenam = NULL;

+	newip->lineno = 0;

+	newip->next = curip;

+	newip->fp = fp;

+	newip->hide = hide;

+	newip->flags = flags;

+	input = newip;

+

+	setloc(fname, (curip) ? curip->lineno : newip->lineno);

+}

+

+void

+delinput(void)

+{

+	Input *ip = input;

+	Symbol *hide = ip->hide;

+

+	switch (ip->flags & ITYPE) {

+	case IFILE:

+		if (fclose(ip->fp))

+			die("cc1: %s: %s", ip->filenam, strerror(errno));

+		break;

+	case IMACRO:

+		assert(hide->hide == 1);

+		--hide->hide;

+		break;

+	}

+	input = ip->next;

+	free(ip->filenam);

+	free(ip->line);

+	if (input) {

+		lineno = input->lineno;

+		strcpy(filenam, input->filenam);

+	}

+}

+

+static void

+newline(void)

+{

+	if (++lineno == 0)

+		die("cc1: %s: file too long", filenam);

+}

+

+/*

+ * Read the next character from the input file, counting number of lines

+ * and joining lines escaped with \

+ */

+static int

+readchar(void)

+{

+	FILE *fp = input->fp;

+	int c;

+

+repeat:

+	switch (c = getc(fp)) {

+	case '\\':

+		if ((c = getc(fp)) == '\n') {

+			newline();

+			goto repeat;

+		}

+		ungetc(c, fp);

+		c = '\\';

+		break;

+	case '\n':

+		newline();

+		break;

+	default:

+		if (!isprint(c) && !ispunct(c) && !isspace(c))

+			warn("invalid input character. The shame of UB is yours");

+		break;

+	}

+

+	return c;

+}

+

+/*

+ * discard a C comment. This function is only called from readline

+ * because it is impossible to have a comment in a macro, because

+ * comments are always discarded before processing any cpp directive

+ */

+static void

+comment(int type)

+{

+	int c;

+

+repeat:

+	while ((c = readchar()) != EOF && c != type)

+		;

+

+	if (c == EOF) {

+		errorp("unterminated comment");

+		return;

+	}

+

+	if (type == '*' && (c = readchar()) != '/')

+		goto repeat;

+}

+

+/*

+ * readline is used to read a full logic line from a file.

+ * It discards comments and check that the line fits in

+ * the input buffer

+ */

+static int

+readline(void)

+{

+	char *bp, *lim;

+	int c, peekc = 0;

+

+	if (feof(input->fp)) {

+		input->flags |= IEOF;

+		return 0;

+	}

+

+	*input->line = '\0';

+	lim = &input->line[INPUTSIZ-1];

+	for (bp = input->line; bp < lim-1; *bp++ = c) {

+		c = (peekc) ? peekc : readchar();

+		peekc = 0;

+		if (c == '\n' || c == EOF)

+			break;

+		if (c != '/')

+			continue;

+

+		/* check for /* or // */

+		peekc = readchar();

+		if (peekc != '*' && peekc != '/')

+			continue;

+		comment((peekc == '/') ? '\n' : '*');

+		peekc = 0;

+		c = ' ';

+	}

+

+	input->begin = input->p = input->line;

+	if (bp == lim-1) {

+		errorp("line too long");

+		--bp;

+	}

+	*bp++ = '\n';

+	*bp = '\0';

+

+	return 1;

+}

+

+/*

+ * moreinput gets more bytes to be passed to the lexer.

+ * It can take more bytes from macro expansions or

+ * directly reading from files. When a cpp directive

+ * is processed the line is discarded because it must not

+ * be passed to the lexer

+ */

+static int

+moreinput(void)

+{

+	int wasexpand = 0;

+

+repeat:

+	if (!input)

+		return 0;

+

+	if (*input->p == '\0') {

+		if ((input->flags&ITYPE) == IMACRO) {

+			wasexpand = 1;

+			input->flags |= IEOF;

+		}

+		if (input->flags & IEOF) {

+			delinput();

+			goto repeat;

+		}

+		if (!readline() || cpp()) {

+			*input->p = '\0';

+			goto repeat;

+		}

+	}

+

+	if (onlycpp && !wasexpand)

+		ppragmaln();

+	return 1;

+}

+

+static void

+tok2str(void)

+{

+	if ((yylen = input->p - input->begin) > INTIDENTSIZ)

+		error("token too big");

+	memcpy(yytext, input->begin, yylen);

+	yytext[yylen] = '\0';

+	input->begin = input->p;

+}

+

+static Symbol *

+readint(char *s, int base, int sign, Symbol *sym)

+{

+	Type *tp = sym->type;

+	struct limits *lim;

+	TUINT u, val, max;

+	int c;

+

+	lim = getlimits(tp);

+	max = lim->max.i;

+	if (*s == '0')

+		++s;

+	if (toupper(*s) == 'X')

+		++s;

+

+	for (u = 0; isxdigit(c = *s++); u = u*base + val) {

+		static char letters[] = "0123456789ABCDEF";

+		val = strchr(letters, toupper(c)) - letters;

+	repeat:

+		if (u <= max/base && u*base <= max - val)

+			continue;

+		if (tp->prop & TSIGNED) {

+			if (tp == inttype)

+				tp = (base==10) ? longtype : uinttype;

+			else if (tp == longtype)

+				tp = (base==10) ? llongtype : ulongtype;

+			else

+				goto overflow;

+		} else {

+			if (tp == uinttype)

+				tp = (sign==UNSIGNED) ? ulongtype : longtype;

+			else if (tp == ulongtype)

+				tp = (sign==UNSIGNED) ? ullongtype : llongtype;

+			else

+				goto overflow;

+		}

+		sym->type = tp;

+		lim = getlimits(tp);

+		max = lim->max.i;

+		goto repeat;

+	}

+

+	if (tp->prop & TSIGNED)

+		sym->u.i = u;

+	else

+		sym->u.u = u;

+

+	return sym;

+

+overflow:

+	errorp("overflow in integer constant");

+	return sym;

+}

+

+static int

+integer(char *s, int base)

+{

+	Type *tp;

+	Symbol *sym;

+	unsigned size, sign;

+

+	for (size = sign = 0; ; ++input->p) {

+		switch (toupper(*input->p)) {

+		case 'L':

+			if (size == LLONG)

+				goto wrong_type;

+			size = (size == LONG) ? LLONG : LONG;

+			continue;

+		case 'U':

+			if (sign == UNSIGNED)

+				goto wrong_type;

+			sign = UNSIGNED;

+			continue;

+		default:

+			goto convert;

+		wrong_type:

+			error("invalid suffix in integer constant");

+		}

+	}

+

+convert:

+	tp = ctype(INT, sign, size);

+	sym = newsym(NS_IDEN, NULL);

+	sym->type = tp;

+	sym->flags |= SCONSTANT;

+	yylval.sym = readint(s, base, sign, sym);

+	return CONSTANT;

+}

+

+static char *

+digits(int base)

+{

+	char *p;

+	int c;

+

+	for (p = input->p; c = *p; ++p) {

+		switch (base) {

+		case 8:

+			if (!strchr("01234567", c))

+				goto end;

+			break;

+		case 10:

+			if (!isdigit(c))

+				goto end;

+			break;

+		case 16:

+			if (!isxdigit(c))

+				goto end;

+			break;

+		}

+	}

+end:

+	input->p = p;

+	tok2str();

+	return yytext;

+}

+

+static int

+number(void)

+{

+	int base;

+

+	if (*input->p != '0') {

+		base = 10;

+	} else {

+		if (toupper(*++input->p) == 'X') {

+			++input->p;

+			base = 16;

+		} else {

+			base = 8;

+		}

+	}

+

+	return integer(digits(base), base);

+}

+

+static int

+escape(void)

+{

+	int c, base;

+

+	switch (*++input->p) {

+	case 'a':  return '\a';

+	case 'f':  return '\f';

+	case 'n':  return '\n';

+	case 'r':  return '\r';

+	case 't':  return '\t';

+	case 'v':  return '\v';

+	case '"':  return '"';

+	case '\'': return '\'';

+	case '\\': return '\\';

+	case '\?': return '\?';

+	case 'u':

+		/*

+		 * FIXME: universal constants are not correctly handled

+		 */

+		if (!isdigit(*++input->p))

+			warn("incorrect digit for numerical character constant");

+		base = 10;

+		break;

+	case 'x':

+		if (!isxdigit(*++input->p))

+			warn("\\x used with no following hex digits");

+		base = 16;

+		break;

+	case '0':

+		if (!strchr("01234567", *++input->p))

+			warn("\\0 used with no following octal digits");

+		base = 8;

+		break;

+	default:

+		warn("unknown escape sequence");

+		return ' ';

+	}

+	errno = 0;

+	c = strtoul(input->p, &input->p, base);

+	if (errno || c > 255)

+		warn("character constant out of range");

+	--input->p;

+	return c;

+}

+

+static int

+character(void)

+{

+	int c;

+	Symbol *sym;

+

+	if ((c = *++input->p) == '\\')

+		c = escape();

+	else

+		c = *input->p;

+	++input->p;

+	if (*input->p != '\'')

+		errorp("invalid character constant");

+	else

+		++input->p;

+

+	sym = newsym(NS_IDEN, NULL);

+	sym->u.i = c;

+	sym->type = inttype;

+	yylval.sym = sym;

+	tok2str();

+	return CONSTANT;

+}

+

+static int

+string(void)

+{

+	char *bp = yytext;

+	int c;

+

+	*bp++ = '"';

+	for (++input->p; (c = *input->p) != '"'; ++input->p) {

+		if (c == '\0') {

+			errorp("missing terminating '\"' character");

+			break;

+		}

+		if (c == '\\')

+			c = escape();

+		if (bp == &yytext[STRINGSIZ+1]) {

+			/* TODO: proper error handling here */

+			error("string too long");

+		}

+		*bp++ = c;

+	}

+

+	input->begin = ++input->p;

+	*bp = '\0';

+

+	yylen = bp - yytext + 1;

+	yylval.sym = newstring(yytext+1, yylen-1);

+	*bp++ = '"';

+	*bp = '\0';

+	return STRING;

+}

+

+static int

+iden(void)

+{

+	Symbol *sym;

+	char *p, *begin;

+

+	begin = input->p;

+	for (p = begin; isalnum(*p) || *p == '_'; ++p)

+		;

+	input->p = p;

+	tok2str();

+	if ((sym = lookup(NS_CPP, yytext, NOALLOC)) != NULL) {

+		if (!disexpand && !sym->hide && expand(begin, sym))

+			return next();

+	}

+	sym = lookup(namespace, yytext, ALLOC);

+	yylval.sym = sym;

+	if (sym->flags & SCONSTANT)

+		return CONSTANT;

+	if (sym->token != IDEN)

+		yylval.token = sym->u.token;

+	return sym->token;

+}

+

+static int

+follow(int expect, int ifyes, int ifno)

+{

+	if (*input->p++ == expect)

+		return ifyes;

+	--input->p;

+	return ifno;

+}

+

+static int

+minus(void)

+{

+	switch (*input->p++) {

+	case '-': return DEC;

+	case '>': return INDIR;

+	case '=': return SUB_EQ;

+	default: --input->p; return '-';

+	}

+}

+

+static int

+plus(void)

+{

+	switch (*input->p++) {

+	case '+': return INC;

+	case '=': return ADD_EQ;

+	default: --input->p; return '+';

+	}

+}

+

+static int

+relational(int op, int equal, int shift, int assig)

+{

+	int c;

+

+	if ((c = *input->p++) == '=')

+		return equal;

+	if (c == op)

+		return follow('=', assig, shift);

+	--input->p;

+	return op;

+}

+

+static int

+logic(int op, int equal, int logic)

+{

+	int c;

+

+	if ((c = *input->p++) == '=')

+		return equal;

+	if (c == op)

+		return logic;

+	--input->p;

+	return op;

+}

+

+static int

+dot(void)

+{

+	int c;

+

+	if ((c = *input->p) != '.')

+		return '.';

+	if ((c = *++input->p) != '.')

+		error("incorrect token '..'");

+	++input->p;

+	return ELLIPSIS;

+}

+

+static int

+operator(void)

+{

+	int t;

+

+	switch (t = *input->p++) {

+	case '<': t = relational('<', LE, SHL, SHL_EQ); break;

+	case '>': t = relational('>', GE, SHR, SHR_EQ); break;

+	case '&': t = logic('&', AND_EQ, AND); break;

+	case '|': t = logic('|', OR_EQ, OR); break;

+	case '=': t = follow('=', EQ, '='); break;

+	case '^': t = follow('=', XOR_EQ, '^'); break;

+	case '*': t = follow('=', MUL_EQ, '*'); break;

+	case '/': t = follow('=', DIV_EQ, '/'); break;

+	case '!': t = follow('=', NE, '!'); break;

+	case '#': t = follow('#', '$', '#'); break;

+	case '-': t = minus(); break;

+	case '+': t = plus(); break;

+	case '.': t = dot(); break;

+	}

+	tok2str();

+	return t;

+}

+

+/* TODO: Ensure that namespace is NS_IDEN after a recovery */

+

+/*

+ * skip all the spaces until the next token. When we are in

+ * CPPMODE \n is not considered a whitespace

+ */

+static int

+skipspaces(void)

+{

+	int c;

+

+	for (;;) {

+		switch (c = *input->p) {

+		case '\n':

+			if (lexmode == CPPMODE)

+				goto return_byte;

+			++input->p;

+		case '\0':

+			if (!moreinput())

+				return EOF;

+			break;

+		case ' ':

+		case '\t':

+		case '\v':

+		case '\r':

+		case '\f':

+			++input->p;

+			break;

+		default:

+			goto return_byte;

+		}

+	}

+

+return_byte:

+	input->begin = input->p;

+	return c;

+}

+

+int

+next(void)

+{

+	int c;

+

+	if ((c = skipspaces()) == EOF)

+		yytoken = EOFTOK;

+	else if (isalpha(c) || c == '_')

+		yytoken = iden();

+	else if (isdigit(c))

+		yytoken = number();

+	else if (c == '"')

+		yytoken = string();

+	else if (c == '\'')

+		yytoken = character();

+	else

+		yytoken = operator();

+

+	if (yytoken == EOF) {

+		strcpy(yytext, "<EOF>");

+		if (cppctx)

+			errorp("#endif expected");

+	}

+

+	DBG("TOKEN %s", yytext);

+	return yytoken;

+}

+

+void

+expect(int tok)

+{

+	if (yytoken != tok) {

+		if (isgraph(tok))

+			errorp("expected '%c' before '%s'", tok, yytext);

+		else

+			errorp("unexpected '%s'", yytext);

+	} else {

+		next();

+	}

+}

+

+int

+ahead(void)

+{

+	skipspaces();

+	return *input->begin;

+}

+

+void

+setsafe(int type)

+{

+	safe = type;

+}

+

+void

+discard(void)

+{

+	extern jmp_buf recover;

+	int c;

+

+	input->begin = input->p;

+	for (c = yytoken; ; c = *input->begin++) {

+		switch (safe) {

+		case END_COMP:

+			if (c == '}')

+				goto jump;

+			goto semicolon;

+		case END_COND:

+			if (c == ')')

+				goto jump;

+			break;

+		case END_LDECL:

+			if (c == ',')

+				goto jump;

+		case END_DECL:

+		semicolon:

+			if (c == ';')

+				goto jump;

+			break;

+		}

+		if (c == '\0' && !moreinput())

+			exit(1);

+	}

+jump:

+	yytoken = c;

+	longjmp(recover, 1);

+}

--- /dev/null

+++ b/src/cmd/scc/cc1/main.c

@@ -1,0 +1,102 @@

+static char sccsid[] = "@(#) ./cc1/main.c";

+#include <setjmp.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include <errno.h>

+

+#include <scc/arg.h>

+#include <scc/scc.h>

+#include "cc1.h"

+

+char *argv0, *infile;

+

+int warnings;

+jmp_buf recover;

+

+static struct items uflags;

+int onlycpp, onlyheader;

+

+

+extern int failure;

+

+static void

+defmacro(char *macro)

+{

+	char *p = strchr(macro, '=');

+

+	if (p)

+		*p++ = '\0';

+	else

+		p = "1";

+

+	defdefine(macro, p, "command-line");

+}

+

+static void

+usage(void)

+{

+	fputs("usage: cc1 [-Ewd] [-D def[=val]]... [-U def]... "

+	      "[-I dir]... [-o output] [input]\n", stderr);

+	exit(1);

+}

+

+int

+main(int argc, char *argv[])

+{

+	int i;

+

+	ilex();

+	icpp();

+	icode();

+	ibuilts();

+

+	ARGBEGIN {

+	case 'D':

+		defmacro(EARGF(usage()));

+		break;

+	case 'M':

+		onlyheader = 1;

+		break;

+	case 'E':

+		onlycpp = 1;

+		break;

+	case 'I':

+		incdir(EARGF(usage()));

+		break;

+	case 'U':

+		newitem(&uflags, EARGF(usage()));

+		break;

+	case 'd':

+		DBGON();

+		break;

+	case 'w':

+		warnings = 1;

+		break;

+	default:

+		usage();

+	} ARGEND

+

+	if (argc > 1)

+		usage();

+

+	for (i = 0; i < uflags.n; ++i)

+		undefmacro(uflags.s[i]);

+

+	infile = (*argv) ? *argv : "<stdin>";

+	addinput(*argv, NULL, NULL);

+

+	/*

+	 * we cannot initialize arch until we have an

+	 * output stream, because we maybe want to emit new types

+	 */

+	iarch();

+	if (onlycpp || onlyheader) {

+		outcpp();

+	} else {

+		for (next(); yytoken != EOFTOK; decl())

+			;

+	}

+

+	return failure;

+}

--- /dev/null

+++ b/src/cmd/scc/cc1/stmt.c

@@ -1,0 +1,386 @@

+static char sccsid[] = "@(#) ./cc1/stmt.c";

+#include <stddef.h>

+#include <setjmp.h>

+

+#include <scc/cstd.h>

+#include <scc/scc.h>

+#include "cc1.h"

+

+#define NEGATE   1

+#define NONEGATE 0

+

+Symbol *curfun;

+

+static void stmt(Symbol *lbreak, Symbol *lcont, Switch *lswitch);

+

+static void

+label(void)

+{

+	Symbol *sym;

+

+	switch (yytoken) {

+	case IDEN:

+	case TYPEIDEN:

+		sym = lookup(NS_LABEL, yytext, ALLOC);

+		if (sym->flags & SDEFINED)

+			error("label '%s' already defined", yytext);

+		if ((sym->flags & SDECLARED) == 0)

+			sym = install(NS_LABEL, sym);

+		sym->flags |= SDEFINED;

+		emit(OLABEL, sym);

+		next();

+		expect(':');

+		break;

+	default:

+		unexpected();

+	}

+}

+

+static void

+stmtexp(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

+{

+	Node *np;

+

+	if (accept(';'))

+		return;

+	if (yytoken == IDEN && ahead() == ':') {

+		label();

+		stmt(lbreak, lcont, lswitch);

+		return;

+	}

+	np = expr();

+	if ((np->flags & NEFFECT) == 0)

+		warn("expression without side effects");

+	emit(OEXPR, np);

+	expect(';');

+}

+

+static Node *

+condition(int neg)

+{

+	Node *np;

+

+	expect('(');

+	np = condexpr(neg);

+	expect(')');

+

+	return np;

+}

+

+static void

+While(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

+{

+	Symbol *begin;

+	Node *np;

+

+	begin = newlabel();

+	lcont = newlabel();

+	lbreak = newlabel();

+

+	expect(WHILE);

+	np = condition(NONEGATE);

+

+	emit(OJUMP, lcont);

+

+	emit(OBLOOP, NULL);

+	emit(OLABEL, begin);

+	stmt(lbreak, lcont, lswitch);

+	emit(OLABEL, lcont);

+	emit(OBRANCH, begin);

+	emit(OEXPR, np);

+	emit(OELOOP, NULL);

+

+	emit(OLABEL, lbreak);

+}

+

+static void

+For(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

+{

+	Symbol *begin, *cond;

+	Node *econd, *einc;

+

+	begin = newlabel();

+	lcont = newlabel();

+	cond = newlabel();

+	lbreak = newlabel();

+

+	pushctx();

+

+	expect(FOR);

+	expect('(');

+	switch (yytoken) {

+	case TYPE:

+	case TYPEIDEN:

+	case TQUALIFIER:

+	case SCLASS:

+		decl();

+		break;

+	default:

+		emit(OEXPR, expr());

+	case ';':

+		expect(';');

+		break;

+	}

+	econd = (yytoken != ';') ? condexpr(NONEGATE) : NULL;

+	expect(';');

+	einc = (yytoken != ')') ? expr() : NULL;

+	expect(')');

+

+	emit(OJUMP, cond);

+

+	emit(OBLOOP, NULL);

+	emit(OLABEL, begin);

+	stmt(lbreak, lcont, lswitch);

+	emit(OLABEL, lcont);

+	emit(OEXPR, einc);

+	emit(OLABEL, cond);

+	emit((econd) ? OBRANCH : OJUMP, begin);

+	emit(OEXPR, econd);

+	emit(OELOOP, NULL);

+

+	emit(OLABEL, lbreak);

+

+	popctx();

+}

+

+static void

+Dowhile(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

+{

+	Symbol *begin;

+	Node *np;

+

+	begin = newlabel();

+	lcont = newlabel();

+	lbreak = newlabel();

+

+	expect(DO);

+

+	emit(OBLOOP, NULL);

+	emit(OLABEL, begin);

+	stmt(lbreak, lcont, lswitch);

+	expect(WHILE);

+	np = condition(NONEGATE);

+	emit(OLABEL, lcont);

+	emit(OBRANCH, begin);

+	emit(OEXPR, np);

+	emit(OELOOP, NULL);

+

+	emit(OLABEL, lbreak);

+}

+

+static void

+Return(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

+{

+	Node *np;

+	Type *tp = curfun->type->type;

+

+	expect(RETURN);

+	np = (yytoken != ';') ? decay(expr()) : NULL;

+	expect(';');

+	if (!np) {

+		if (tp != voidtype)

+			warn("function returning non void returns no value");

+		tp = voidtype;

+	} else if (np->type != tp) {

+		if (tp == voidtype)

+			warn("function returning void returns a value");

+		else if ((np = convert(np, tp, 0)) == NULL)

+			errorp("incorrect type in return");

+	}

+	emit(ORET, NULL);

+	emit(OEXPR, np);

+}

+

+static void

+Break(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

+{

+	expect(BREAK);

+	if (!lbreak) {

+		errorp("break statement not within loop or switch");

+	} else {

+		emit(OJUMP, lbreak);

+		expect(';');

+	}

+}

+

+static void

+Continue(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

+{

+	expect(CONTINUE);

+	if (!lcont) {

+		errorp("continue statement not within loop");

+	} else {

+		emit(OJUMP, lcont);

+		expect(';');

+	}

+}

+

+static void

+Goto(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

+{

+	Symbol *sym;

+

+	namespace = NS_LABEL;

+	next();

+	namespace = NS_IDEN;

+

+	if (yytoken != IDEN)

+		unexpected();

+	sym = yylval.sym;

+	if ((sym->flags & SDECLARED) == 0)

+		sym = install(NS_LABEL, sym);

+	sym->flags |= SUSED;

+	emit(OJUMP, sym);

+	next();

+	expect(';');

+}

+

+static void

+Swtch(Symbol *obr, Symbol *lcont, Switch *osw)

+{

+	Switch sw = {0};

+	Node *cond;

+	Symbol *lbreak;

+

+	expect(SWITCH);

+

+	expect ('(');

+	if ((cond = convert(expr(), inttype, 0)) == NULL) {

+		errorp("incorrect type in switch statement");

+		cond = constnode(zero);

+	}

+	expect (')');

+

+	lbreak = newlabel();

+	emit(OBSWITCH, NULL);

+	emit(OEXPR, cond);

+	stmt(lbreak, lcont, &sw);

+	emit(OESWITCH, lbreak);

+	emit(OLABEL, lbreak);

+}

+

+static void

+Case(Symbol *lbreak, Symbol *lcont, Switch *sw)

+{

+	Node *np;

+	Symbol *label;

+

+	expect(CASE);

+	if ((np = constexpr()) == NULL)

+		errorp("case label does not reduce to an integer constant");

+	if (!sw) {

+		errorp("case label not within a switch statement");

+	} else if (sw->nr >= 0 && ++sw->nr == NR_SWITCH) {

+		errorp("too many case labels for a switch statement");

+		sw->nr = -1;

+	}

+	expect(':');

+

+	label = newlabel();

+	emit(OCASE, label);

+	emit(OEXPR, np);

+	emit(OLABEL, label);

+	stmt(lbreak, lcont, sw);

+}

+

+static void

+Default(Symbol *lbreak, Symbol *lcont, Switch *sw)

+{

+	Symbol *label = newlabel();

+

+	if (sw->hasdef)

+		errorp("multiple default labels in one switch");

+	sw->hasdef = 1;

+	expect(DEFAULT);

+	expect(':');

+	emit(ODEFAULT, label);

+	emit(OLABEL, label);

+	stmt(lbreak, lcont, sw);

+}

+

+static void

+If(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

+{

+	Symbol *end, *lelse;

+	Node *np;

+

+	lelse = newlabel();

+	expect(IF);

+	np = condition(NEGATE);

+	emit(OBRANCH, lelse);

+	emit(OEXPR, np);

+	stmt(lbreak, lcont, lswitch);

+	if (accept(ELSE)) {

+		end = newlabel();

+		emit(OJUMP, end);

+		emit(OLABEL, lelse);

+		stmt(lbreak, lcont, lswitch);

+		emit(OLABEL, end);

+	} else {

+		emit(OLABEL, lelse);

+	}

+}

+

+static void

+blockit(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

+{

+	switch (yytoken) {

+	case TYPEIDEN:

+		if (ahead() == ':')

+			goto parse_stmt;

+	case TYPE:

+	case TQUALIFIER:

+	case SCLASS:

+		decl();

+		return;

+	default:

+	parse_stmt:

+		stmt(lbreak, lcont, lswitch);

+	}

+}

+

+void

+compound(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

+{

+	static int nested;

+

+	pushctx();

+	expect('{');

+

+	if (nested == NR_BLOCK)

+		error("too many nesting levels of compound statements");

+

+	++nested;

+	for (;;) {

+		if (yytoken == '}')

+			break;

+		blockit(lbreak, lcont, lswitch);

+	}

+	--nested;

+

+	popctx();

+	expect('}');

+}

+

+static void

+stmt(Symbol *lbreak, Symbol *lcont, Switch *lswitch)

+{

+	void (*fun)(Symbol *, Symbol *, Switch *);

+

+	switch (yytoken) {

+	case '{':      fun = compound; break;

+	case RETURN:   fun = Return;   break;

+	case WHILE:    fun = While;    break;

+	case FOR:      fun = For;      break;

+	case DO:       fun = Dowhile;  break;

+	case IF:       fun = If;       break;

+	case BREAK:    fun = Break;    break;

+	case CONTINUE: fun = Continue; break;

+	case GOTO:     fun = Goto;     break;

+	case SWITCH:   fun = Swtch;    break;

+	case CASE:     fun = Case;     break;

+	case DEFAULT:  fun = Default;  break;

+	default:       fun = stmtexp;  break;

+	}

+	(*fun)(lbreak, lcont, lswitch);

+}

--- /dev/null

+++ b/src/cmd/scc/cc1/symbol.c

@@ -1,0 +1,353 @@

+static char sccsid[] = "@(#) ./cc1/symbol.c";

+#include <assert.h>

+#include <limits.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+

+#include <scc/cstd.h>

+#include <scc/scc.h>

+#include "cc1.h"

+

+#define NR_SYM_HASH 64

+#define NR_CPP_HASH 32

+#define NR_LBL_HASH 16

+

+unsigned curctx;

+static unsigned short counterid;

+

+static Symbol *head, *labels;

+static Symbol *htab[NR_SYM_HASH];

+static Symbol *htabcpp[NR_CPP_HASH];

+static Symbol *htablbl[NR_LBL_HASH];

+

+#ifndef NDEBUG

+void

+dumpstab(Symbol **tbl, char *msg)

+{

+	Symbol **bp, *sym;

+	unsigned size;

+

+	fprintf(stderr, "Symbol Table dump at ctx=%u\n%s\n", curctx, msg);

+	if (tbl == htab)

+		size = NR_SYM_HASH;

+	else if (tbl == htabcpp)

+		size = NR_CPP_HASH;

+	else if (tbl == htablbl)

+		size = NR_LBL_HASH;

+	else

+		abort();

+

+	for (bp = tbl; bp < &tbl[size]; ++bp) {

+		if (*bp == NULL)

+			continue;

+		fprintf(stderr, "%d", (int) (bp - htab));

+		for (sym = *bp; sym; sym = sym->hash)

+			fprintf(stderr, "->[%d,%d:'%s'=%p]",

+			        sym->ns, sym->ctx, sym->name, (void *) sym);

+		putc('\n', stderr);

+	}

+	fputs("head:", stderr);

+	for (sym = head; sym; sym = sym->next) {

+		fprintf(stderr, "->[%d,%d:'%s'=%p]",

+		        sym->ns, sym->ctx,

+		        (sym->name) ? sym->name : "", (void *) sym);

+	}

+	fputs("\nlabels:", stderr);

+	for (sym = labels; sym; sym = sym->next) {

+		fprintf(stderr, "->[%d,%d:'%s'=%p]",

+		        sym->ns, sym->ctx,

+		        (sym->name) ? sym->name : "", (void *) sym);

+	}

+	putc('\n', stderr);

+}

+#endif

+

+static Symbol **

+hash(char *s, int ns)

+{

+	unsigned c, h, size;

+	Symbol **tab;

+

+	for (h = 0; c = *s; ++s)

+		h = h*33 ^ c;

+

+	switch (ns) {

+	case NS_CPP:

+		tab = htabcpp;

+		size = NR_CPP_HASH-1;

+		break;

+	case NS_LABEL:

+		tab = htablbl;

+		size = NR_LBL_HASH-1;

+		break;

+	default:

+		tab = htab;

+		size = NR_SYM_HASH-1;

+		break;

+	}

+	return &tab[h & size];

+}

+

+static void

+unlinkhash(Symbol *sym)

+{

+	Symbol **h;

+

+	if ((sym->flags & SDECLARED) == 0)

+		return;

+	h = hash(sym->name, sym->ns);

+	assert(sym->ns == NS_CPP || *h == sym);

+	while (*h != sym)

+		h = &(*h)->hash;

+	*h = sym->hash;

+}

+

+void

+pushctx(void)

+{

+	DBG("SYM: pushed context %d", curctx+1);

+	if (++curctx == NR_BLOCK+1)

+		error("too many nested blocks");

+}

+

+void

+killsym(Symbol *sym)

+{

+	short f;

+	char *name;

+

+	if (!sym)

+		return;

+	f = sym->flags;

+	if (f & SSTRING)

+		free(sym->u.s);

+	if (sym->ns == NS_TAG)

+		sym->type->prop &= ~TDEFINED;

+	unlinkhash(sym);

+	if ((name = sym->name) != NULL) {

+		switch (sym->ns) {

+		case NS_LABEL:

+			if ((f & SDEFINED) == 0)

+				errorp("label '%s' is not defined", name);

+		case NS_IDEN:

+			if ((f & (SUSED|SGLOBAL|SDECLARED)) == SDECLARED)

+				warn("'%s' defined but not used", name);

+			break;

+		}

+	}

+	free(name);

+	free(sym);

+}

+

+void

+popctx(void)

+{

+	Symbol *next, *sym;

+	int ns, dangling = 0;

+

+	DBG("SYM: poped context %d", curctx);

+	/*

+	 * we have to be careful before popping the current

+	 * context, because since the parser is one token

+	 * ahead it may already have read an identifier at

+	 * this point, and yylval.sym is a pointer to

+	 * the symbol associated to such token. If that

+	 * symbol is from the context that we are popping

+	 * then we are going to generate a dangling pointer.

+	 * We can detect this situation and call again to

+	 * lookup.

+	 */

+	if ((yytoken == IDEN || yytoken == TYPEIDEN) &&

+	    yylval.sym->ctx == curctx) {

+		ns = yylval.sym->ns;

+		dangling = 1;

+	}

+

+	for (sym = head; sym && sym->ctx == curctx; sym = next) {

+		/*

+		 * Since we are unlinking them in the inverse order

+		 * we do know that sym is always the head of the

+		 * collision list

+		 */

+		next = sym->next;

+		killsym(sym);

+	}

+	head = sym;

+

+	if (--curctx == GLOBALCTX) {

+		for (sym = labels; sym; sym = next) {

+			next = sym->next;

+			killsym(sym);

+		}

+		labels = NULL;

+	}

+

+	if (dangling) {

+		yylval.sym = lookup(ns, yytext, ALLOC);

+		yytoken = yylval.sym->token;

+	}

+}

+

+unsigned

+newid(void)

+{

+	unsigned short id;

+

+	if (lexmode == CPPMODE)

+		return 0;

+	id = ++counterid;

+	if (id == 0) {

+		die("cc1: overflow in %s identifiers",

+		    (curctx) ? "internal" : "external");

+	}

+	return id;

+}

+

+Symbol *

+newsym(int ns, char *name)

+{

+	Symbol *sym;

+

+	sym = xmalloc(sizeof(*sym));

+	if (name)

+		name = xstrdup(name);

+	sym->name = name;

+	sym->id = 0;

+	sym->hide = 0;

+	sym->ns = ns;

+	sym->ctx = curctx;

+	sym->token = IDEN;

+	sym->flags = 0;

+	sym->u.s = NULL;

+	sym->type = NULL;

+	sym->hash = NULL;

+

+	if (ns == NS_LABEL) {

+		sym->next = labels;

+		labels = sym;

+	} else if (ns != NS_CPP) {

+		sym->next = head;

+		head = sym;

+	}

+	return sym;

+}

+

+static Symbol *

+linkhash(Symbol *sym)

+{

+	Symbol **h;

+

+	h = hash(sym->name, sym->ns);

+	sym->hash = *h;

+	*h = sym;

+

+	if (sym->ns != NS_CPP)

+		sym->id = newid();

+	sym->flags |= SDECLARED;

+	return sym;

+}

+

+Symbol *

+newstring(char *s, size_t len)

+{

+	Symbol *sym = newsym(NS_IDEN, NULL);

+

+	if (lexmode != CPPMODE)

+		sym->type = mktype(chartype, ARY, len, NULL);

+	sym->id = newid();

+	sym->flags |= SSTRING | SCONSTANT | SPRIVATE;

+	sym->u.s = xmalloc(len);

+	if (s)

+		memcpy(sym->u.s, s, len);

+

+	return sym;

+}

+

+Symbol *

+newlabel(void)

+{

+	Symbol *sym = newsym(NS_LABEL, NULL);

+	sym->id = newid();

+	return sym;

+}

+

+Symbol *

+lookup(int ns, char *name, int alloc)

+{

+	Symbol *sym;

+	int sns, c;

+	char *t;

+

+	c = *name;

+	for (sym = *hash(name, ns); sym; sym = sym->hash) {

+		t = sym->name;

+		if (*t != c || strcmp(t, name))

+			continue;

+		sns = sym->ns;

+		if (sns == ns)

+			return sym;

+		/*

+		 * When a lookup is done in a namespace associated

+		 * to a struct we also want symbols of NS_IDEN which

+		 * are typedef, because in other case we cannot declare

+		 * fields of such types.

+		 * TODO: Remove this trick

+		 */

+		if (sns == NS_KEYWORD ||

+		    (sym->flags & STYPEDEF) && ns >= NS_STRUCTS) {

+			return sym;

+		}

+	}

+	return (alloc == ALLOC) ? newsym(ns, name) : NULL;

+}

+

+Symbol *

+install(int ns, Symbol *sym)

+{

+	if (sym->flags & SDECLARED || sym->ctx != curctx) {

+		if (sym->ctx == curctx && ns == sym->ns)

+			return NULL;

+		sym = newsym(ns, sym->name);

+	}

+	return linkhash(sym);

+}

+

+void

+keywords(struct keyword *key, int ns)

+{

+	Symbol *sym;

+

+	for ( ; key->str; ++key) {

+		sym = linkhash(newsym(ns, key->str));

+		sym->token = key->token;

+		sym->u.token = key->value;

+	}

+	/*

+	 * Remove all the predefined symbols from * the symbol list. It

+	 * will make faster some operations. There is no problem of memory

+	 * leakeage because this memory is not ever freed

+	 */

+	counterid = 0;

+	head = NULL;

+}

+

+void

+builtins(struct builtin *built)

+{

+	Symbol *sym;

+	struct builtin *bp;

+

+	for (bp = built; bp->str; ++bp) {

+		sym = linkhash(newsym(NS_KEYWORD, bp->str));

+		sym->token = BUILTIN;

+		sym->u.fun = bp->fun;

+	}

+	/*

+	 * Remove all the predefined symbols from * the symbol list. It

+	 * will make faster some operations. There is no problem of memory

+	 * leakeage because this memory is not ever freed

+	 */

+	counterid = 0;

+	head = NULL;

+}

--- /dev/null

+++ b/src/cmd/scc/cc1/target/amd64-sysv/arch.c

@@ -1,0 +1,220 @@

+static char sccsid[] = "@(#) ./cc1/arch/amd64-sysv/arch.c";

+

+#include <scc/scc.h>

+#include "../../cc1.h"

+

+#define RANK_BOOL    0

+#define RANK_SCHAR   1

+#define RANK_UCHAR   1

+#define RANK_CHAR    1

+#define RANK_SHORT   2

+#define RANK_USHORT  2

+#define RANK_INT     3

+#define RANK_UINT    3

+#define RANK_LONG    4

+#define RANK_ULONG   4

+#define RANK_LLONG   5

+#define RANK_ULLONG  5

+#define RANK_FLOAT   6

+#define RANK_DOUBLE  7

+#define RANK_LDOUBLE 8

+

+/*

+ * Initializaion of type pointers were done with

+ * a C99 initilizator '... = &(Type) {...', but

+ * c compiler in Plan9 gives error with this

+ * syntax, so I have switched it to this ugly form

+ * I hope I will change it again in the future

+ */

+

+static Type types[] = {

+	{       /* 0 = voidtype */

+		.op = VOID,

+		.letter = L_VOID,

+	},

+	{       /* 1 = pvoidtype */

+		.op = PTR,

+		.letter = L_POINTER,

+		.prop = TDEFINED,

+		.type = &types[5],  /* chartype */

+		.size = 8,

+		.align = 8,

+	},

+	{      /* 2 = booltype */

+		.op = INT,

+		.letter = L_BOOL,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 1,

+		.align = 1,

+		.n.rank = RANK_BOOL,

+	},

+	{       /* 3 = schartype */

+		.op = INT,

+		.letter = L_INT8,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 1,

+		.align = 1,

+		.n.rank = RANK_SCHAR,

+	},

+	{      /* 4 = uchartype */

+		.op = INT,

+		.letter = L_UINT8,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 1,

+		.align = 1,

+		.n.rank = RANK_UCHAR,

+	},

+	{      /* 5 = chartype */

+		.op = INT,

+		.letter = L_INT8,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 1,

+		.align = 1,

+		.n.rank = RANK_CHAR,

+	},

+	{       /* 6 = ushortype */

+		.op = INT,

+		.letter = L_UINT16,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 2,

+		.align = 2,

+		.n.rank = RANK_USHORT,

+	},

+	{       /* 7 = shortype */

+		.op = INT,

+		.letter = L_INT16,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 2,

+		.align = 2,

+		.n.rank = RANK_SHORT,

+	},

+	{       /* 8 = uinttype */

+		.op = INT,

+		.letter = L_UINT32,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 4,

+		.align = 4,

+		.n.rank = RANK_UINT,

+	},

+	{       /* 9 = inttype */

+		.op = INT,

+		.letter = L_INT32,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 4,

+		.align = 4,

+		.n.rank = RANK_INT,

+	},

+	{      /* 10 = longtype */

+		.op = INT,

+		.letter = L_INT64,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 8,

+		.align = 8,

+		.n.rank = RANK_LONG,

+	},

+	{       /* 11 = ulongtype */

+		.op = INT,

+		.letter = L_UINT64,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 8,

+		.align = 8,

+		.n.rank = RANK_ULONG,

+	},

+	{	/* 12 = ullongtype */

+		.op = INT,

+		.letter = L_UINT64,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 8,

+		.align = 8,

+		.n.rank = RANK_ULLONG,

+	},

+	{       /* 13 = llongtype */

+		.op = INT,

+		.letter = L_INT64,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 8,

+		.align = 8,

+		.n.rank = RANK_LLONG,

+	},

+	{       /* 14 = floattype */

+		.op = FLOAT,

+		.letter = L_FLOAT,

+		.prop = TDEFINED | TARITH,

+		.size = 4,

+		.align = 4,

+		.n.rank = RANK_FLOAT,

+	},

+	{       /* 15 = doubletype */

+		.op = FLOAT,

+		.letter = L_DOUBLE,

+		.prop = TDEFINED | TARITH,

+		.size = 8,

+		.align = 8,

+		.n.rank = RANK_DOUBLE,

+	},

+	{       /* 16 = ldoubletype */

+		.op = FLOAT,

+		.letter = L_LDOUBLE,

+		.prop = TDEFINED | TARITH,

+		.size = 16,

+		.align = 16,

+		.n.rank = RANK_LDOUBLE,

+	},

+	{       /* 17 = sizettype */

+		.op = INT,

+		.letter = L_UINT64,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 8,

+		.align = 8,

+		.n.rank = RANK_UINT,

+	},

+	{      /* 18 = ellipsis */

+		.op = ELLIPSIS,

+		.letter = L_ELLIPSIS,

+		.prop = TDEFINED,

+	},

+	{      /* 19 = pdifftype */

+		.op = INT,

+		.letter = L_INT64,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 8,

+		.align = 8,

+		.n.rank = RANK_LONG,

+	},

+	{      /* 20 = va_type */

+		.op = STRUCT,

+		.letter = L_VA_ARG,

+		.prop = TDEFINED,

+		.size = 24,

+		.align = 8,

+	},

+};

+

+Type *voidtype = &types[0], *pvoidtype = &types[1],

+     *booltype = &types[2], *schartype = &types[3],

+     *uchartype = &types[4], *chartype = &types[5],

+     *ushortype = &types[6], *shortype = &types[7],

+     *uinttype = &types[8], *inttype = &types[9],

+     *longtype = &types[10], *ulongtype = &types[11],

+     *ullongtype = &types[12], *llongtype = &types[13],

+     *floattype = &types[14], *doubletype = &types[15],

+     *ldoubletype = &types[16],

+     *sizettype = &types[17], *pdifftype = &types[19],

+     *ellipsistype = &types[18], *va_type = &types[20],

+     *va_list_type;

+

+static Symbol dummy0 = {.u.i = 0, .type = &types[9]},

+              dummy1 = {.u.i = 1, .type = &types[9]};

+Symbol *zero = &dummy0, *one = &dummy1;

+

+void

+iarch(void)

+{

+	va_list_type = mktype(va_type, ARY, 1, NULL);

+}

+

+int

+valid_va_list(Type *tp)

+{

+	return tp->op == PTR && eqtype(tp->type, va_type, 1);

+}

--- /dev/null

+++ b/src/cmd/scc/cc1/target/amd64-sysv/arch.mk

@@ -1,0 +1,4 @@

+OBJ-amd64-sysv= $(OBJS)  target/amd64-sysv/arch.o

+

+$(LIBEXEC)/cc1-amd64-sysv: $(OBJ-amd64-sysv)

+	$(CC) $(SCC_LDFLAGS) $(OBJ-amd64-sysv) -lscc -o $@

--- /dev/null

+++ b/src/cmd/scc/cc1/target/arm64-sysv/arch.c

@@ -1,0 +1,220 @@

+static char sccsid[] = "@(#) ./cc1/arch/arm64-sysv/arch.c";

+

+#include <scc/scc.h>

+#include "../../cc1.h"

+

+#define RANK_BOOL    0

+#define RANK_SCHAR   1

+#define RANK_UCHAR   1

+#define RANK_CHAR    1

+#define RANK_SHORT   2

+#define RANK_USHORT  2

+#define RANK_INT     3

+#define RANK_UINT    3

+#define RANK_LONG    4

+#define RANK_ULONG   4

+#define RANK_LLONG   5

+#define RANK_ULLONG  5

+#define RANK_FLOAT   6

+#define RANK_DOUBLE  7

+#define RANK_LDOUBLE 8

+

+/*

+ * Initializaion of type pointers were done with

+ * a C99 initilizator '... = &(Type) {...', but

+ * c compiler in Plan9 gives error with this

+ * syntax, so I have switched it to this ugly form

+ * I hope I will change it again in the future

+ */

+

+static Type types[] = {

+	{       /* 0 = voidtype */

+		.op = VOID,

+		.letter = L_VOID,

+	},

+	{       /* 1 = pvoidtype */

+		.op = PTR,

+		.letter = L_POINTER,

+		.prop = TDEFINED,

+		.type = &types[5],  /* chartype */

+		.size = 8,

+		.align = 8,

+	},

+	{      /* 2 = booltype */

+		.op = INT,

+		.letter = L_BOOL,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 1,

+		.align = 1,

+		.n.rank = RANK_BOOL,

+	},

+	{       /* 3 = schartype */

+		.op = INT,

+		.letter = L_INT8,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 1,

+		.align = 1,

+		.n.rank = RANK_SCHAR,

+	},

+	{      /* 4 = uchartype */

+		.op = INT,

+		.letter = L_UINT8,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 1,

+		.align = 1,

+		.n.rank = RANK_UCHAR,

+	},

+	{      /* 5 = chartype */

+		.op = INT,

+		.letter = L_INT8,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 1,

+		.align = 1,

+		.n.rank = RANK_CHAR,

+	},

+	{       /* 6 = ushortype */

+		.op = INT,

+		.letter = L_UINT16,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 2,

+		.align = 2,

+		.n.rank = RANK_USHORT,

+	},

+	{       /* 7 = shortype */

+		.op = INT,

+		.letter = L_INT16,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 2,

+		.align = 2,

+		.n.rank = RANK_SHORT,

+	},

+	{       /* 8 = uinttype */

+		.op = INT,

+		.letter = L_UINT32,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 4,

+		.align = 4,

+		.n.rank = RANK_UINT,

+	},

+	{       /* 9 = inttype */

+		.op = INT,

+		.letter = L_INT32,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 4,

+		.align = 4,

+		.n.rank = RANK_INT,

+	},

+	{      /* 10 = longtype */

+		.op = INT,

+		.letter = L_INT64,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 8,

+		.align = 8,

+		.n.rank = RANK_LONG,

+	},

+	{       /* 11 = ulongtype */

+		.op = INT,

+		.letter = L_UINT64,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 8,

+		.align = 8,

+		.n.rank = RANK_ULONG,

+	},

+	{	/* 12 = ullongtype */

+		.op = INT,

+		.letter = L_UINT64,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 8,

+		.align = 8,

+		.n.rank = RANK_ULLONG,

+	},

+	{       /* 13 = llongtype */

+		.op = INT,

+		.letter = L_INT64,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 8,

+		.align = 8,

+		.n.rank = RANK_LLONG,

+	},

+	{       /* 14 = floattype */

+		.op = FLOAT,

+		.letter = L_FLOAT,

+		.prop = TDEFINED | TARITH,

+		.size = 4,

+		.align = 4,

+		.n.rank = RANK_FLOAT,

+	},

+	{       /* 15 = doubletype */

+		.op = FLOAT,

+		.letter = L_DOUBLE,

+		.prop = TDEFINED | TARITH,

+		.size = 8,

+		.align = 8,

+		.n.rank = RANK_DOUBLE,

+	},

+	{       /* 16 = ldoubletype */

+		.op = FLOAT,

+		.letter = L_LDOUBLE,

+		.prop = TDEFINED | TARITH,

+		.size = 16,

+		.align = 16,

+		.n.rank = RANK_LDOUBLE,

+	},

+	{       /* 17 = sizettype */

+		.op = INT,

+		.letter = L_UINT64,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 8,

+		.align = 8,

+		.n.rank = RANK_UINT,

+	},

+	{      /* 18 = ellipsis */

+		.op = ELLIPSIS,

+		.letter = L_ELLIPSIS,

+		.prop = TDEFINED,

+	},

+	{      /* 19 = pdifftype */

+		.op = INT,

+		.letter = L_INT64,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 8,

+		.align = 8,

+		.n.rank = RANK_LONG,

+	},

+	{      /* 20 = va_type */

+		.op = STRUCT,

+		.letter = L_VA_ARG,

+		.prop = TDEFINED,

+		.size = 24,

+		.align = 8,

+	},

+};

+

+Type *voidtype = &types[0], *pvoidtype = &types[1],

+     *booltype = &types[2], *schartype = &types[3],

+     *uchartype = &types[4], *chartype = &types[5],

+     *ushortype = &types[6], *shortype = &types[7],

+     *uinttype = &types[8], *inttype = &types[9],

+     *longtype = &types[10], *ulongtype = &types[11],

+     *ullongtype = &types[12], *llongtype = &types[13],

+     *floattype = &types[14], *doubletype = &types[15],

+     *ldoubletype = &types[16],

+     *sizettype = &types[17], *pdifftype = &types[19],

+     *ellipsistype = &types[18], *va_type = &types[20],

+     *va_list_type;

+

+static Symbol dummy0 = {.u.i = 0, .type = &types[9]},

+              dummy1 = {.u.i = 1, .type = &types[9]};

+Symbol *zero = &dummy0, *one = &dummy1;

+

+void

+iarch(void)

+{

+	va_list_type = mktype(va_type, ARY, 1, NULL);

+}

+

+int

+valid_va_list(Type *tp)

+{

+	return tp->op == PTR && eqtype(tp->type, va_type, 1);

+}

--- /dev/null

+++ b/src/cmd/scc/cc1/target/arm64-sysv/arch.mk

@@ -1,0 +1,4 @@

+OBJ-arm64-sysv= $(OBJS)  target/arm64-sysv/arch.o

+

+$(LIBEXEC)/cc1-arm64-sysv: $(OBJ-arm64-sysv)

+	$(CC) $(SCC_LDFLAGS) $(OBJ-arm64-sysv) -lscc -o $@

--- /dev/null

+++ b/src/cmd/scc/cc1/target/i386-sysv/arch.c

@@ -1,0 +1,221 @@

+static char sccsid[] = "@(#) ./cc1/arch/i386-sysv/arch.c";

+

+#include <scc/scc.h>

+#include "../../cc1.h"

+

+#define RANK_BOOL    0

+#define RANK_SCHAR   1

+#define RANK_UCHAR   1

+#define RANK_CHAR    1

+#define RANK_SHORT   2

+#define RANK_USHORT  2

+#define RANK_INT     3

+#define RANK_UINT    3

+#define RANK_LONG    4

+#define RANK_ULONG   4

+#define RANK_LLONG   5

+#define RANK_ULLONG  5

+#define RANK_FLOAT   6

+#define RANK_DOUBLE  7

+#define RANK_LDOUBLE 8

+

+/*

+ * Initializaion of type pointers were done with

+ * a C99 initilizator '... = &(Type) {...', but

+ * c compiler in Plan9 gives error with this

+ * syntax, so I have switched it to this ugly form

+ * I hope I will change it again in the future

+ */

+

+static Type types[] = {

+	{       /* 0 = voidtype */

+		.op = VOID,

+		.letter = L_VOID,

+	},

+	{       /* 1 = pvoidtype */

+		.op = PTR,

+		.letter = L_POINTER,

+		.prop = TDEFINED,

+		.type = &types[5],  /* chartype */

+		.size = 4,

+		.align = 4,

+	},

+	{      /* 2 = booltype */

+		.op = INT,

+		.letter = L_BOOL,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 1,

+		.align = 1,

+		.n.rank = RANK_BOOL,

+	},

+	{       /* 3 = schartype */

+		.op = INT,

+		.letter = L_INT8,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 1,

+		.align = 1,

+		.n.rank = RANK_SCHAR,

+	},

+	{      /* 4 = uchartype */

+		.op = INT,

+		.letter = L_UINT8,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 1,

+		.align = 1,

+		.n.rank = RANK_UCHAR,

+	},

+	{      /* 5 = chartype */

+		.op = INT,

+		.letter = L_INT8,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 1,

+		.align = 1,

+		.n.rank = RANK_CHAR,

+	},

+	{       /* 6 = ushortype */

+		.op = INT,

+		.letter = L_UINT16,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 2,

+		.align = 2,

+		.n.rank = RANK_USHORT,

+	},

+	{       /* 7 = shortype */

+		.op = INT,

+		.letter = L_INT16,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 2,

+		.align = 2,

+		.n.rank = RANK_SHORT,

+	},

+	{       /* 8 = uinttype */

+		.op = INT,

+		.letter = L_UINT32,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 4,

+		.align = 4,

+		.n.rank = RANK_UINT,

+	},

+	{       /* 9 = inttype */

+		.op = INT,

+		.letter = L_INT32,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 4,

+		.align = 4,

+		.n.rank = RANK_INT,

+	},

+	{      /* 10 = longtype */

+		.op = INT,

+		.letter = L_INT32,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 4,

+		.align = 4,

+		.n.rank = RANK_LONG,

+	},

+	{       /* 11 = ulongtype */

+		.op = INT,

+		.letter = L_UINT32,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 4,

+		.align = 4,

+		.n.rank = RANK_ULONG,

+	},

+	{	/* 12 = ullongtype */

+		.op = INT,

+		.letter = L_UINT64,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 8,

+		.align = 4,

+		.n.rank = RANK_ULLONG,

+	},

+	{       /* 13 = llongtype */

+		.op = INT,

+		.letter = L_INT64,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 8,

+		.align = 4,

+		.n.rank = RANK_LLONG,

+	},

+	{       /* 14 = floattype */

+		.op = FLOAT,

+		.letter = L_FLOAT,

+		.prop = TDEFINED | TARITH,

+		.size = 4,

+		.align = 4,

+		.n.rank = RANK_FLOAT,

+	},

+	{       /* 15 = doubletype */

+		.op = FLOAT,

+		.letter = L_DOUBLE,

+		.prop = TDEFINED | TARITH,

+		.size = 8,

+		.align = 4,

+		.n.rank = RANK_DOUBLE,

+	},

+	{       /* 16 = ldoubletype */

+		.op = FLOAT,

+		.letter = L_LDOUBLE,

+		.prop = TDEFINED | TARITH,

+		.size = 12,

+		.align = 4,

+		.n.rank = RANK_LDOUBLE,

+	},

+	{       /* 17 = sizettype */

+		.op = INT,

+		.letter = L_UINT32,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 4,

+		.align = 4,

+		.n.rank = RANK_UINT,

+	},

+	{      /* 18 = ellipsis */

+		.op = ELLIPSIS,

+		.letter = L_ELLIPSIS,

+		.prop = TDEFINED,

+	},

+	{       /* 19 = pdifftype */

+		.op = INT,

+		.letter = L_INT32,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 4,

+		.align = 4,

+		.n.rank = RANK_INT,

+	},

+	{      /* 20 = va_list_type */

+		.op = PTR,

+		.letter = L_POINTER,

+		.prop = TDEFINED,

+		.size = 4,

+		.align = 4,

+	},

+};

+

+

+Type *voidtype = &types[0], *pvoidtype = &types[1],

+     *booltype = &types[2], *schartype = &types[3],

+     *uchartype = &types[4], *chartype = &types[5],

+     *ushortype = &types[6], *shortype = &types[7],

+     *uinttype = &types[8], *inttype = &types[9],

+     *longtype = &types[10], *ulongtype = &types[11],

+     *ullongtype = &types[12], *llongtype = &types[13],

+     *floattype = &types[14], *doubletype = &types[15],

+     *ldoubletype = &types[16],

+     *sizettype = &types[17], *pdifftype = &types[19],

+     *ellipsistype = &types[18], *va_list_type = &types[20];

+

+

+

+static Symbol dummy0 = {.u.i = 0, .type = &types[9]},

+              dummy1 = {.u.i = 1, .type = &types[9]};

+Symbol *zero = &dummy0, *one = &dummy1;

+

+void

+iarch(void)

+{

+}

+

+int

+valid_va_list(Type *tp)

+{

+	return eqtype(tp, va_list_type, 1);

+}

--- /dev/null

+++ b/src/cmd/scc/cc1/target/i386-sysv/arch.mk

@@ -1,0 +1,4 @@

+OBJ-i386-sysv= $(OBJS)  target/i386-sysv/arch.o

+

+$(LIBEXEC)/cc1-i386-sysv: $(OBJ-i386-sysv)

+	$(CC) $(SCC_LDFLAGS) $(OBJ-i386-sysv) -lscc -o $@

--- /dev/null

+++ b/src/cmd/scc/cc1/target/z80-scc/arch.c

@@ -1,0 +1,219 @@

+static char sccsid[] = "@(#) ./cc1/arch/z80/arch.c";

+

+#include <scc/scc.h>

+#include "../../cc1.h"

+

+#define RANK_BOOL    0

+#define RANK_SCHAR   1

+#define RANK_UCHAR   1

+#define RANK_CHAR    1

+#define RANK_SHORT   2

+#define RANK_USHORT  2

+#define RANK_INT     3

+#define RANK_UINT    3

+#define RANK_LONG    4

+#define RANK_ULONG   4

+#define RANK_LLONG   5

+#define RANK_ULLONG  5

+#define RANK_FLOAT   6

+#define RANK_DOUBLE  7

+#define RANK_LDOUBLE 8

+

+/*

+ * Initializaion of type pointers were done with

+ * a C99 initilizator '... = &(Type) {...', but

+ * c compiler in Plan9 gives error with this

+ * syntax, so I have switched it to this ugly form

+ * I hope I will change it again in the future

+ */

+

+static Type types[] = {

+	{       /* 0 = voidtype */

+		.op = VOID,

+		.letter = L_VOID,

+	},

+	{       /* 1 = pvoidtype */

+		.op = PTR,

+		.letter = L_POINTER,

+		.prop = TDEFINED,

+		.type = &types[5], /* char type */

+		.size = 2,

+		.align = 2,

+	},

+	{      /* 2 = booltype */

+		.op = INT,

+		.letter = L_BOOL,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 1,

+		.align = 1,

+		.n.rank = RANK_BOOL,

+	},

+	{       /* 3 = schartype */

+		.op = INT,

+		.letter = L_INT8,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 1,

+		.align = 1,

+		.n.rank = RANK_SCHAR,

+	},

+	{      /* 4 = uchartype */

+		.op = INT,

+		.letter = L_UINT8,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 1,

+		.align = 1,

+		.n.rank = RANK_UCHAR,

+	},

+	{      /* 5 = chartype */

+		.op = INT,

+		.letter = L_UINT8,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 1,

+		.align = 1,

+		.n.rank = RANK_CHAR,

+	},

+	{       /* 6 = ushortype */

+		.op = INT,

+		.letter = L_UINT16,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 2,

+		.align = 1,

+		.n.rank = RANK_USHORT,

+	},

+	{       /* 7 = shortype */

+		.op = INT,

+		.letter = L_INT16,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 2,

+		.align = 1,

+		.n.rank = RANK_SHORT,

+	},

+	{       /* 8 = uinttype */

+		.op = INT,

+		.letter = L_UINT16,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 2,

+		.align = 1,

+		.n.rank = RANK_UINT,

+	},

+	{       /* 9 = inttype */

+		.op = INT,

+		.letter = L_INT16,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 2,

+		.align = 1,

+		.n.rank = RANK_INT,

+	},

+	{      /* 10 = longtype */

+		.op = INT,

+		.letter = L_INT32,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 4,

+		.align = 1,

+		.n.rank = RANK_LONG,

+	},

+	{       /* 11 = ulongtype */

+		.op = INT,

+		.letter = L_UINT32,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 4,

+		.align = 1,

+		.n.rank = RANK_ULONG,

+	},

+	{	/* 12 = ullongtype */

+		.op = INT,

+		.letter = L_UINT64,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 8,

+		.align = 1,

+		.n.rank = RANK_ULLONG,

+	},

+	{       /* 13 = llongtype */

+		.op = INT,

+		.letter = L_INT64,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 8,

+		.align = 1,

+		.n.rank = RANK_LLONG,

+	},

+	{       /* 14 = floattype */

+		.op = FLOAT,

+		.letter = L_FLOAT,

+		.prop = TDEFINED | TARITH,

+		.size = 4,

+		.align = 1,

+		.n.rank = RANK_FLOAT,

+	},

+	{       /* 15 = doubletype */

+		.op = FLOAT,

+		.letter = L_DOUBLE,

+		.prop = TDEFINED | TARITH,

+		.size = 8,

+		.align = 1,

+		.n.rank = RANK_DOUBLE,

+	},

+	{       /* 16 = ldoubletype */

+		.op = FLOAT,

+		.letter = L_LDOUBLE,

+		.prop = TDEFINED | TARITH,

+		.size = 16,

+		.align = 1,

+		.n.rank = RANK_LDOUBLE,

+	},

+	{       /* 17 = sizettype */

+		.op = INT,

+		.letter = L_UINT16,

+		.prop = TDEFINED | TINTEGER | TARITH,

+		.size = 2,

+		.align = 1,

+		.n.rank = RANK_UINT,

+	},

+	{      /* 18 = ellipsis */

+		.op = ELLIPSIS,

+		.letter = L_ELLIPSIS,

+		.prop = TDEFINED,

+	},

+	{       /* 7 = pdifftype */

+		.op = INT,

+		.letter = L_INT16,

+		.prop = TDEFINED | TINTEGER | TARITH | TSIGNED,

+		.size = 2,

+		.align = 1,

+		.n.rank = RANK_SHORT,

+	},

+	{       /* 20 = va_list_type */

+		.op = PTR,

+		.letter = L_POINTER,

+		.prop = TDEFINED,

+		.size = 2,

+		.align = 1,

+	}

+};

+

+Type *voidtype = &types[0], *pvoidtype = &types[1],

+     *booltype = &types[2], *schartype = &types[3],

+     *uchartype = &types[4], *chartype = &types[5],

+     *ushortype = &types[6], *shortype = &types[7],

+     *uinttype = &types[8], *inttype = &types[9],

+     *longtype = &types[10], *ulongtype = &types[11],

+     *ullongtype = &types[12], *llongtype = &types[13],

+     *floattype = &types[14], *doubletype = &types[15],

+     *ldoubletype = &types[16],

+     *sizettype = &types[17], *pdifftype = &types[19],

+     *ellipsistype = &types[18], *va_list_type = &types[20];

+

+

+static Symbol dummy0 = {.u.i = 0, .type = &types[9]},

+              dummy1 = {.u.i = 1, .type = &types[9]};

+Symbol *zero = &dummy0, *one = &dummy1;

+

+void

+iarch(void)

+{

+}

+

+int

+valid_va_list(Type *tp)

+{

+	return eqtype(tp, va_list_type, 1);

+}

--- /dev/null

+++ b/src/cmd/scc/cc1/target/z80-scc/arch.mk

@@ -1,0 +1,4 @@

+OBJ-z80-scc= $(OBJS) target/z80-scc/arch.o

+

+$(LIBEXEC)/cc1-z80-scc: $(OBJ-z80-scc)

+	$(CC) $(SCC_LDFLAGS) $(OBJ-z80-scc) -lscc -o $@

--- /dev/null

+++ b/src/cmd/scc/cc1/types.c

@@ -1,0 +1,438 @@

+static char sccsid[] = "@(#) ./cc1/types.c";

+#include <assert.h>

+#include <inttypes.h>

+#include <stdlib.h>

+#include <string.h>

+

+#include <scc/cstd.h>

+#include <scc/scc.h>

+#include "cc1.h"

+

+#define NR_TYPE_HASH 16

+#define HASH(t) (((t)->op ^ (uintptr_t) (t)->type>>3) & NR_TYPE_HASH-1)

+

+static Type *typetab[NR_TYPE_HASH], *localtypes;

+

+/* FIXME:

+ * Compiler can generate warnings here if the ranges of TINT,

+ * TUINT and TFLOAT are smaller than any of the constants in this

+ * array. Ignore them if you know that the target types are correct

+ */

+static struct limits limits[][4] = {

+	{

+		{	/* 0 = unsigned 1 byte */

+			.min.i = 0,

+			.max.i = 0xff

+		},

+		{	/* 1 = unsigned 2 bytes */

+			.min.i = 0,

+			.max.i = 0xffff

+		},

+		{	/* 2 = unsigned 4 bytes */

+			.min.i = 0,

+			.max.i = 0xffffffff

+		},

+		{	/* 3 = unsigned 8 bytes */

+			.min.i = 0,

+			.max.i = 0xffffffffffffffff

+		}

+	},

+	{

+		{	/* 0 = signed 1 byte */

+			.min.i = -0x7f-1,

+			.max.i = 0x7f

+		},

+		{	/* 1 = signed 2 byte */

+			.min.i = -0x7fff-1,

+			.max.i = 0x7fff

+		},

+		{	/* 2 = signed 4 byte */

+			.min.i = -0x7fffffff-1,

+			.max.i = 0x7fffffff

+		},

+		{	/* 3 = signed 8 byte */

+			.min.i = -0x7fffffffffffffff-1,

+			.max.i = 0x7fffffffffffffff,

+		}

+	},

+	{

+		{

+			/* 0 = float 4 bytes */

+			.min.f = -1,

+			.max.f = 2

+		},

+		{

+			/* 1 = float 8 bytes */

+			.min.f = -1,

+			.max.f = 2,

+		},

+		{

+			/* 2 = float 16 bytes */

+			.min.f = -1,

+			.max.f = 2,

+		}

+	}

+};

+

+struct limits *

+getlimits(Type *tp)

+{

+	int ntable, ntype;

+

+	switch (tp->op) {

+	case ENUM:

+	case INT:

+		ntable = ((tp->prop & TSIGNED) != 0);

+		switch (tp->size) {

+		case 1: ntype = 0; break;

+		case 2: ntype = 1; break;

+		case 4: ntype = 2; break;

+		case 8: ntype = 3; break;

+		}

+		break;

+	case FLOAT:

+		ntable = 2;

+		switch (tp->size) {

+		case 4:  ntype = 0; break;

+		case 8:  ntype = 1; break;

+		case 16: ntype = 2; break;

+		}

+		break;

+	default:

+		abort();

+	}

+

+	return &limits[ntable][ntype];

+}

+

+Type *

+ctype(int type, int sign, int size)

+{

+	switch (type) {

+	case CHAR:

+		if (size)

+			goto invalid_type;

+		switch (sign) {

+		case 0:

+			return chartype;

+		case SIGNED:

+			return schartype;

+		case UNSIGNED:

+			return uchartype;

+		}

+		break;

+	case VA_LIST:

+		if (size || sign)

+			goto invalid_type;

+		return va_list_type;

+	case VOID:

+		if (size || sign)

+			goto invalid_type;

+		return voidtype;

+	case BOOL:

+		if (size || sign)

+			goto invalid_type;

+		return booltype;

+	case 0:

+	case INT:

+		switch (size) {

+		case 0:

+			return (sign == UNSIGNED) ? uinttype   : inttype;

+		case SHORT:

+			return (sign == UNSIGNED) ? ushortype  : shortype;

+		case LONG:

+			return (sign == UNSIGNED) ? ulongtype  : longtype;

+		case LLONG:

+			return (sign == UNSIGNED) ? ullongtype : llongtype;

+		}

+		break;

+	case DOUBLE:

+		if (size == LLONG)

+			goto invalid_type;

+		if (size == LONG)

+			size = LLONG;

+		else

+			size = LONG;

+		goto floating;

+	case FLOAT:

+		if (size == LLONG)

+			goto invalid_type;

+	floating:

+		if (sign)

+			goto invalid_type;

+		switch (size) {

+		case 0:

+			return floattype;

+		case LONG:

+			return doubletype;

+		case LLONG:

+			return ldoubletype;

+		}

+		break;

+	}

+

+invalid_type:

+	error("invalid type specification");

+}

+

+void

+typesize(Type *tp)

+{

+	Symbol **sp;

+	Type *type;

+	unsigned long size, offset;

+	int align, a;

+	TINT n;

+

+	switch (tp->op) {

+	case ARY:

+		/* FIXME: Control overflow */

+		tp->size = tp->n.elem * tp->type->size;

+		tp->align = tp->type->align;

+		return;

+	case PTR:

+		tp->size = pvoidtype->size;

+		tp->align = pvoidtype->align;

+		return;

+	case STRUCT:

+	case UNION:

+		/* FIXME: Control overflow */

+		/*

+		 * The alignment of the struct/union is

+		 * he alignment of the largest included type.

+		 * The size of an union is the size of the largest

+		 * field, and the size of a struct is the sum

+		 * of the size of every field plus padding bits.

+		 */

+		offset = align = size = 0;

+		n = tp->n.elem;

+		for (sp = tp->p.fields; n--; ++sp) {

+			(*sp)->u.i = offset;

+			type = (*sp)->type;

+			a = type->align;

+			if (a > align)

+				align = a;

+			if (tp->op == STRUCT) {

+				if (--a != 0)

+					size = (size + a) & ~a;

+				size += type->size;

+				offset = size;

+			} else {

+				if (type->size > size)

+					size = type->size;

+			}

+		}

+

+		tp->align = align;

+		/*

+		 * We have to add the padding bits to

+		 * ensure next struct in an array is well

+		 * alignment.

+		 */

+		if (tp->op == STRUCT && align-- > 1)

+			size += size+align & ~align;

+		tp->size = size;

+		return;

+	case ENUM:

+		tp->size = inttype->size;

+		tp->align = inttype->align;

+		return;

+	case FTN:

+		return;

+	default:

+		abort();

+	}

+}

+

+Type *

+deftype(Type *tp)

+{

+	tp->prop |= TDEFINED;

+	typesize(tp);

+	emit(OTYP, tp);

+	return tp;

+}

+

+static Type *

+newtype(Type *base)

+{

+	Type *tp;

+	size_t siz;

+

+	tp = xmalloc(sizeof(*tp));

+	*tp = *base;

+	tp->id = newid();

+

+	if (tp->op == FTN) {

+		siz = tp->n.elem * sizeof(Type *);

+		tp->p.pars = memcpy(xmalloc(siz), tp->p.pars, siz);

+	}

+

+	if (curfun) {

+		/* it is a type defined in the body of a function */

+		tp->next = localtypes;

+		localtypes = tp;

+	}

+	if (tp->prop & TDEFINED)

+		deftype(tp);

+	return tp;

+}

+

+Type *

+mktype(Type *tp, int op, TINT nelem, Type *pars[])

+{

+	Type **tbl, type;

+	Type *bp;

+

+	if (op == PTR && tp == voidtype)

+		return pvoidtype;

+

+	memset(&type, 0, sizeof(type));

+	type.type = tp;

+	type.op = op;

+	type.p.pars = pars;

+	type.n.elem = nelem;

+

+	switch (op) {

+	case ARY:

+		if (tp == voidtype) {

+			errorp("declaration of array of voids type");

+			tp = inttype;

+		}

+		type.letter = L_ARRAY;

+		if (nelem != 0)

+			type.prop |= TDEFINED;

+		break;

+	case KRFTN:

+		type.prop |= TDEFINED | TK_R;

+		type.op = FTN;

+		type.letter = L_FUNCTION;

+		break;

+	case FTN:

+		if (nelem > 0 && pars[nelem-1] == ellipsistype)

+			type.prop |= TELLIPSIS;

+		type.letter = L_FUNCTION;

+		type.prop |= TDEFINED;

+		break;

+	case PTR:

+	        type.letter = L_POINTER;

+		type.prop |= TDEFINED;

+		break;

+	case ENUM:

+		type.letter = inttype->letter;

+		type.prop |= TINTEGER | TARITH;

+		type.n.rank = inttype->n.rank;

+		goto create_type;

+	case STRUCT:

+		type.letter = L_STRUCT;

+		type.prop |= TAGGREG;

+		goto create_type;

+	case UNION:

+		type.letter = L_UNION;

+		type.prop |= TAGGREG;

+	create_type:

+		return newtype(&type);

+	default:

+		abort();

+	}

+

+	tbl = &typetab[HASH(&type)];

+	for (bp = *tbl; bp; bp = bp->h_next) {

+		if (eqtype(bp, &type, 0))

+			return bp;

+	}

+

+	bp = newtype(&type);

+	bp->h_next = *tbl;

+	*tbl = bp;

+

+	return bp;

+}

+

+int

+eqtype(Type *tp1, Type *tp2, int equiv)

+{

+	TINT n;

+	Type **p1, **p2;

+	Symbol **s1, **s2;

+

+	if (tp1 == tp2)

+		return 1;

+	if (!tp1 || !tp2)

+		return 0;

+	if (tp1->op != tp2->op)

+		return 0;

+

+	switch (tp1->op) {

+	case UNION:

+	case STRUCT:

+		if (tp1->letter != tp2->letter)

+			return 0;

+		if (tp1->tag->name || tp2->tag->name)

+			return tp1->tag == tp2->tag;

+		if (tp1->n.elem != tp2->n.elem)

+			return 0;

+		s1 = tp1->p.fields, s2 = tp2->p.fields;

+		for (n = tp1->n.elem; n > 0; --n, ++s1, ++s2) {

+			if (strcmp((*s1)->name, (*s2)->name))

+				return 0;

+			if (!eqtype((*s1)->type, (*s2)->type, equiv))

+				return 0;

+		}

+		return 1;

+	case FTN:

+		if (tp1->n.elem != tp2->n.elem)

+			return 0;

+		p1 = tp1->p.pars, p2 = tp2->p.pars;

+		for (n = tp1->n.elem; n > 0; --n) {

+			if (!eqtype(*p1++, *p2++, equiv))

+				return 0;

+		}

+		goto check_base;

+	case ARY:

+		if (equiv && (tp1->n.elem == 0 || tp2->n.elem == 0))

+			goto check_base;

+		if (tp1->n.elem != tp2->n.elem)

+			return 0;

+	case PTR:

+	check_base:

+		return eqtype(tp1->type, tp2->type, equiv);

+	case VOID:

+	case ENUM:

+		return 0;

+	case INT:

+	case FLOAT:

+		return tp1->letter == tp2->letter;

+	default:

+		abort();

+	}

+}

+

+void

+flushtypes(void)

+{

+	Type *tp, *next, **h;

+

+	for (tp = localtypes; tp; tp = next) {

+		next = tp->next;

+		switch (tp->op) {

+		default:

+			/*

+			 * All the local types are linked after

+			 * global types, and since we are

+			 * unlinking them in the inverse order

+			 * we do know that tp is always the head

+			 * of the collision list

+			 */

+			h = &typetab[HASH(tp)];

+			assert(*h == tp);

+			*h = tp->h_next;

+		case STRUCT:

+		case UNION:

+		case ENUM:

+			free(tp);

+			break;

+		}

+	}

+	localtypes = NULL;

+}

--- /dev/null

+++ b/src/cmd/scc/cc2/.gitignore

@@ -1,0 +1,1 @@

+error.h

--- /dev/null

+++ b/src/cmd/scc/cc2/Makefile

@@ -1,0 +1,40 @@

+.POSIX:

+

+PROJECTDIR = ../../../..

+include $(PROJECTDIR)/scripts/rules.mk

+

+MORECFLAGS = -I$(INCDIR)/$(STD)

+

+OBJS = main.o \

+       parser.o \

+       peep.o \

+       symbol.o \

+       node.o \

+       code.o \

+       optm.o \

+

+TARGET  = $(LIBEXEC)/cc2-amd64-sysv \

+          $(LIBEXEC)/cc2-i386-sysv \

+          $(LIBEXEC)/cc2-qbe_amd64-sysv \

+          $(LIBEXEC)/cc2-z80-scc \

+

+all: $(TARGET)

+

+$(TARGET): error.h

+

+error.h: cc2.h

+	rm -f $@;\

+	trap 'r=$?;rm -f $$$$.h;exit $r' EXIT INT QUIT ;\

+	awk -f generror.awk cc2.h > $$$$.h && mv $$$$.h $@

+

+dep: inc-dep

+

+clean:

+	rm -f target/*/*.o error.h

+

+include target/amd64-sysv/target.mk

+include target/i386-sysv/target.mk

+include target/qbe_amd64-sysv/target.mk

+include target/qbe_arm64-sysv/target.mk

+include target/z80-scc/target.mk

+include deps.mk

--- /dev/null

+++ b/src/cmd/scc/cc2/cc2.h

@@ -1,0 +1,256 @@

+enum iflags {

+	BBENTRY =    1,        /* basic block entry */

+};

+

+enum tflags {

+	SIGNF   =     1 << 0,  /* Signed type */

+	INTF    =     1 << 1,  /* integer type */

+	FLOATF  =     1 << 2,  /* float type */

+	STRF    =     1 << 3,  /* string */

+	AGGRF   =     1 << 4,  /* aggregate */

+	FUNF    =     1 << 5,  /* function */

+	PARF    =     1 << 6,  /* parameter */

+	INITF   =     1 << 7,  /* initializer flag */

+	ELLIPS  =     1 << 8,  /* vararg function */

+};

+

+enum sclass {

+	SAUTO     = 'A',

+	SREG      = 'R',

+	SLABEL    = 'L',

+	SINDEX    = 'I',

+	STMP      = 'N',

+	SGLOB     = 'G',

+	SEXTRN    = 'X',

+	SPRIV     = 'Y',

+	SLOCAL    = 'T',

+	SMEMB     = 'M',

+	SCONST    = '#',

+	STRING    = '"',

+	SNONE     = 0 /* cc2 relies on SNONE being 0 in nextpc() */

+};

+

+enum types {

+	ELLIPSIS = 'E',

+	INT8     = 'C',

+	INT16    = 'I',

+	INT32    = 'W',

+	INT64    = 'Q',

+	UINT8    = 'K',

+	UINT16   = 'N',

+	UINT32   = 'Z',

+	UINT64   = 'O',

+	POINTER  = 'P',

+	FUNCTION = 'F',

+	VECTOR   = 'V',

+	UNION    = 'U',

+	STRUCT   = 'S',

+	BOOL     = 'B',

+	FLOAT    = 'J',

+	DOUBLE   = 'D',

+	LDOUBLE  = 'H',

+	VOID     = '0'

+};

+

+enum op {

+	/* kind of operand */

+	/* operands */

+	OMEM     = 'M',

+	OTMP     = 'N',

+	OAUTO    = 'A',

+	OREG     = 'R',

+	OCONST   = '#',

+	OSTRING  = '"',

+	OLOAD    = 'D',

+	OLABEL   = 'L',

+	OADD     = '+',

+	OSUB     = '-',

+	OMUL     = '*',

+	OMOD     = '%',

+	ODIV     = '/',

+	OSHL     = 'l',

+	OSHR     = 'r',

+	OLT      = '<',

+	OGT      = '>',

+	OLE      = '[',

+	OGE      = ']',

+	OEQ      = '=',

+	ONE      = '!',

+	OBAND    = '&',

+	OBOR     = '|',

+	OBXOR    = '^',

+	OCPL     = '~',

+	OASSIG   = ':',

+	OSNEG    = '_',

+	OCALL    = 'c',

+	OCALLE   = 'z',

+	OPAR     = 'p',

+	OFIELD   = '.',

+	OCOMMA   = ',',

+	OASK     = '?',

+	OCOLON   = ' ',

+	OADDR    = '\'',

+	OAND     = 'a',

+	OOR      = 'o',

+	ONEG     = 'n',

+	OPTR     = '@',

+	OCAST    = 'g',

+	OINC     = 'i',

+	ODEC     = 'd',

+	OBUILTIN = 'm',

+	/*statements */

+	ONOP     = 'q',

+	OJMP     = 'j',

+	OBRANCH  = 'y',

+	ORET     = 'h',

+	OBLOOP   = 'b',

+	OELOOP   = 'e',

+	OCASE    = 'v',

+	ODEFAULT = 'f',

+	OBSWITCH = 's',

+	OESWITCH = 't',

+	OBFUN    = 'x',

+	OEFUN    = 'k',

+};

+

+enum builtins {

+	BVA_START = 's',

+	BVA_END   = 'e',

+	BVA_ARG   = 'a',

+	BVA_COPY  = 'c',

+};

+

+enum nerrors {

+	EEOFFUN,       /* EOF while parsing function */

+	ENLABEL,       /* label without statement */

+	EIDOVER,       /* identifier overflow */

+	EOUTPAR,       /* out pf params */

+	ESYNTAX,       /* syntax error */

+	ESTACKA,       /* stack unaligned */

+	ESTACKO,       /* stack overflow */

+	ESTACKU,       /* stack underflow */

+	ELNLINE,       /* line too long */

+	ELNBLNE,       /* line without new line */

+	EFERROR,       /* error reading from file:%s */

+	EBADID,        /* incorrect symbol id */

+	EWTACKO,       /* switch stack overflow */

+	EWTACKU,       /* switch stack underflow */

+	ENOSWTC,       /* Out of switch statement */

+	EBBUILT,       /* Unknown builtin */

+	ENUMERR

+};

+

+typedef struct node Node;

+typedef struct type Type;

+typedef struct symbol Symbol;

+typedef struct addr Addr;

+typedef struct inst Inst;

+

+struct type {

+	unsigned long size;

+	unsigned long align;

+	short flags;

+};

+

+struct symbol {

+	Type type;

+	Type rtype;

+	unsigned short id;

+	unsigned short numid;

+	char *name;

+	char kind;

+	union {

+		unsigned long off;

+		Node *stmt;

+		Inst *inst;

+	} u;

+	Symbol *next;

+	Symbol *h_next;

+};

+

+struct node {

+	char op;

+	Type type;

+	char complex;

+	char address;

+	unsigned char flags;

+	union {

+		TUINT i;

+		TFLOAT f;

+		char reg;

+		char *s;

+		Symbol *sym;

+		char subop;

+	} u;

+	Symbol *label;

+	Node *left, *right;

+	Node *next, *prev;

+};

+

+struct addr {

+        char kind;

+        union {

+                char reg;

+                TUINT i;

+                Symbol *sym;

+        } u;

+};

+

+struct inst {

+	unsigned char op;

+	unsigned char flags;

+	Symbol *label;

+	Inst *next, *prev;

+	Addr from1, from2, to;

+};

+

+/* main.c */

+extern void error(unsigned nerror, ...);

+

+/* parse.c */

+extern void parse(void);

+

+/* optm.c */

+extern Node *optm_dep(Node *np), *optm_ind(Node *np);

+

+/* cgen.c */

+extern Node *sethi(Node *np);

+extern Node *cgen(Node *np);

+

+/* peep.c */

+extern void peephole(void);

+

+/* code.c */

+extern void data(Node *np);

+extern void writeout(void), endinit(void), newfun(void);

+extern void code(int op, Node *to, Node *from1, Node *from2);

+extern void defvar(Symbol *), defpar(Symbol *), defglobal(Symbol *);

+extern void setlabel(Symbol *sym), getbblocks(void);

+extern Node *label2node(Node *np, Symbol *sym);

+extern Node *constnode(Node *np, TUINT n, Type *tp);

+extern Symbol *newlabel(void);

+

+/* node.c */

+#define SETCUR  1

+#define KEEPCUR 0

+extern void apply(Node *(*fun)(Node *));

+extern void cleannodes(void);

+extern void delnode(Node *np);

+extern void deltree(Node *np);

+extern void prtree(Node *np), prforest(char *msg);

+extern Node *node(int op);

+extern Node *addstmt(Node *np, int flags);

+extern Node *delstmt(void);

+extern Node *nextstmt(void);

+

+/* symbol.c */

+#define TMPSYM  0

+extern Symbol *getsym(unsigned id);

+extern void popctx(void);

+extern void pushctx(void);

+extern void freesym(Symbol *sym);

+

+/* globals */

+extern Symbol *curfun;

+extern Symbol *locals;

+extern Inst *pc, *prog;

--- /dev/null

+++ b/src/cmd/scc/cc2/code.c

@@ -1,0 +1,133 @@

+static char sccsid[] = "@(#) ./cc2/code.c";

+#include <stdlib.h>

+#include <string.h>

+

+#include <scc/scc.h>

+#include "cc2.h"

+

+Inst *pc, *prog;

+

+static void

+nextpc(void)

+{

+        Inst *new;

+

+        new = xcalloc(1, sizeof(*new)); /* TODO: create an arena */

+

+        if (!pc) {

+                prog = new;

+        } else {

+                new->next = pc->next;

+                pc->next = new;

+        }

+

+	/* SNONE being 0, calloc initialized {from1,from2,to}.kind for us */

+        new->prev = pc;

+        pc = new;

+}

+

+static void

+addr(Node *np, Addr *addr)

+{

+	Symbol *sym;

+

+	switch (np->op) {

+	case OREG:

+		/* TODO:

+		 * At this moment this op is used also for register variables

+		 */

+		addr->kind = SREG;

+		addr->u.reg = np->u.reg;

+		break;

+	case OCONST:

+		addr->kind = SCONST;

+		/* TODO: Add support for more type of constants */

+		addr->u.i = np->u.i;

+		break;

+	case OTMP:

+	case OLABEL:

+	case OAUTO:

+	case OMEM:

+		sym = np->u.sym;

+		addr->kind = sym->kind;

+		addr->u.sym = sym;

+		break;

+	default:

+		abort();

+	}

+}

+

+Symbol *

+newlabel(void)

+{

+	Symbol *sym = getsym(TMPSYM);

+

+	sym->kind = SLABEL;

+	return sym;

+}

+

+Node *

+label2node(Node *np, Symbol *sym)

+{

+	if(!sym)

+		sym = newlabel();

+	if (!np)

+		np = node(OLABEL);

+	np->op = OLABEL;

+	np->u.sym = sym;

+

+	return np;

+}

+

+Node *

+constnode(Node *np, TUINT n, Type *tp)

+{

+	if (!np)

+		np = node(OCONST);

+	np->op = OCONST;

+	np->left = NULL;

+	np->right = NULL;

+	np->type = *tp;

+	np->u.i = n;

+	return np;

+}

+

+void

+setlabel(Symbol *sym)

+{

+	if (!sym)

+		return;

+	code(0, NULL, NULL, NULL);

+	pc->label = sym;

+	sym->u.inst = pc;

+}

+

+void

+code(int op, Node *to, Node *from1, Node *from2)

+{

+	nextpc();

+	if (from1)

+		addr(from1, &pc->from1);

+	if (from2)

+		addr(from2, &pc->from2);

+	if (to)

+		addr(to, &pc->to);

+	pc->op = op;

+}

+

+void

+delcode(void)

+{

+        Inst *prev = pc->prev, *next = pc->next;

+

+        free(pc);

+        if (!prev) {

+                pc = next;

+                prog = NULL;

+        } else {

+                pc = prev;

+                prev->next = next;

+                if (next)

+                        next->prev = prev;

+        }

+}

--- /dev/null

+++ b/src/cmd/scc/cc2/deps.mk

@@ -1,0 +1,61 @@

+#deps

+code.o: $(INCDIR)/scc/scc/scc.h

+code.o: cc2.h

+main.o: $(INCDIR)/scc/scc/arg.h

+main.o: $(INCDIR)/scc/scc/scc.h

+main.o: cc2.h

+main.o: error.h

+node.o: $(INCDIR)/scc/scc/scc.h

+node.o: cc2.h

+optm.o: $(INCDIR)/scc/scc/scc.h

+optm.o: cc2.h

+parser.o: $(INCDIR)/scc/scc/cstd.h

+parser.o: $(INCDIR)/scc/scc/scc.h

+parser.o: cc2.h

+peep.o: $(INCDIR)/scc/scc/scc.h

+peep.o: cc2.h

+symbol.o: $(INCDIR)/scc/scc/scc.h

+symbol.o: cc2.h

+target/amd64-sysv/cgen.o: $(INCDIR)/scc/scc/scc.h

+target/amd64-sysv/cgen.o: target/amd64-sysv/../../cc2.h

+target/amd64-sysv/cgen.o: target/amd64-sysv/arch.h

+target/amd64-sysv/code.o: $(INCDIR)/scc/scc/cstd.h

+target/amd64-sysv/code.o: $(INCDIR)/scc/scc/scc.h

+target/amd64-sysv/code.o: target/amd64-sysv/../../cc2.h

+target/amd64-sysv/code.o: target/amd64-sysv/arch.h

+target/amd64-sysv/optm.o: $(INCDIR)/scc/scc/scc.h

+target/amd64-sysv/optm.o: target/amd64-sysv/../../cc2.h

+target/amd64-sysv/types.o: $(INCDIR)/scc/scc/scc.h

+target/amd64-sysv/types.o: target/amd64-sysv/../../cc2.h

+target/i386-sysv/cgen.o: $(INCDIR)/scc/scc/scc.h

+target/i386-sysv/cgen.o: target/i386-sysv/../../cc2.h

+target/i386-sysv/cgen.o: target/i386-sysv/arch.h

+target/i386-sysv/code.o: $(INCDIR)/scc/scc/cstd.h

+target/i386-sysv/code.o: $(INCDIR)/scc/scc/scc.h

+target/i386-sysv/code.o: target/i386-sysv/../../cc2.h

+target/i386-sysv/code.o: target/i386-sysv/arch.h

+target/i386-sysv/optm.o: $(INCDIR)/scc/scc/scc.h

+target/i386-sysv/optm.o: target/i386-sysv/../../cc2.h

+target/i386-sysv/types.o: $(INCDIR)/scc/scc/scc.h

+target/i386-sysv/types.o: target/i386-sysv/../../cc2.h

+target/qbe/cgen.o: $(INCDIR)/scc/scc/cstd.h

+target/qbe/cgen.o: $(INCDIR)/scc/scc/scc.h

+target/qbe/cgen.o: target/qbe/../../cc2.h

+target/qbe/cgen.o: target/qbe/arch.h

+target/qbe/code.o: $(INCDIR)/scc/scc/cstd.h

+target/qbe/code.o: $(INCDIR)/scc/scc/scc.h

+target/qbe/code.o: target/qbe/../../cc2.h

+target/qbe/code.o: target/qbe/arch.h

+target/qbe/optm.o: $(INCDIR)/scc/scc/scc.h

+target/qbe/optm.o: target/qbe/../../cc2.h

+target/z80-scc/cgen.o: $(INCDIR)/scc/scc/scc.h

+target/z80-scc/cgen.o: target/z80-scc/../../cc2.h

+target/z80-scc/cgen.o: target/z80-scc/arch.h

+target/z80-scc/code.o: $(INCDIR)/scc/scc/cstd.h

+target/z80-scc/code.o: $(INCDIR)/scc/scc/scc.h

+target/z80-scc/code.o: target/z80-scc/../../cc2.h

+target/z80-scc/code.o: target/z80-scc/arch.h

+target/z80-scc/optm.o: $(INCDIR)/scc/scc/scc.h

+target/z80-scc/optm.o: target/z80-scc/../../cc2.h

+target/z80-scc/types.o: $(INCDIR)/scc/scc/scc.h

+target/z80-scc/types.o: target/z80-scc/../../cc2.h

--- /dev/null

+++ b/src/cmd/scc/cc2/generror.awk

@@ -1,0 +1,9 @@

+/^enum nerrors \{/     {print "char *errlist[] = {"; inhome = 1}

+

+inhome && /E[A-Z]*, /  {sub(/,/, "", $1)

+                        printf("\t[%s] = \"", $1)

+                        for (i = 3; i <= NF-1; ++i)

+				printf("%s%s", $i, (i == NF-1) ? "\"" : " ")

+			print ","}

+

+inhome && /^}/          {print "};" ; inhome = 0}

--- /dev/null

+++ b/src/cmd/scc/cc2/main.c

@@ -1,0 +1,70 @@

+static char sccsid[] = "@(#) ./cc2/main.c";

+

+#include <errno.h>

+#include <stdarg.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+

+#include <scc/arg.h>

+#include <scc/scc.h>

+#include "cc2.h"

+#include "error.h"

+

+char *argv0;

+

+void

+error(unsigned nerror, ...)

+{

+	va_list va;

+	va_start(va, nerror);

+	vfprintf(stderr, errlist[nerror], va);

+	va_end(va);

+	putc('\n', stderr);

+	exit(1);

+}

+

+static int

+moreinput(void)

+{

+	int c;

+

+repeat:

+	if (feof(stdin))

+		return 0;

+	if ((c = getchar()) == '\n' || c == EOF)

+		goto repeat;

+	ungetc(c, stdin);

+	return 1;

+}

+

+static void

+usage(void)

+{

+	fputs("usage: cc2 [irfile]\n", stderr);

+	exit(1);

+}

+

+int

+main(int argc, char *argv[])

+{

+	ARGBEGIN {

+	default:

+		usage();

+	} ARGEND

+

+	if (argv[0] && !freopen(argv[0], "r", stdin))

+		die("cc2: %s: %s", argv[0], strerror(errno));

+

+	while (moreinput()) {

+		parse();

+		apply(optm_ind);

+		apply(optm_dep);

+		apply(sethi);

+		apply(cgen);

+		getbblocks();  /* TODO: run apply over asm ins too */

+		peephole();

+		writeout();

+	}

+	return 0;

+}

--- /dev/null

+++ b/src/cmd/scc/cc2/node.c

@@ -1,0 +1,142 @@

+static char sccsid[] = "@(#) ./cc2/node.c";

+#include <stdlib.h>

+#include <string.h>

+

+#include <scc/scc.h>

+

+#include "cc2.h"

+

+#define NNODES   32

+

+Node *curstmt;

+Symbol *curfun;

+

+static Alloc *arena;

+

+

+Node *

+node(int op)

+{

+	struct arena *ap;

+	Node *np;

+

+	if (!arena)

+		arena = alloc(sizeof(Node), NNODES);

+	np = memset(new(arena), 0, sizeof(*np));

+	np->op = op;

+

+	return np;

+}

+

+#ifndef NDEBUG

+#include <stdio.h>

+

+static void

+prnode(Node *np)

+{

+	if (np->left)

+		prnode(np->left);

+	if (np->right)

+		prnode(np->right);

+	fprintf(stderr, "\t%c%lu", np->op, np->type.size);

+}

+

+void

+prtree(Node *np)

+{

+	prnode(np);

+	putc('\n', stderr);

+}

+

+void

+prforest(char *msg)

+{

+	Node *np;

+

+	if (!curfun)

+		return;

+

+	fprintf(stderr, "%s {\n", msg);

+	for (np = curfun->u.stmt; np; np = np->next)

+		prtree(np);

+	fputs("}\n", stderr);

+}

+#endif

+

+Node *

+addstmt(Node *np, int flag)

+{

+	if (curstmt)

+		np->next = curstmt->next;

+	np->prev = curstmt;

+

+	if (!curfun->u.stmt)

+		curfun->u.stmt = np;

+	else

+		curstmt->next = np;

+

+	if (flag == SETCUR)

+		curstmt = np;

+

+	return np;

+}

+

+Node *

+delstmt(void)

+{

+	Node *next, *prev;

+

+	next = curstmt->next;

+	prev = curstmt->prev;

+	if (next)

+		next->prev = prev;

+	if (prev)

+		prev->next = next;

+	else

+		curfun->u.stmt = next;

+	deltree(curstmt);

+

+	return curstmt = next;

+}

+

+Node *

+nextstmt(void)

+{

+	return curstmt = curstmt->next;

+}

+

+void

+delnode(Node *np)

+{

+	delete(arena, np);

+}

+

+void

+deltree(Node *np)

+{

+	if (!np)

+		return;

+	deltree(np->left);

+	deltree(np->right);

+	delnode(np);

+}

+

+void

+cleannodes(void)

+{

+	if (arena) {

+		dealloc(arena);

+		arena = NULL;

+	}

+	curstmt = NULL;

+}

+

+void

+apply(Node *(*fun)(Node *))

+{

+	if (!curfun)

+		return;

+	curstmt = curfun->u.stmt;

+	while (curstmt)

+		(*fun)(curstmt) ? nextstmt() : delstmt();

+}

--- /dev/null

+++ b/src/cmd/scc/cc2/optm.c

@@ -1,0 +1,9 @@

+#include <scc/scc.h>

+#include "cc2.h"

+

+Node *

+optm_ind(Node *np)

+{

+	return np;

+}

+

--- /dev/null

+++ b/src/cmd/scc/cc2/parser.c

@@ -1,0 +1,722 @@

+static char sccsid[] = "@(#) ./cc2/parser.c";

+#include <errno.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+

+#include <scc/cstd.h>

+#include <scc/scc.h>

+

+#include "cc2.h"

+

+#define STACKSIZ     50

+

+extern Type int8type, int16type, int32type, int64type,

+            uint8type, uint16type, uint32type, uint64type,

+            float32type, float64type, float80type,

+            booltype,

+            ptrtype,

+            voidtype,

+            arg_type;

+

+Type funetype = {

+	.flags = FUNF | ELLIPS

+};

+

+Type funtype = {

+	.flags = FUNF

+};

+

+union tokenop {

+	void *arg;

+	unsigned op;

+};

+

+struct swtch {

+	int nr;

+	Node *first;

+	Node *last;

+};

+

+static struct swtch swtbl[NR_BLOCK], *swp = swtbl;

+static Symbol *lastfun;

+

+typedef void parsefun(char *, union tokenop);

+static parsefun type, symbol, getname, unary, binary, ternary, call,

+                constant, composed, binit, einit,

+                jump, oreturn, loop, assign,

+                ocase, bswitch, eswitch, builtin;

+

+typedef void evalfun(void);

+static evalfun vardecl, beginfun, endfun, endpars, stmt,

+               array, aggregate, flddecl, labeldcl;

+

+static struct decoc {

+	void (*eval)(void);

+	void (*parse)(char *token, union tokenop);

+	union tokenop u;

+} optbl[] = {      /*  eval     parse           args */

+	['A']   = {  vardecl,  symbol, .u.op  =  SAUTO<<8 | OAUTO},

+	['R']   = {  vardecl,  symbol, .u.op  =   SREG<<8 |  OREG},

+	['G']   = {  vardecl,  symbol, .u.op  =  SGLOB<<8 |  OMEM},

+	['X']   = {  vardecl,  symbol, .u.op  = SEXTRN<<8 |  OMEM},

+	['Y']   = {  vardecl,  symbol, .u.op  =  SPRIV<<8 |  OMEM},

+	['T']   = {  vardecl,  symbol, .u.op  = SLOCAL<<8 |  OMEM},

+	['M']   = {  flddecl,  symbol, .u.op  =  SMEMB<<8 |  OMEM},

+	['L']   = { labeldcl,  symbol, .u.op  = SLABEL<<8 | OLABEL},

+

+	['C']   = {     NULL,    type, .u.arg =    &int8type},

+	['I']   = {     NULL,    type, .u.arg =   &int16type},

+	['W']   = {     NULL,    type, .u.arg =   &int32type},

+	['Q']   = {     NULL,    type, .u.arg =   &int64type},

+	['K']   = {     NULL,    type, .u.arg =   &uint8type},

+	['N']   = {     NULL,    type, .u.arg =  &uint16type},

+	['Z']   = {     NULL,    type, .u.arg =  &uint32type},

+	['O']   = {     NULL,    type, .u.arg =  &uint64type},

+	['J']   = {     NULL,    type, .u.arg = &float32type},

+	['D']   = {     NULL,    type, .u.arg = &float64type},

+	['H']   = {     NULL,    type, .u.arg = &float80type},

+	['0']   = {     NULL,    type, .u.arg =    &voidtype},

+	['B']   = {     NULL,    type, .u.arg =    &booltype},

+	['P']   = {     NULL,    type, .u.arg =     &ptrtype},

+	['E']   = {     NULL,    type, .u.arg =    &funetype},

+	['1']	= {     NULL,    type, .u.arg =    &arg_type},

+

+	['F']   = {     NULL,    type, .u.arg =     &funtype},

+	['V']   = {    array,composed,                     0},

+	['U']   = {aggregate,composed,                     0},

+	['S']   = {aggregate,composed,                     0},

+

+	['"']   = {     NULL, getname,                     0},

+	['{']   = { beginfun,    NULL,                     0},

+	['}']   = {   endfun,    NULL,                     0},

+	['(']   = {     NULL,   binit,                     0},

+	[')']   = {     NULL,   einit,                     0},

+	['\\']  = {  endpars,    NULL,                     0},

+	['\t']  = {     stmt,    NULL,                     0},

+

+	['~']   = {     NULL,   unary, .u.op =          OCPL},

+	['_']   = {     NULL,   unary, .u.op =         OSNEG},

+	['\'']  = {     NULL,   unary, .u.op =         OADDR},

+	['@']   = {     NULL,   unary, .u.op =          OPTR},

+	['g']   = {     NULL,   unary, .u.op =         OCAST},

+	['p']   = {     NULL,   unary, .u.op =          OPAR},

+	['n']   = {     NULL,   unary, .u.op =          ONEG},

+

+	['a']   = {     NULL,  binary, .u.op =          OAND},

+	['o']   = {     NULL,  binary, .u.op =           OOR},

+	['.']   = {     NULL,  binary, .u.op =        OFIELD},

+	['+']   = {     NULL,  binary, .u.op =          OADD},

+	['-']   = {     NULL,  binary, .u.op =          OSUB},

+	['*']   = {     NULL,  binary, .u.op =          OMUL},

+	['%']   = {     NULL,  binary, .u.op =          OMOD},

+	['/']   = {     NULL,  binary, .u.op =          ODIV},

+	['l']   = {     NULL,  binary, .u.op =          OSHL},

+	['r']   = {     NULL,  binary, .u.op =          OSHR},

+	['<']   = {     NULL,  binary, .u.op =           OLT},

+	['>']   = {     NULL,  binary, .u.op =           OGT},

+	['[']   = {     NULL,  binary, .u.op =           OLE},

+	[']']   = {     NULL,  binary, .u.op =           OGE},

+	['=']   = {     NULL,  binary, .u.op =           OEQ},

+	['!']   = {     NULL,  binary, .u.op =           ONE},

+	['&']   = {     NULL,  binary, .u.op =         OBAND},

+	['|']   = {     NULL,  binary, .u.op =          OBOR},

+	['^']   = {     NULL,  binary, .u.op =         OBXOR},

+	[',']   = {     NULL,  binary, .u.op =        OCOMMA},

+	['m']   = {     NULL,  builtin,.u.op =      OBUILTIN},

+

+	[':']   = {     NULL,  assign, .u.op =        OASSIG},

+	['?']   = {     NULL, ternary, .u.op =          OASK},

+	['c']   = {     NULL,    call, .u.op =         OCALL},

+	['z']   = {     NULL,    call, .u.op =        OCALLE},

+

+	['#']   = {     NULL,constant, .u.op =        OCONST},

+

+	['j']   = {     NULL,    jump, .u.op =          OJMP},

+	['y']   = {     NULL,    jump, .u.op =       OBRANCH},

+	['h']   = {     NULL, oreturn, .u.op =          ORET},

+	['i']   = {     NULL,    NULL, .u.op =          OINC},

+	['d']   = {     NULL,    NULL, .u.op =          ODEC},

+

+	['b']   = {     NULL,    loop, .u.op =        OBLOOP},

+	['e']   = {     NULL,    loop, .u.op =        OELOOP},

+

+	['v']   = {     NULL,   ocase, .u.op =         OCASE},

+	['f']   = {     NULL,   ocase, .u.op =      ODEFAULT},

+	['t']   = {     NULL, eswitch, .u.op =      OESWITCH},

+	['s']   = {     NULL, bswitch, .u.op =      OBSWITCH},

+};

+

+static int sclass, inpars, ininit, endf, lineno;

+static void *stack[STACKSIZ], **sp = stack;

+

+static Node *

+push(void *elem)

+{

+	if (sp == &stack[STACKSIZ])

+		error(ESTACKO);

+	return *sp++ = elem;

+}

+

+static void *

+pop(void)

+{

+	if (sp == stack)

+		error(ESTACKU);

+	return *--sp;

+}

+

+static int

+empty(void)

+{

+	return sp == stack;

+}

+

+static void

+type(char *token, union tokenop u)

+{

+	push(u.arg);

+}

+

+static void

+composed(char *token, union tokenop u)

+{

+	Symbol *sym;

+

+	sym = getsym(atoi(token+1));

+	push(&sym->type);

+}

+

+static void

+getname(char *t, union tokenop u)

+{

+	push((*++t) ? xstrdup(t) : NULL);

+}

+

+static void

+symbol(char *token, union tokenop u)

+{

+	Node *np = node(u.op & 0xFF);

+	Symbol *sym = getsym(atoi(token+1));

+

+	sclass = u.op >> 8;

+	np->u.sym = sym;

+	np->type = sym->type;

+	push(np);

+}

+

+static Type *

+gettype(char *token)

+{

+	struct decoc *dp;

+

+	dp = &optbl[*token];

+	if (!dp->parse)

+		error(ESYNTAX);

+	(*dp->parse)(token, dp->u);

+	return pop();

+}

+

+static void

+constant(char *token, union tokenop u)

+{

+	static char letters[] = "0123456789ABCDEF";

+	Node *np;

+	TUINT v;

+	unsigned c;

+

+	++token;

+	if (*token == '"') {

+		++token;

+		np = node(OSTRING);

+		np->type.flags = STRF;

+		np->type.size = strlen(token);

+		np->type.align = int8type.align;

+		np->u.s = xstrdup(token);

+	} else {

+		np = node(OCONST);

+		np->type = *gettype(token++);

+		for (v = 0; c = *token++; v += c) {

+			v <<= 4;

+			c = strchr(letters, c) - letters;

+		}

+		np->u.i = v;

+	}

+	push(np);

+}

+

+static void

+assign(char *token, union tokenop u)

+{

+	int subop;

+	Node *np = node(u.op);

+

+	switch (subop = *++token) {

+	case '+':

+	case '-':

+	case '*':

+	case '%':

+	case '/':

+	case 'l':

+	case 'r':

+	case '&':

+	case '|':

+	case '^':

+	case 'i':

+	case 'd':

+		++token;

+		subop = optbl[subop].u.op;

+		break;

+	default:

+		subop = 0;

+		break;

+	}

+

+	np->u.subop = subop;

+	np->type = *gettype(token);

+	np->right = pop();

+	np->left = pop();

+	push(np);

+}

+

+static void

+ternary(char *token, union tokenop u)

+{

+	Node *ask = node(OASK), *colon = node(OCOLON);

+	Type *tp = gettype(token+1);

+

+	colon->right = pop();

+	colon->left = pop();

+

+	ask->type = *tp;

+	ask->left = pop();

+	ask->right = colon;

+	push(ask);

+}

+

+static void

+eval(char *tok)

+{

+	struct decoc *dp;

+

+	do {

+		dp = &optbl[*tok];

+		if (!dp->parse)

+			break;

+		(*dp->parse)(tok, dp->u);

+	} while (tok = strtok(NULL, "\t\n"));

+}

+

+static int

+nextline(void)

+{

+	static char line[LINESIZ];

+	size_t len;

+	int c;

+	void (*fun)(void);

+

+repeat:

+	++lineno;

+	if (!fgets(line, sizeof(line), stdin))

+		return 0;

+	if ((len = strlen(line)) == 0 || line[0] == '\n')

+		goto repeat;

+	if (line[len-1] != '\n')

+		error(len < sizeof(line)-1 ? ELNBLNE : ELNLINE);

+	line[len-1] = '\0';

+

+	c = *line;

+	eval(strtok(line, "\t\n"));

+	if ((fun = *optbl[c].eval) != NULL)

+		(*fun)();

+	if (sp != stack)

+		error(ESTACKA);

+	return 1;

+}

+

+static void

+oreturn(char *token, union tokenop u)

+{

+	Node *np = node(u.op);

+

+	if (token = strtok(NULL, "\t\n"))

+		eval(token);

+	if (!empty())

+		np->left = pop();

+	push(np);

+}

+

+/*

+ * Move np (which is a OCASE/ODEFAULT/OESWITCH) to be contigous with

+ * the last switch table. It is a bit ugly to touch directly curstmt

+ * here, but moving this function to node.c is worse, because we are

+ * putting knowledge of how the text is parsed into the node

+ * represtation module.

+ */

+static void

+waft(Node *np)

+{

+	Node *lastcase, *next;;

+	struct swtch *cur;

+	extern Node *curstmt;

+

+	if (swp == swtbl)

+		error(EWTACKU);

+

+	cur = swp - 1;

+	lastcase = cur->last;

+	next = lastcase->next;

+

+	np->next = next;

+	np->prev = lastcase;

+

+	if (next)

+		next->prev = np;

+	lastcase->next = np;

+

+	if (curstmt == cur->last)

+		curstmt = np;

+	cur->last = np;

+	cur->nr++;

+}

+

+static void

+bswitch(char *token, union tokenop u)

+{

+	struct swtch *cur;

+	Node *np = node(u.op);

+

+	if (swp == &swtbl[NR_BLOCK])

+		error(EWTACKO);

+	cur = swp++;

+	cur->nr = 0;

+

+	eval(strtok(NULL, "\t\n"));

+	np->left = pop();

+

+	push(cur->first = cur->last = np);

+}

+

+static void

+eswitch(char *token, union tokenop u)

+{

+	struct swtch *cur;

+

+	if (swp == swtbl)

+		error(EWTACKU);

+	jump(token, u);

+	waft(pop());

+	cur = --swp;

+	cur->first->u.i = cur->nr;

+}

+

+static void

+ocase(char *token, union tokenop u)

+{

+	jump(token, u);

+	waft(pop());

+}

+

+static void

+jump(char *token, union tokenop u)

+{

+	Node *aux, *np = node(u.op);

+

+	eval(strtok(NULL, "\t\n"));

+

+	if (u.op == OBRANCH || u.op == OCASE)

+		np->left = pop();

+	aux = pop();

+	np->u.sym = aux->u.sym;

+	delnode(aux);

+	push(np);

+}

+

+static void

+loop(char *token, union tokenop u)

+{

+	push(node(u.op));

+}

+

+static void

+unary(char *token, union tokenop u)

+{

+	Node *np = node(u.op);

+

+	np->type = *gettype(token+1);

+	np->left = pop();

+	np->right = NULL;

+	push(np);

+}

+

+static void

+call(char *token, union tokenop u)

+{

+	Node *np, *par, *fun = node(u.op);

+

+	for (par = NULL;; par = np) {

+		np = pop();

+		if (np->op != OPAR)

+			break;

+		np->right = par;

+	}

+

+	fun->type = *gettype(token+1);

+	fun->left = np;

+	fun->right = par;

+	push(fun);

+}

+

+static void

+builtin(char *token, union tokenop u)

+{

+	Node *np = node(u.op);

+	char *name;

+	unsigned subop, nchilds;

+

+	np->type = *gettype(token+1);

+	name = pop();

+

+	if (!strcmp("__builtin_va_arg", name)) {

+		nchilds = 1;

+		subop = BVA_ARG;

+	} else if (!strcmp("__builtin_va_start", name)) {

+		nchilds = 2;

+		subop = BVA_START;

+	} else if (!strcmp("__builtin_va_end", name)) {

+		nchilds = 1;

+		subop = BVA_END;

+	} else if (!strcmp("__builtin_va_copy", name)) {

+		nchilds = 2;

+		subop = BVA_COPY;

+	} else {

+		error(EBBUILT);;

+	}

+

+	np->u.subop = subop;

+	np->right = (nchilds == 2) ? pop() : NULL;

+	np->left = (nchilds != 0) ? pop() : NULL;

+

+	free(name);

+	push(np);

+}

+

+static void

+binary(char *token, union tokenop u)

+{

+	Node *np = node(u.op);

+

+	np->type = *gettype(token+1);

+	np->right = pop();

+	np->left = pop();

+	push(np);

+}

+

+static void

+binit(char *token, union tokenop u)

+{

+	ininit = 1;

+}

+

+static void

+einit(char *token, union tokenop u)

+{

+	ininit = 0;

+	endinit();

+}

+

+static void

+endpars(void)

+{

+	if (!curfun || !inpars)

+		error(ESYNTAX);

+	inpars = 0;

+}

+

+static void

+aggregate(void)

+{

+	Node *align, *size;

+	char *name;

+	Type *tp;

+	Symbol *sym;

+

+	align = pop();

+	size = pop();

+	name = pop();

+	tp = pop();

+

+	tp->size = size->u.i;

+	tp->align = align->u.i;

+	tp->flags = AGGRF;

+	/*

+	 * type is the first field of Symbol so we can obtain the

+	 * address of the symbol from the address of the type.

+	 * We have to do this because composed returns the pointer

+	 * to the type, but in this function we also need the

+	 * symbol to store the name.

+	 */

+	sym = (Symbol *) tp;

+	sym->name = name;

+

+	delnode(align);

+	delnode(size);

+}

+

+static void

+array(void)

+{

+	Type *tp, *base;

+	Node *size;

+

+	size = pop();

+	base = pop();

+	tp = pop();

+	tp->size = size->u.i * base->size; /* FIXME check for overflow */

+	tp->align = base->align;

+

+	delnode(size);

+}

+

+static void

+decl(Symbol *sym)

+{

+	Type *tp = &sym->type;

+

+	if (tp->flags & FUNF) {

+		lastfun = sym;

+	} else {

+		switch (sym->kind) {

+		case SEXTRN:

+		case SGLOB:

+		case SPRIV:

+		case SLOCAL:

+			defglobal(sym);

+			break;

+		case SAUTO:

+		case SREG:

+			if (!curfun)

+				error(ESYNTAX);

+			((inpars) ? defpar : defvar)(sym);

+			break;

+		default:

+			abort();

+		}

+	}

+}

+

+static void

+vardecl(void)

+{

+	Type *tp, *rp;

+	Node *np;

+	Symbol *sym;

+	char *name;

+

+	name = pop();

+	tp = pop();

+	if (tp->flags & FUNF)

+		rp = pop();

+	np = pop();

+

+	sym = np->u.sym;

+	/*

+	 * We have to free sym->name because in tentative declarations

+	 * we can have multiple declarations of the same symbol, and in

+	 * this case our parser will allocate twice the memory

+	 */

+	free(sym->name);

+	sym->name = name;

+	sym->type = *tp;

+	if (tp->flags & FUNF)

+		sym->rtype = *rp;

+	sym->kind = sclass;

+

+	if (ininit)

+		sym->type.flags |= INITF;

+	decl(sym);

+	delnode(np);

+}

+

+static void

+flddecl(void)

+{

+	Node *off, *np;

+	char *name;

+	Type *tp;

+	Symbol *sym;

+

+	off = pop();

+	name = pop();

+	tp = pop();

+	np = pop();

+

+	sym = np->u.sym;

+	sym->u.off = off->u.i;

+	sym->name = name;

+	sym->type = *tp;

+

+	delnode(np);

+	delnode(off);

+}

+

+static void

+labeldcl(void)

+{

+	Node *np;

+	Symbol *sym;

+

+	np = pop();

+	np->op = ONOP;

+	sym = np->u.sym;

+	sym->kind = SLABEL;

+	sym->u.stmt = np;

+	np->label = sym;

+	addstmt(np, SETCUR);

+}

+

+static void

+stmt(void)

+{

+	Node *np;

+

+	if (empty())

+		return;

+	np = pop();

+	if (ininit) {

+		data(np);

+		deltree(np);

+		return;

+	}

+	addstmt(np, SETCUR);

+}

+

+static void

+beginfun(void)

+{

+	curfun = lastfun;

+	inpars = 1;

+	pushctx();

+	addstmt(node(OBFUN), SETCUR);

+}

+

+static void

+endfun(void)

+{

+	endf = 1;

+	addstmt(node(OEFUN), SETCUR);

+}

+

+void

+parse(void)

+{

+	cleannodes();  /* remove code of previous function */

+	popctx();  /* remove context of previous function */

+	curfun = NULL;

+	endf = 0;

+

+	while (!endf && nextline())

+		;

+	if (ferror(stdin))

+		error(EFERROR, strerror(errno));

+}

--- /dev/null

+++ b/src/cmd/scc/cc2/peep.c

@@ -1,0 +1,8 @@

+static char sccsid[] = "@(#) ./cc2/peep.c";

+#include <scc/scc.h>

+#include "cc2.h"

+

+void

+peephole(void)

+{

+}

--- /dev/null

+++ b/src/cmd/scc/cc2/symbol.c

@@ -1,0 +1,92 @@

+static char sccsid[] = "@(#) ./cc2/symbol.c";

+#include <limits.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+

+#include <scc/scc.h>

+

+#include "cc2.h"

+

+#define NR_SYMHASH  64

+

+Symbol *locals;

+

+static Symbol *symtab[NR_SYMHASH], *curlocal;

+static int infunction;

+

+

+void

+freesym(Symbol *sym)

+{

+	free(sym->name);

+	free(sym);

+}

+

+void

+pushctx(void)

+{

+	infunction = 1;

+}

+

+void

+popctx(void)

+{

+	Symbol *sym, *next;

+

+	infunction = 0;

+	for (sym = locals; sym; sym = next) {

+		next = sym->next;

+		/*

+		 * Symbols are inserted in the hash in the inverted

+		 * order they are found in locals and it is impossible

+		 * to have a global over a local, because a local is

+		 * any symbol defined in the body of a function,

+		 * even if it has extern linkage.

+		 * For this reason when we reach a symbol in the

+		 * locals list we know that it is the head of it

+		 * collision list and we can remove it assigning

+		 * it h_next to the hash table position

+		 */

+		if (sym->id != TMPSYM)

+			symtab[sym->id & NR_SYMHASH-1] = sym->h_next;

+		freesym(sym);

+	}

+	curlocal = locals = NULL;

+}

+

+Symbol *

+getsym(unsigned id)

+{

+	Symbol **htab, *sym;

+	static unsigned short num;

+

+	if (id >= USHRT_MAX)

+		error(EBADID);

+

+	if (id != TMPSYM) {

+		htab = &symtab[id & NR_SYMHASH-1];

+		for (sym = *htab; sym; sym = sym->h_next) {

+			if (sym->id == id)

+				return sym;

+		}

+	}

+

+	sym = xcalloc(1, sizeof(*sym));

+	sym->id = id;

+	if (infunction) {

+		if (!locals)

+			locals = sym;

+		if (curlocal)

+			curlocal->next = sym;

+		curlocal = sym;

+	}

+	if (id != TMPSYM) {

+		sym->h_next = *htab;

+		*htab = sym;

+	}

+	if ((sym->numid = ++num) == 0)

+		error(EIDOVER);

+

+	return sym;

+}

--- /dev/null

+++ b/src/cmd/scc/cc2/target/amd64-sysv/cgen.c

@@ -1,0 +1,15 @@

+static char sccsid[] = "@(#) ./cc2/arch/amd64-sysv/cgen.c";

+

+#include "arch.h"

+#include <scc/scc.h>

+#include "../../cc2.h"

+

+Node *

+cgen(Node *np)

+{

+}

+

+Node *

+sethi(Node *np)

+{

+}

--- /dev/null

+++ b/src/cmd/scc/cc2/target/amd64-sysv/code.c

@@ -1,0 +1,211 @@

+static char sccsid[] = "@(#) ./cc2/arch/amd64-sysv/code.c";

+

+#include <stdio.h>

+#include <stdlib.h>

+

+#include <scc/cstd.h>

+#include <scc/scc.h>

+

+#include "arch.h"

+#include "../../cc2.h"

+

+enum segment {

+	CODESEG,

+	DATASEG,

+	BSSSEG,

+	NOSEG

+};

+

+static int curseg = NOSEG;

+

+static void

+segment(int seg)

+{

+	static char *txt[] = {

+		[CODESEG] = "\t.text\n",

+		[DATASEG] = "\t.data\n",

+		[BSSSEG] = "\t.bss\n",

+	};

+

+	if (seg == curseg)

+		return;

+	fputs(txt[seg], stdout);

+	curseg = seg;

+}

+

+static char *

+symname(Symbol *sym)

+{

+	static char name[INTIDENTSIZ+1];

+

+	if (sym->name) {

+		switch (sym->kind) {

+		case SEXTRN:

+		case SGLOB:

+		case SPRIV:

+			return sym->name;

+		}

+	}

+

+	sprintf(name, ".L%d", sym->numid);

+

+	return name;

+}

+

+static void

+emitconst(Node *np)

+{

+	switch (np->type.size) {

+	case 1:

+		printf("%d", (int) np->u.i & 0xFF);

+		break;

+	case 2:

+		printf("%d", (int) np->u.i & 0xFFFF);

+		break;

+	case 4:

+		printf("%ld", (long) np->u.i & 0xFFFFFFFF);

+		break;

+	case 8:

+		printf("%lld", (long long) np->u.i & 0xFFFFFFFF);

+		break;

+	default:

+		abort();

+	}

+}

+

+static void

+emittree(Node *np)

+{

+	if (!np)

+		return;

+

+	switch (np->op) {

+	case OSTRING:

+		printf("\"%s\"", np->u.s);

+		free(np->u.s);

+		np->u.s = NULL;

+		break;

+	case OCONST:

+		emitconst(np);

+		break;

+	case OADDR:

+		emittree(np->left);

+		break;

+	case OMEM:

+		fputs(symname(np->u.sym), stdout);

+		break;

+	default:

+		emittree(np->left);

+		printf(" %c ", np->op);

+		emittree(np->right);

+		break;

+	}

+}

+static void

+size2asm(Type *tp)

+{

+	char *s;

+

+	if (tp->flags & STRF) {

+		s = "\t.ascii\t";

+	} else {

+		switch (tp->size) {

+		case 1:

+			s = "\t.byte\t";

+			break;

+		case 2:

+			s = "\t.short\t";

+			break;

+		case 4:

+			s = "\t.long\t";

+			break;

+		case 8:

+			s = "\t.quad\t";

+			break;

+		default:

+			s = "\t.space\t%lu,";

+			break;

+		}

+	}

+	printf(s, tp->size);

+}

+

+

+void

+data(Node *np)

+{

+	size2asm(&np->type);

+	emittree(np);

+	putchar('\n');

+}

+

+static void

+label(Symbol *sym)

+{

+	int seg;

+	char *name = symname(sym);

+	Type *tp = &sym->type;

+

+	if (sym->type.flags & FUNF)

+		seg = CODESEG;

+	else if (sym->type.flags & INITF)

+		seg = DATASEG;

+	else

+		seg = BSSSEG;

+	segment(seg);

+

+	switch (sym->kind) {

+	case SEXTRN:

+		printf("\t.extern\t%s\n", name);

+	case SLOCAL:

+		return;

+	case SGLOB:

+		printf("\t.global\t%s\n", name);

+		if (seg == BSSSEG)

+			printf("\t.comm\t%s,%lu\n", name, tp->size);

+		break;

+	}

+	if (sym->type.align != 1)

+		printf("\t.align\t%lu\n", sym->type.align );

+	printf("%s:\n", name);

+}

+

+void

+defglobal(Symbol *sym)

+{

+	label(sym);

+	if (sym->kind == SEXTRN || (sym->type.flags & INITF))

+		return;

+	size2asm(&sym->type);

+	puts("0");

+}

+

+void

+defvar(Symbol *sym)

+{

+}

+

+void

+defpar(Symbol *sym)

+{

+}

+

+void

+newfun(void)

+{

+}

+

+void

+writeout(void)

+{

+}

+

+void

+endinit(void)

+{

+}

+

+void

+getbblocks(void)

+{

+}

--- /dev/null

+++ b/src/cmd/scc/cc2/target/amd64-sysv/optm.c

@@ -1,0 +1,11 @@

+static char sccsid[] = "@(#) ./cc2/arch/amd64-sysv/optm.c";

+

+#include <scc/scc.h>

+

+#include "../../cc2.h"

+

+Node *

+optm_dep(Node *np)

+{

+	return np;

+}

--- /dev/null

+++ b/src/cmd/scc/cc2/target/amd64-sysv/target.mk

@@ -1,0 +1,8 @@

+OBJ-amd64-sysv = $(OBJS)  \

+        target/amd64-sysv/cgen.o \

+        target/amd64-sysv/optm.o \

+        target/amd64-sysv/code.o \

+        target/amd64-sysv/types.o

+

+$(LIBEXEC)/cc2-amd64-sysv: $(OBJ-amd64-sysv)

+	$(CC) $(SCC_LDFLAGS) $(OBJ-amd64-sysv) -lscc -o $@

--- /dev/null

+++ b/src/cmd/scc/cc2/target/amd64-sysv/types.c

@@ -1,0 +1,94 @@

+static char sccsid[] = "@(#) ./cc2/arch/amd64-sysv/types.c";

+

+#include <scc/scc.h>

+

+#include "../../cc2.h"

+

+

+Type int8type = {

+	.flags  = SIGNF | INTF,

+	.size   = 1,

+	.align  = 1

+};

+

+Type int16type = {

+	.flags  = SIGNF | INTF,

+	.size   = 2,

+	.align  = 2

+};

+

+Type int32type = {

+	.flags  = SIGNF | INTF,

+	.size   = 4,

+	.align  = 4

+};

+

+Type int64type = {

+	.flags  = SIGNF | INTF,

+	.size   = 8,

+	.align  = 8

+};

+

+Type uint8type = {

+	.flags  = INTF,

+	.size   = 1,

+	.align  = 1

+};

+

+Type uint16type = {

+	.flags  = INTF,

+	.size   = 2,

+	.align  = 2

+};

+

+Type uint32type = {

+	.flags  = INTF,

+	.size   = 4,

+	.align  = 4

+};

+

+Type uint64type = {

+	.flags  = INTF,

+	.size   = 8,

+	.align  = 2

+};

+

+Type ptrtype = {

+	.flags  = INTF,

+	.size   = 8,

+	.align  = 8

+};

+

+Type booltype = {

+	.flags  = INTF,

+	.size   = 1,

+	.align  = 1

+};

+

+Type float32type = {

+	.flags  = FLOATF,

+	.size   = 4,

+	.align  = 4

+};

+

+Type float64type = {

+	.flags  = FLOATF,

+	.size   = 8,

+	.align  = 8

+};

+

+Type float80type = {

+	.flags  = FLOATF,

+	.size   = 16,

+	.align  = 16

+};

+

+Type voidtype = {

+	.size = 0,

+	.align = 0

+};

+

+Type arg_type = {

+	.size = 24,

+	.align = 8

+};

--- /dev/null

+++ b/src/cmd/scc/cc2/target/i386-sysv/cgen.c

@@ -1,0 +1,16 @@

+static char sccsid[] = "@(#) ./cc2/arch/i386-sysv/cgen.c";

+

+#include <scc/scc.h>

+

+#include "arch.h"

+#include "../../cc2.h"

+

+Node *

+cgen(Node *np)

+{

+}

+

+Node *

+sethi(Node *np)

+{

+}

--- /dev/null

+++ b/src/cmd/scc/cc2/target/i386-sysv/code.c

@@ -1,0 +1,209 @@

+static char sccsid[] = "@(#) ./cc2/arch/i386-sysv/code.c";

+#include <stdio.h>

+#include <stdlib.h>

+

+#include <scc/cstd.h>

+#include <scc/scc.h>

+

+#include "arch.h"

+#include "../../cc2.h"

+

+enum segment {

+	CODESEG,

+	DATASEG,

+	BSSSEG,

+	NOSEG

+};

+

+static int curseg = NOSEG;

+

+static void

+segment(int seg)

+{

+	static char *txt[] = {

+		[CODESEG] = "\t.text\n",

+		[DATASEG] = "\t.data\n",

+		[BSSSEG] = "\t.bss\n",

+	};

+

+	if (seg == curseg)

+		return;

+	fputs(txt[seg], stdout);

+	curseg = seg;

+}

+

+static char *

+symname(Symbol *sym)

+{

+	static char name[INTIDENTSIZ+1];

+

+	if (sym->name) {

+		switch (sym->kind) {

+		case SEXTRN:

+		case SGLOB:

+		case SPRIV:

+			return sym->name;

+		}

+	}

+

+	sprintf(name, ".L%d", sym->numid);

+

+	return name;

+}

+

+static void

+emitconst(Node *np)

+{

+	switch (np->type.size) {

+	case 1:

+		printf("%d", (int) np->u.i & 0xFF);

+		break;

+	case 2:

+		printf("%d", (int) np->u.i & 0xFFFF);

+		break;

+	case 4:

+		printf("%ld", (long) np->u.i & 0xFFFFFFFF);

+		break;

+	case 8:

+		printf("%lld", (long long) np->u.i & 0xFFFFFFFF);

+		break;

+	default:

+		abort();

+	}

+}

+

+static void

+emittree(Node *np)

+{

+	if (!np)

+		return;

+

+	switch (np->op) {

+	case OSTRING:

+		printf("\"%s\"", np->u.s);

+		free(np->u.s);

+		np->u.s = NULL;

+		break;

+	case OCONST:

+		emitconst(np);

+		break;

+	case OADDR:

+		emittree(np->left);

+		break;

+	case OMEM:

+		fputs(symname(np->u.sym), stdout);

+		break;

+	default:

+		emittree(np->left);

+		printf(" %c ", np->op);

+		emittree(np->right);

+		break;

+	}

+}

+static void

+size2asm(Type *tp)

+{

+	char *s;

+

+	if (tp->flags & STRF) {

+		s = "\t.ascii\t";

+	} else {

+		switch (tp->size) {

+		case 1:

+			s = "\t.byte\t";

+			break;

+		case 2:

+			s = "\t.short\t";

+			break;

+		case 4:

+			s = "\t.long\t";

+			break;

+		case 8:

+			s = "\t.quad\t";

+			break;

+		default:

+			s = "\t.space\t%lu,";

+			break;

+		}

+	}

+	printf(s, tp->size);

+}

+

+void

+data(Node *np)

+{

+	size2asm(&np->type);

+	emittree(np);

+	putchar('\n');

+}

+

+static void

+label(Symbol *sym)

+{

+	int seg;

+	char *name = symname(sym);

+	Type *tp = &sym->type;

+

+	if (sym->type.flags & FUNF)

+		seg = CODESEG;

+	else if (sym->type.flags & INITF)

+		seg = DATASEG;

+	else

+		seg = BSSSEG;

+	segment(seg);

+

+	switch (sym->kind) {

+	case SEXTRN:

+		printf("\t.extern\t%s\n", name);

+	case SLOCAL:

+		return;

+	case SGLOB:

+		printf("\t.global\t%s\n", name);

+		if (seg == BSSSEG)

+			printf("\t.comm\t%s,%lu\n", name, tp->size);

+		break;

+	}

+	if (sym->type.align != 1)

+		printf("\t.align\t%lu\n", sym->type.align );

+	printf("%s:\n", name);

+}

+

+void

+defglobal(Symbol *sym)

+{

+	label(sym);

+	if (sym->kind == SEXTRN || (sym->type.flags & INITF))

+		return;

+	size2asm(&sym->type);

+	puts("0");

+}

+

+void

+defpar(Symbol *sym)

+{

+}

+

+void

+defvar(Symbol *sym)

+{

+}

+

+void

+newfun(void)

+{

+}

+

+void

+writeout(void)

+{

+}

+

+void

+endinit(void)

+{

+}

+

+void

+getbblocks(void)

+{

+}

--- /dev/null

+++ b/src/cmd/scc/cc2/target/i386-sysv/optm.c

@@ -1,0 +1,11 @@

+static char sccsid[] = "@(#) ./cc2/arch/i386-sysv/optm.c";

+

+#include <scc/scc.h>

+

+#include "../../cc2.h"

+

+Node *

+optm_dep(Node *np)

+{

+	return np;

+}

--- /dev/null

+++ b/src/cmd/scc/cc2/target/i386-sysv/target.mk

@@ -1,0 +1,8 @@

+OBJ-i386-sysv = $(OBJS)  \

+        target/i386-sysv/cgen.o \

+        target/i386-sysv/optm.o \

+        target/i386-sysv/code.o \

+        target/i386-sysv/types.o

+

+$(LIBEXEC)/cc2-i386-sysv: $(OBJ-i386-sysv)

+	$(CC) $(SCC_LDFLAGS) $(OBJ-i386-sysv) -lscc -o $@

--- /dev/null

+++ b/src/cmd/scc/cc2/target/i386-sysv/types.c

@@ -1,0 +1,95 @@

+static char sccsid[] = "@(#) ./cc2/arch/i386-sysv/types.c";

+

+#include <scc/scc.h>

+

+#include "../../cc2.h"

+

+

+Type int8type = {

+	.flags  = SIGNF | INTF,

+	.size   = 1,

+	.align  = 1

+};

+

+Type int16type = {

+	.flags  = SIGNF | INTF,

+	.size   = 2,

+	.align  = 2

+};

+

+Type int32type = {

+	.flags  = SIGNF | INTF,

+	.size   = 4,

+	.align  = 4

+};

+

+Type int64type = {

+	.flags  = SIGNF | INTF,

+	.size   = 8,

+	.align  = 4

+};

+

+Type uint8type = {

+	.flags  = INTF,

+	.size   = 1,

+	.align  = 1

+};

+

+Type uint16type = {

+	.flags  = INTF,

+	.size   = 2,

+	.align  = 2

+};

+

+Type uint32type = {

+	.flags  = INTF,

+	.size   = 4,

+	.align  = 2

+};

+

+Type uint64type = {

+	.flags  = INTF,

+	.size   = 8,

+	.align  = 4

+};

+

+Type ptrtype = {

+	.flags  = INTF,

+	.size   = 4,

+	.align  = 4

+};

+

+Type booltype = {

+	.flags  = INTF,

+	.size   = 1,

+	.align  = 1

+};

+

+Type float32type = {

+	.flags  = FLOATF,

+	.size   = 4,

+	.align  = 4

+};

+

+Type float64type = {

+	.flags  = FLOATF,

+	.size   = 8,

+	.align  = 4

+};

+

+Type float80type = {

+	.flags  = FLOATF,

+	.size   = 12,

+	.align  =  4

+};

+

+Type voidtype = {

+	.size = 0,

+	.align = 0

+};

+

+/* this type is not used in this architecture */

+Type arg_type = {

+        .size = 0,

+        .align = 0

+};

--- /dev/null

+++ b/src/cmd/scc/cc2/target/qbe/arch.h

@@ -1,0 +1,135 @@

+enum asmop {

+	ASNOP = 0,

+	ASSTB,

+	ASSTH,

+	ASSTW,

+	ASSTL,

+	ASSTM,

+	ASSTS,

+	ASSTD,

+

+	ASLDSB,

+	ASLDUB,

+	ASLDSH,

+	ASLDUH,

+	ASLDSW,

+	ASLDUW,

+	ASLDL,

+	ASLDS,

+	ASLDD,

+

+	ASADDW,

+	ASSUBW,

+	ASMULW,

+	ASMODW,

+	ASUMODW,

+	ASDIVW,

+	ASUDIVW,

+	ASSHLW,

+	ASSHRW,

+	ASUSHRW,

+	ASLTW,

+	ASULTW,

+	ASGTW,

+	ASUGTW,

+	ASLEW,

+	ASULEW,

+	ASGEW,

+	ASUGEW,

+	ASEQW,

+	ASNEW,

+	ASBANDW,

+	ASBORW,

+	ASBXORW,

+

+	ASADDL,

+	ASSUBL,

+	ASMULL,

+	ASMODL,

+	ASUMODL,

+	ASDIVL,

+	ASUDIVL,

+	ASSHLL,

+	ASSHRL,

+	ASUSHRL,

+	ASLTL,

+	ASULTL,

+	ASGTL,

+	ASUGTL,

+	ASLEL,

+	ASULEL,

+	ASGEL,

+	ASUGEL,

+	ASEQL,

+	ASNEL,

+	ASBANDL,

+	ASBORL,

+	ASBXORL,

+

+	ASADDS,

+	ASSUBS,

+	ASMULS,

+	ASDIVS,

+	ASLTS,

+	ASGTS,

+	ASLES,

+	ASGES,

+	ASEQS,

+	ASNES,

+

+	ASADDD,

+	ASSUBD,

+	ASMULD,

+	ASDIVD,

+	ASLTD,

+	ASGTD,

+	ASLED,

+	ASGED,

+	ASEQD,

+	ASNED,

+

+	ASEXTBW,

+	ASUEXTBW,

+	ASEXTBL,

+	ASUEXTBL,

+	ASEXTHW,

+	ASUEXTHW,

+	ASEXTHL,

+	ASUEXTHL,

+	ASEXTWL,

+	ASUEXTWL,

+

+	ASSTOL,

+	ASSTOW,

+	ASDTOL,

+	ASDTOW,

+

+	ASSWTOD,

+	ASSWTOS,

+	ASSLTOD,

+	ASSLTOS,

+

+	ASEXTS,

+	ASTRUNCD,

+

+	ASJMP,

+	ASBRANCH,

+	ASRET,

+	ASCALL,

+	ASCALLE,

+	ASCALLEX,

+	ASPAR,

+	ASPARE,

+	ASALLOC,

+	ASFORM,

+

+	ASCOPYB,

+	ASCOPYH,

+	ASCOPYW,

+	ASCOPYL,

+	ASCOPYS,

+	ASCOPYD,

+

+	ASVSTAR,

+	ASVARG,

+};

--- /dev/null

+++ b/src/cmd/scc/cc2/target/qbe/cgen.c

@@ -1,0 +1,729 @@

+static char sccsid[] = "@(#) ./cc2/arch/qbe/cgen.c";

+

+#include <assert.h>

+#include <stdlib.h>

+

+#include <scc/cstd.h>

+#include <scc/scc.h>

+

+#include "arch.h"

+#include "../../cc2.h"

+

+enum sflags {

+	ISTMP  = 1,

+	ISCONS = 2

+};

+

+static char opasmw[] = {

+	[OADD] = ASADDW,

+	[OSUB] = ASSUBW,

+	[OMUL] = ASMULW,

+	[OMOD] = ASMODW,

+	[ODIV] = ASDIVW,

+	[OSHL] = ASSHLW,

+	[OSHR] = ASSHRW,

+	[OLT] = ASLTW,

+	[OGT] = ASGTW,

+	[OLE] = ASLEW,

+	[OGE] = ASGEW,

+	[OEQ] = ASEQW,

+	[ONE] = ASNEW,

+	[OBAND] = ASBANDW,

+	[OBOR] = ASBORW,

+	[OBXOR] = ASBXORW,

+};

+

+static char opasml[] = {

+	[OADD] = ASADDL,

+	[OSUB] = ASSUBL,

+	[OMUL] = ASMULL,

+	[OMOD] = ASMODL,

+	[ODIV] = ASDIVL,

+	[OSHL] = ASSHLL,

+	[OSHR] = ASSHRL,

+	[OLT] = ASLTL,

+	[OGT] = ASGTL,

+	[OLE] = ASLEL,

+	[OGE] = ASGEL,

+	[OEQ] = ASEQL,

+	[ONE] = ASNEL,

+	[OBAND] = ASBANDL,

+	[OBOR] = ASBORL,

+	[OBXOR] = ASBXORL,

+};

+

+static char opasms[] = {

+	[OADD] = ASADDS,

+	[OSUB] = ASSUBS,

+	[OMUL] = ASMULS,

+	[ODIV] = ASDIVS,

+	[OLT] = ASLTS,

+	[OGT] = ASGTS,

+	[OLE] = ASLES,

+	[OGE] = ASGES,

+	[OEQ] = ASEQS,

+	[ONE] = ASNES,

+};

+static char opasmd[] = {

+	[OADD] = ASADDD,

+	[OSUB] = ASSUBD,

+	[OMUL] = ASMULD,

+	[ODIV] = ASDIVD,

+	[OLT] = ASLTD,

+	[OGT] = ASGTD,

+	[OLE] = ASLED,

+	[OGE] = ASGED,

+	[OEQ] = ASEQD,

+	[ONE] = ASNED,

+};

+

+extern Type int32type, uint32type, ptrtype;

+

+static Node *

+tmpnode(Node *np, Type *tp)

+{

+	char flags;

+	Symbol *sym;

+

+	if (!np)

+		np = node(OTMP);

+	sym = getsym(TMPSYM);

+	sym->type = np->type = *tp;

+	flags = tp->flags & ~(PARF|INITF);

+	sym->type.flags = np->type.flags = flags;

+	sym->kind = STMP;

+	np->left = np->right = NULL;

+	np->u.sym = sym;

+	np->op = OTMP;

+	np->flags |= ISTMP;

+	return np;

+}

+

+static Node *

+load(Type *tp, Node *np, Node *new)

+{

+	int op;

+	int flags = tp->flags;

+

+	if (flags & (AGGRF|FUNF)) {

+		*new = *np;

+		return new;

+	}

+	switch (tp->size) {

+	case 1:

+		op = ASLDSB;

+		break;

+	case 2:

+		op = ASLDSH;

+		break;

+	case 4:

+		op = (flags & FLOATF) ? ASLDS : ASLDSW;

+		break;

+	case 8:

+		op = (flags & FLOATF) ? ASLDD : ASLDL;

+		break;

+	default:

+		abort();

+	}

+	/*

+	 * unsigned version of operations are always +1 the

+	 * signed version

+	 */

+	if ((flags & (INTF|SIGNF)) == INTF && tp->size < 8)

+		++op;

+

+	code(op, tmpnode(new, tp), np, NULL);

+

+	return new;

+}

+

+static Node *rhs(Node *np, Node *new);

+

+static Node *

+cast(Type *td, Node *ns, Node *nd)

+{

+	Type *ts;

+	Node aux1, aux2;

+	int op, d_isint, s_isint;

+

+	ts = &ns->type;

+	d_isint = (td->flags & INTF) != 0;

+	s_isint = (ts->flags & INTF) != 0;

+

+	if (d_isint && s_isint) {

+		if (td->size <= ts->size) {

+			*nd = *ns;

+			return nd;

+		}

+		assert(td->size == 4 || td->size == 8);

+		switch (ts->size) {

+		case 1:

+			op = (td->size == 4) ? ASEXTBW : ASEXTBL;

+			break;

+		case 2:

+			op = (td->size == 4) ? ASEXTHW : ASEXTHL;

+			break;

+		case 4:

+			op = ASEXTWL;

+			break;

+		default:

+			abort();

+		}

+		/*

+		 * unsigned version of operations are always +1 the

+		 * signed version

+		 */

+		op += (ts->flags & SIGNF) == 0;

+	} else if (d_isint) {

+		/* conversion from float to int */

+		switch (ts->size) {

+		case 4:

+			op = (td->size == 8) ? ASSTOL : ASSTOW;

+			break;

+		case 8:

+			op = (td->size == 8) ? ASDTOL : ASDTOW;

+			break;

+		default:

+			abort();

+		}

+		/* TODO: Add signess */

+	} else if (s_isint) {

+		/* conversion from int to float */

+		switch (ts->size) {

+		case 1:

+		case 2:

+			ts = (ts->flags&SIGNF) ? &int32type : &uint32type;

+			ns = cast(ts, ns, tmpnode(&aux2, ts));

+		case 4:

+			op = (td->size == 8) ? ASSWTOD : ASSWTOS;

+			break;

+		case 8:

+			op = (td->size == 8) ? ASSLTOD : ASSLTOS;

+			break;

+		default:

+			abort();

+		}

+		/* TODO: Add signess */

+	} else {

+		/* conversion from float to float */

+		op = (td->size == 4) ? ASEXTS : ASTRUNCD;

+	}

+

+	code(op, tmpnode(nd, td), ns, NULL);

+	return nd;

+}

+

+static Node *

+call(Node *np, Node *fun, Node *ret)

+{

+	int n, op;

+	Type *tp;

+	Node aux, **q, *p, *pars[NR_FUNPARAM];

+

+	for (n = 0, p = np->right; p; p = p->right)

+		pars[n++] = rhs(p->left, node(OTMP));

+

+	tp = &np->type;

+	code(ASCALL, tmpnode(ret, tp), fun, NULL);

+

+	for (q = pars; q < &pars[n]; ++q) {

+		op = (q == &pars[n-1]) ? ASPARE : ASPAR;

+		tmpnode(&aux, &(*q)->type);

+		code(op, NULL, *q, &aux);

+	}

+	code((np->op == OCALL) ? ASCALLE : ASCALLEX, NULL, NULL, NULL);

+

+	return ret;

+}

+

+static Node *

+assign(Type *tp, Node *to, Node *from)

+{

+	int op;

+

+	switch (tp->size) {

+	case 1:

+		op = ASSTB;

+		break;

+	case 2:

+		op = ASSTH;

+		break;

+	case 4:

+		op = (tp->flags & FLOATF) ? ASSTS : ASSTW;

+		break;

+	case 8:

+		op = (tp->flags & FLOATF) ? ASSTD : ASSTL;

+		break;

+	default:

+		op = ASSTM;

+		break;

+	}

+	code(op, to, from, NULL);

+	return from;

+}

+

+static Node *

+copy(Type *tp, Node *to, Node *from)

+{

+	int op;

+

+	switch (tp->size) {

+	case 1:

+		op = ASCOPYB;

+		break;

+	case 2:

+		op = ASCOPYH;

+		break;

+	case 4:

+		op = (tp->flags & FLOATF) ? ASCOPYS : ASCOPYW;

+		break;

+	case 8:

+		op = (tp->flags & FLOATF) ? ASCOPYD : ASCOPYL;

+		break;

+	default:

+		/* TODO: Need to handle the general case */

+		abort();

+	}

+	code(op, to, from, NULL);

+	return from;

+}

+

+/* TODO: Do field() transformation in sethi */

+

+static Node *

+field(Node *np, Node *ret, int islhs)

+{

+	Node base, node, off, add, *addr;

+	TUINT offset = np->right->u.sym->u.off;

+

+	addr = rhs(np->left, &base);

+

+	if (offset != 0) {

+		node.op = OADD;

+		node.type = ptrtype;

+		node.left = addr;

+		node.right = constnode(&off, offset, &ptrtype);

+		addr = rhs(&node, &add);

+	}

+

+	if (islhs)

+		*ret = *addr;

+	else

+		load(&np->type, addr, ret);

+

+	return ret;

+}

+

+static Node *

+lhs(Node *np, Node *new)

+{

+	switch (np->op) {

+	case OMEM:

+	case OAUTO:

+		*new = *np;

+		return new;

+	case OPTR:

+		return rhs(np->left, new);

+	case OFIELD:

+		return field(np, new, 1);

+	default:

+		abort();

+	}

+}

+

+static void

+bool(Node *np, Symbol *true, Symbol *false)

+{

+	Node *l = np->left, *r = np->right;

+	Node ret, ifyes, ifno;

+	Symbol *label;

+

+	switch (np->op) {

+	case ONEG:

+		bool(l, false, true);

+		break;

+	case OAND:

+		label = newlabel();

+		bool(l, label, false);

+		setlabel(label);

+		bool(r, true, false);

+		break;

+	case OOR:

+		label = newlabel();

+		bool(l, true, label);

+		setlabel(label);

+		bool(r, true, false);

+		break;

+	default:

+		label2node(&ifyes, true);

+		label2node(&ifno, false);

+		code(ASBRANCH, rhs(np, &ret), &ifyes, &ifno);

+		break;

+	}

+}

+

+static Node *

+ternary(Node *np, Node *ret)

+{

+	Node ifyes, ifno, phi, *colon, aux1, aux2, aux3;

+

+	tmpnode(ret, &np->type);

+	label2node(&ifyes, NULL);

+	label2node(&ifno, NULL);

+	label2node(&phi, NULL);

+

+	colon = np->right;

+	code(ASBRANCH, rhs(np->left, &aux1), &ifyes, &ifno);

+

+	setlabel(ifyes.u.sym);

+	copy(&ret->type, ret, rhs(colon->left, &aux2));

+	code(ASJMP, NULL, &phi, NULL);

+

+	setlabel(ifno.u.sym);

+	copy(&ret->type, ret, rhs(colon->right, &aux3));

+	setlabel(phi.u.sym);

+

+	return ret;

+}

+

+static Node *

+function(void)

+{

+	Node aux;

+	Symbol *p;

+

+	/* allocate stack space for parameters */

+	for (p = locals; p && (p->type.flags & PARF) != 0; p = p->next)

+		code(ASALLOC, label2node(&aux, p), NULL, NULL);

+

+	/* allocate stack space for local variables) */

+	for ( ; p && p->id != TMPSYM; p = p->next) {

+		if (p->kind != SAUTO)

+			continue;

+		code(ASALLOC, label2node(&aux, p), NULL, NULL);

+	}

+	/* store formal parameters in parameters */

+	for (p = locals; p; p = p->next) {

+		if ((p->type.flags & PARF) == 0)

+			break;

+		code(ASFORM, label2node(&aux, p), NULL, NULL);

+	}

+	return NULL;

+}

+

+static void

+swtch_if(Node *idx)

+{

+	Node aux1, aux2, *np;

+	Symbol *deflabel = NULL;

+

+	for (;;) {

+		np = delstmt();

+		setlabel(np->label);

+

+		switch (np->op) {

+		case OESWITCH:

+			if (!deflabel)

+				deflabel = np->u.sym;

+			aux1.op = OJMP;

+			aux1.label = NULL;

+			aux1.u.sym = deflabel;

+			cgen(&aux1);

+			return;

+		case OCASE:

+			aux1 = *np;

+			aux1.op = OBRANCH;

+			aux1.label = NULL;

+			aux1.left = &aux2;

+

+			aux2.op = OEQ;

+			aux2.type = idx->type;

+			aux2.left = np->left;

+			aux2.right = idx;

+

+			cgen(&aux1);

+			break;

+		case ODEFAULT:

+			deflabel = np->u.sym;

+			break;

+		default:

+			abort();

+		}

+	}

+}

+

+static Node *

+rhs(Node *np, Node *ret)

+{

+	Node aux1, aux2, *phi, *l = np->left, *r = np->right;

+	Type *tp;

+	int off, op;

+	char *tbl;

+	Symbol *true, *false;

+

+	tp = &np->type;

+

+	switch (np->op) {

+	case OBFUN:

+		return function();

+	case ONOP:

+	case OBLOOP:

+	case OELOOP:

+	case OEFUN:

+		return NULL;

+	case OTMP:

+	case OCONST:

+		*ret = *np;

+		return np;

+	case OMEM:

+	case OAUTO:

+		return load(tp, np, ret);

+	case ONEG:

+	case OAND:

+	case OOR:

+		true = newlabel();

+		false = newlabel();

+		phi = label2node(&aux1, NULL);

+		tmpnode(ret, &int32type);

+

+		bool(np, true, false);

+

+		setlabel(true);

+		code(ASCOPYW, ret, constnode(&aux2, 1, &int32type), NULL);

+		code(ASJMP, NULL, phi, NULL);

+

+		setlabel(false);

+		code(ASCOPYW, ret, constnode(&aux2, 0, &int32type), NULL);

+

+		setlabel(phi->u.sym);

+		return ret;

+        case OMOD:

+        case OSHR:

+		assert(tp->flags & INTF);

+        case ODIV:

+        case OLT:

+        case OGT:

+        case OLE:

+        case OGE:

+                /*

+                 * unsigned version of operations are always +1 the

+                 * signed version

+                 */

+                off = (tp->flags & SIGNF) == 0;

+                goto binary;

+        case OSHL:

+        case OBAND:

+        case OBOR:

+        case OBXOR:

+		assert(tp->flags & INTF);

+        case OADD:

+        case OSUB:

+        case OMUL:

+        case OEQ:

+        case ONE:

+                off = 0;

+        binary:

+		if (l->complex >= r->complex) {

+			rhs(l, &aux1);

+			rhs(r, &aux2);

+		} else {

+			rhs(r, &aux2);

+			rhs(l, &aux1);

+		}

+                switch (tp->size) {

+                case 4:

+                        tbl = (tp->flags & FLOATF) ? opasms : opasmw;

+                        break;

+                case 8:

+                        tbl = (tp->flags & FLOATF) ? opasmd : opasml;

+                        break;

+                default:

+                        abort();

+                }

+                op = tbl[np->op] + off;

+		tmpnode(ret, tp);

+                code(op, ret, &aux1, &aux2);

+                return ret;

+	case OCALL:

+	case OCALLE:

+		if (l->op == OPTR)

+			l = rhs(l, &aux1);

+		return call(np, l, ret);

+	case OCAST:

+		return cast(tp, rhs(l, &aux1), ret);

+	case OASSIG:

+		/* TODO: Do this transformations in sethi */

+		switch (np->u.subop) {

+		case OINC:

+			op = OADD;

+			goto post_oper;

+		case ODEC:

+			op = OSUB;

+		post_oper:

+			aux1.op = op;

+			aux1.left = rhs(l, ret);

+			aux1.right = r;

+			aux1.type = np->type;

+			rhs(&aux1, &aux2);

+			lhs(l, &aux1);

+			assign(tp, &aux1, &aux2);

+			break;

+		default:

+			aux2.type = np->type;

+			aux2.op = np->u.subop;

+			aux2.right = np->right;

+			aux2.left = np->left;

+			r = rhs(&aux2, &aux1);

+			Node aux3;

+			if (l->op == OCAST) {

+				aux3.type = l->left->type;

+				aux3.op = OCAST;

+				aux3.left = r;

+				aux3.right = NULL;

+				r = &aux3;

+				l = l->left;

+			}

+		case 0:

+			/* TODO: see what is the most difficult */

+			lhs(l, &aux2);

+			rhs(r, ret);

+			return assign(tp, &aux2, ret);

+		}

+		return ret;

+	case OASK:

+		return ternary(np, ret);

+	case OCOMMA:

+		rhs(l, &aux1);

+		return rhs(r, ret);

+	case OPTR:

+		return load(tp, rhs(l, &aux1), ret);

+	case OADDR:

+		lhs(l, ret);

+		ret->type = *tp;

+		return ret;

+	case OFIELD:

+		return field(np, ret, 0);

+	case OBUILTIN:

+		switch (np->u.subop) {

+		case BVA_START:

+			l = rhs(l, &aux1);

+			code(ASVSTAR, NULL, l, NULL);

+			return NULL;

+		case BVA_END:

+			return NULL;

+		case BVA_ARG:

+			l = rhs(l, &aux1);

+			code(ASVARG, tmpnode(ret, tp), l, NULL);

+			return ret;

+		case BVA_COPY:

+			/* TODO */

+		default:

+			abort();

+		}

+	default:

+		abort();

+	}

+	abort();

+}

+

+Node *

+cgen(Node *np)

+{

+	Node aux, *p, *next;

+

+	setlabel(np->label);

+	switch (np->op) {

+	case OJMP:

+		label2node(&aux, np->u.sym);

+		code(ASJMP, NULL, &aux, NULL);

+		break;

+	case OBRANCH:

+		next = np->next;

+		if (!next->label)

+			next->label = newlabel();

+		bool(np->left, np->u.sym, next->label);

+		break;

+	case ORET:

+		p = (np->left) ? rhs(np->left, &aux) : NULL;

+		code(ASRET, NULL, p, NULL);

+		break;

+	case OBSWITCH:

+		p = rhs(np->left, &aux);

+		swtch_if(p);

+		break;

+	default:

+		rhs(np, &aux);

+		break;

+	}

+	return NULL;

+}

+

+/*

+ * This is strongly influenced by

+ * http://plan9.bell-labs.com/sys/doc/compiler.ps (/sys/doc/compiler.ps)

+ * calculate addresability as follows

+ *     AUTO => 11          value+fp

+ *     REG => 11           reg

+ *     STATIC => 11        (value)

+ *     CONST => 11         $value

+ * These values of addressability are not used in the code generation.

+ * They are only used to calculate the Sethi-Ullman numbers. Since

+ * QBE is AMD64 targered we could do a better job there, and try to

+ * detect some of the complex addressing modes of these processors.

+ */

+Node *

+sethi(Node *np)

+{

+	Node *lp, *rp;

+

+	if (!np)

+		return np;

+

+	np->complex = 0;

+	np->address = 0;

+	lp = np->left;

+	rp = np->right;

+

+	switch (np->op) {

+	case OAUTO:

+	case OREG:

+	case OMEM:

+	case OCONST:

+		np->address = 11;

+		break;

+	case OCPL:

+		assert(np->type.flags & INTF);

+		np->op = OBXOR;

+		rp = constnode(NULL, ~(TUINT) 0, &np->type);

+		goto binary;

+	case OSNEG:

+		np->op = OSUB;

+		rp = lp;

+		lp = constnode(NULL, 0, &np->type);

+		if ((np->type.flags & INTF) == 0)

+			lp->u.f = 0.0;

+	default:

+	binary:

+		lp = sethi(lp);

+		rp = sethi(rp);

+		break;

+	}

+	np->left = lp;

+	np->right = rp;

+

+	if (np->address > 10)

+		return np;

+	if (lp)

+		np->complex = lp->complex;

+	if (rp) {

+		int d = np->complex - rp->complex;

+

+		if (d == 0)

+			++np->complex;

+		else if (d < 0)

+			np->complex = rp->complex;

+	}

+	if (np->complex == 0)

+		++np->complex;

+	return np;

+}

--- /dev/null

+++ b/src/cmd/scc/cc2/target/qbe/code.c

@@ -1,0 +1,569 @@

+static char sccsid[] = "@(#) ./cc2/arch/qbe/code.c";

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+

+#include <scc/cstd.h>

+#include <scc/scc.h>

+

+#include "arch.h"

+#include "../../cc2.h"

+

+#define ADDR_LEN (INTIDENTSIZ+64)

+

+static void binary(void), unary(void), store(void), jmp(void), ret(void),

+            branch(void), call(void), ecall(void), param(void),

+            asalloc(void), form2local(void), ldir(void), vastart(void),

+            vaarg(void);

+

+static struct opdata {

+	void (*fun)(void);

+	char *txt;

+	char letter;

+} optbl [] = {

+	[ASLDSB]  =  {.fun = unary,  .txt = "loadsb", .letter = 'w'},

+	[ASLDUB]  =  {.fun = unary,  .txt = "loadub", .letter = 'w'},

+	[ASLDSH]  =  {.fun = unary,  .txt = "loadsh", .letter = 'w'},

+	[ASLDUH]  =  {.fun = unary,  .txt = "loaduh", .letter = 'w'},

+	[ASLDSW]  =  {.fun = unary,  .txt = "loadsw", .letter = 'w'},

+	[ASLDUW]  =  {.fun = unary,  .txt = "loaduw", .letter = 'w'},

+	[ASLDL]   =  {.fun = unary,  .txt = "loadl", .letter = 'l'},

+	[ASLDS]   =  {.fun = unary,  .txt = "loads", .letter = 's'},

+	[ASLDD]   =  {.fun = unary,  .txt = "loadd", .letter = 'd'},

+

+	[ASCOPYB] =  {.fun = unary,  .txt = "copy", .letter = 'b'},

+	[ASCOPYH] =  {.fun = unary,  .txt = "copy", .letter = 'h'},

+	[ASCOPYW] =  {.fun = unary,  .txt = "copy", .letter = 'w'},

+	[ASCOPYL] =  {.fun = unary,  .txt = "copy", .letter = 'l'},

+	[ASCOPYS] =  {.fun = unary,  .txt = "copy", .letter = 's'},

+	[ASCOPYD] =  {.fun = unary,  .txt = "copy", .letter = 'd'},

+

+	[ASSTB]   =  {.fun = store,  .txt = "store", .letter = 'b'},

+	[ASSTH]   =  {.fun = store,  .txt = "store", .letter = 'h'},

+	[ASSTW]   =  {.fun = store,  .txt = "store", .letter = 'w'},

+	[ASSTL]   =  {.fun = store,  .txt = "store", .letter = 'l'},

+	[ASSTM]   =  {.fun = ldir},

+	[ASSTS]   =  {.fun = store,  .txt = "store", .letter = 's'},

+	[ASSTD]   =  {.fun = store,  .txt = "store", .letter = 'd'},

+

+	[ASADDW]  =  {.fun = binary, .txt = "add", .letter = 'w'},

+	[ASSUBW]  =  {.fun = binary, .txt = "sub", .letter = 'w'},

+	[ASMULW]  =  {.fun = binary, .txt = "mul", .letter = 'w'},

+	[ASMODW]  =  {.fun = binary, .txt = "rem", .letter = 'w'},

+	[ASUMODW] =  {.fun = binary, .txt = "urem", .letter = 'w'},

+	[ASDIVW]  =  {.fun = binary, .txt = "div", .letter = 'w'},

+	[ASUDIVW] =  {.fun = binary, .txt = "udiv", .letter = 'w'},

+	[ASSHLW]  =  {.fun = binary, .txt = "shl", .letter = 'w'},

+	[ASSHRW]  =  {.fun = binary, .txt = "sar", .letter = 'w'},

+	[ASUSHRW] =  {.fun = binary, .txt = "shr", .letter = 'w'},

+	[ASLTW]   =  {.fun = binary, .txt = "csltw", .letter = 'w'},

+	[ASULTW]  =  {.fun = binary, .txt = "cultw", .letter = 'w'},

+	[ASGTW]   =  {.fun = binary, .txt = "csgtw", .letter = 'w'},

+	[ASUGTW]  =  {.fun = binary, .txt = "cugtw", .letter = 'w'},

+	[ASLEW]   =  {.fun = binary, .txt = "cslew", .letter = 'w'},

+	[ASULEW]  =  {.fun = binary, .txt = "culew", .letter = 'w'},

+	[ASGEW]   =  {.fun = binary, .txt = "csgew", .letter = 'w'},

+	[ASUGEW]  =  {.fun = binary, .txt = "cugew", .letter = 'w'},

+	[ASEQW]   =  {.fun = binary, .txt = "ceqw", .letter = 'w'},

+	[ASNEW]   =  {.fun = binary, .txt = "cnew", .letter = 'w'},

+	[ASBANDW] =  {.fun = binary, .txt = "and", .letter = 'w'},

+	[ASBORW]  =  {.fun = binary, .txt = "or", .letter = 'w'},

+	[ASBXORW] =  {.fun = binary, .txt = "xor", .letter = 'w'},

+

+	[ASADDL]  =  {.fun = binary, .txt = "add", .letter = 'l'},

+	[ASSUBL]  =  {.fun = binary, .txt = "sub", .letter = 'l'},

+	[ASMULL]  =  {.fun = binary, .txt = "mul", .letter = 'l'},

+	[ASMODL]  =  {.fun = binary, .txt = "rem", .letter = 'l'},

+	[ASUMODL] =  {.fun = binary, .txt = "urem", .letter = 'l'},

+	[ASDIVL]  =  {.fun = binary, .txt = "div", .letter = 'l'},

+	[ASUDIVL] =  {.fun = binary, .txt = "udiv", .letter = 'l'},

+	[ASSHLL]  =  {.fun = binary, .txt = "shl", .letter = 'l'},

+	[ASSHRL]  =  {.fun = binary, .txt = "sar", .letter = 'l'},

+	[ASUSHRL] =  {.fun = binary, .txt = "shr", .letter = 'l'},

+	[ASLTL]   =  {.fun = binary, .txt = "csltl", .letter = 'w'},

+	[ASULTL]  =  {.fun = binary, .txt = "cultl", .letter = 'w'},

+	[ASGTL]   =  {.fun = binary, .txt = "csgtl", .letter = 'w'},

+	[ASUGTL]  =  {.fun = binary, .txt = "cugtl", .letter = 'w'},

+	[ASLEL]   =  {.fun = binary, .txt = "cslel", .letter = 'w'},

+	[ASULEL]  =  {.fun = binary, .txt = "culel", .letter = 'w'},

+	[ASGEL]   =  {.fun = binary, .txt = "csgel", .letter = 'w'},

+	[ASUGEL]  =  {.fun = binary, .txt = "cugel", .letter = 'w'},

+	[ASEQL]   =  {.fun = binary, .txt = "ceql", .letter = 'w'},

+	[ASNEL]   =  {.fun = binary, .txt = "cnel", .letter = 'w'},

+	[ASBANDL] =  {.fun = binary, .txt = "and", .letter = 'l'},

+	[ASBORL]  =  {.fun = binary, .txt = "or", .letter = 'l'},

+	[ASBXORL] =  {.fun = binary, .txt = "xor", .letter = 'l'},

+

+	[ASADDS]  =  {.fun = binary, .txt = "add", .letter = 's'},

+	[ASSUBS]  =  {.fun = binary, .txt = "sub", .letter = 's'},

+	[ASMULS]  =  {.fun = binary, .txt = "mul", .letter = 's'},

+	[ASDIVS]  =  {.fun = binary, .txt = "div", .letter = 's'},

+	[ASLTS]   =  {.fun = binary, .txt = "clts", .letter = 'w'},

+	[ASGTS]   =  {.fun = binary, .txt = "cgts", .letter = 'w'},

+	[ASLES]   =  {.fun = binary, .txt = "cles", .letter = 'w'},

+	[ASGES]   =  {.fun = binary, .txt = "cges", .letter = 'w'},

+	[ASEQS]   =  {.fun = binary, .txt = "ceqs", .letter = 'w'},

+	[ASNES]   =  {.fun = binary, .txt = "cnes", .letter = 'w'},

+

+	[ASADDD]  =  {.fun = binary, .txt = "add", .letter = 'd'},

+	[ASSUBD]  =  {.fun = binary, .txt = "sub", .letter = 'd'},

+	[ASMULD]  =  {.fun = binary, .txt = "mul", .letter = 'd'},

+	[ASDIVD]  =  {.fun = binary, .txt = "div", .letter = 'd'},

+	[ASLTD]   =  {.fun = binary, .txt = "cltd", .letter = 'w'},

+	[ASGTD]   =  {.fun = binary, .txt = "cgtd", .letter = 'w'},

+	[ASLED]   =  {.fun = binary, .txt = "cled", .letter = 'w'},

+	[ASGED]   =  {.fun = binary, .txt = "cged", .letter = 'w'},

+	[ASEQD]   =  {.fun = binary, .txt = "ceqd", .letter = 'w'},

+	[ASNED]   =  {.fun = binary, .txt = "cned", .letter = 'w'},

+

+	[ASEXTBW] =  {.fun = unary, .txt = "extsb", .letter = 'w'},

+	[ASUEXTBW]=  {.fun = unary, .txt = "extub", .letter = 'w'},

+	[ASEXTBL] =  {.fun = unary, .txt = "extsb", .letter = 'l'},

+	[ASUEXTBL]=  {.fun = unary, .txt = "extub", .letter = 'l'},

+	[ASEXTHW] =  {.fun = unary, .txt = "extsh", .letter = 'w'},

+	[ASUEXTHW]=  {.fun = unary, .txt = "extuh", .letter = 'w'},

+	[ASEXTWL] =  {.fun = unary, .txt = "extsw", .letter = 'l'},

+	[ASUEXTWL]=  {.fun = unary, .txt = "extuw", .letter = 'l'},

+

+	[ASSTOL] = {.fun = unary, .txt = "stosi", .letter = 'l'},

+	[ASSTOW] = {.fun = unary, .txt = "stosi", .letter = 'w'},

+	[ASDTOL] = {.fun = unary, .txt = "dtosi", .letter = 'l'},

+	[ASDTOW] = {.fun = unary, .txt = "dtosi", .letter = 'w'},

+

+	[ASSWTOD] = {.fun = unary, .txt = "swtof", .letter = 'd'},

+	[ASSWTOS] = {.fun = unary, .txt = "swtof", .letter = 's'},

+	[ASSLTOD] = {.fun = unary, .txt = "sltof", .letter = 'd'},

+	[ASSLTOS] = {.fun = unary, .txt = "sltof", .letter = 's'},

+

+	[ASEXTS] = {.fun = unary, .txt = "exts", .letter = 'd'},

+	[ASTRUNCD] = {.fun = unary, .txt = "truncd", .letter = 's'},

+

+	[ASBRANCH] = {.fun = branch},

+	[ASJMP]  = {.fun = jmp},

+	[ASRET]  = {.fun = ret},

+	[ASCALL] = {.fun = call},

+	[ASCALLE] = {.fun = ecall, .txt = ")"},

+	[ASCALLEX] = {.fun = ecall, .txt = ", ...)"},

+	[ASPAR] = {.fun = param, .txt = "%s %s, "},

+	[ASPARE] = {.fun = param, .txt = "%s %s"},

+	[ASALLOC] = {.fun = asalloc},

+	[ASFORM] = {.fun = form2local},

+

+	[ASVSTAR] = {.fun = vastart},

+	[ASVARG] = {.fun = vaarg},

+};

+

+static char buff[ADDR_LEN];

+/*

+ * : is for user-defined Aggregate Types

+ * $ is for globals (represented by a pointer)

+ * % is for function-scope temporaries

+ * @ is for block labels

+ */

+static char

+sigil(Symbol *sym)

+{

+	switch (sym->kind) {

+	case SEXTRN:

+	case SGLOB:

+	case SPRIV:

+	case SLOCAL:

+		return '$';

+	case SAUTO:

+	case STMP:

+		return '%';

+	case SLABEL:

+		return '@';

+	default:

+		abort();

+	}

+}

+

+static char *

+symname(Symbol *sym)

+{

+	char c = sigil(sym);

+

+	if (sym->name) {

+		switch (sym->kind) {

+		case SEXTRN:

+		case SGLOB:

+			sprintf(buff, "%c%s", c, sym->name);

+			return buff;

+		case SLOCAL:

+		case SPRIV:

+		case SAUTO:

+			sprintf(buff, "%c%s.%u", c, sym->name, sym->id);

+			return buff;

+		default:

+			abort();

+		}

+	}

+	sprintf(buff, "%c.%u", c, sym->numid);

+

+	return buff;

+}

+

+static void

+emitconst(Node *np)

+{

+	switch (np->type.size) {

+	case 1:

+		printf("%d", (int) np->u.i & 0xFF);

+		break;

+	case 2:

+		printf("%d", (int) np->u.i & 0xFFFF);

+		break;

+	case 4:

+		printf("%ld", (long) np->u.i & 0xFFFFFFFF);

+		break;

+        case 8:

+                printf("%lld", (long long) np->u.i);

+                break;

+	default:

+		abort();

+	}

+}

+

+static void

+emittree(Node *np)

+{

+	if (!np)

+		return;

+

+	switch (np->op) {

+	case OSTRING:

+		printf("\"%s\"", np->u.s);

+		free(np->u.s);

+		np->u.s = NULL;

+		break;

+	case OCONST:

+		emitconst(np);

+		break;

+	case OADDR:

+		emittree(np->left);

+		break;

+	case OMEM:

+		fputs(symname(np->u.sym), stdout);

+		break;

+	default:

+		emittree(np->left);

+		printf(" %c ", np->op);

+		emittree(np->right);

+		break;

+	}

+}

+

+static char *

+size2asm(Type *tp)

+{

+	if (tp->flags & STRF) {

+		return "b";

+	} else if (tp->flags & INTF) {

+		switch (tp->size) {

+		case 1:

+			return "b";

+		case 2:

+			return "h";

+		case 4:

+			return "w";

+		case 8:

+			return "l";

+		}

+	} else if (tp->flags & FLOATF) {

+		if (tp->size == 4)

+			return "s";

+		else if (tp->size == 8)

+			return "d";

+	}

+	abort();

+}

+

+void

+defglobal(Symbol *sym)

+{

+	if (sym->kind == SEXTRN)

+		return;

+	if (sym->kind == SGLOB)

+		fputs("export ", stdout);

+	printf("data %s = {\n", symname(sym));

+	if (sym->type.flags & INITF)

+		return;

+	printf("\tz\t%lu\n}\n", sym->type.size);

+}

+

+void

+defpar(Symbol *sym)

+{

+	sym->type.flags |= PARF;

+}

+

+void

+defvar(Symbol *sym)

+{

+	if (sym->kind == SREG)

+		sym->kind = SAUTO;

+}

+

+void

+data(Node *np)

+{

+	printf("\t%s\t", size2asm(&np->type));

+	emittree(np);

+	putchar(',');

+	putchar('\n');

+}

+

+static char *

+size2stack(Type *tp)

+{

+	if (tp->flags & INTF) {

+		switch (tp->size) {

+		case 1:

+		case 2:

+		case 4:

+			return "w";

+		case 8:

+			return "l";

+		}

+	} else if (tp->flags & FLOATF) {

+		if (tp->size == 4)

+			return "s";

+		else if (tp->size == 8)

+			return "d";

+	} else if (tp->size == 0) {

+		return "w";

+	}

+	abort();

+}

+

+void

+writeout(void)

+{

+	Symbol *p;

+	Type *tp;

+	char *sep, *name;

+	int haslabel = 0;

+

+	if (!curfun)

+		return;

+	if (curfun->kind == SGLOB)

+		fputs("export ", stdout);

+	printf("function %s %s(", size2stack(&curfun->rtype), symname(curfun));

+

+	/* declare formal parameters */

+	for (sep = "", p = locals; p; p = p->next, sep = ",") {

+		if ((p->type.flags & PARF) == 0)

+			break;

+		printf("%s%s %s.val", sep, size2stack(&p->type), symname(p));

+	}

+	printf("%s)\n{\n", (curfun->type.flags&ELLIPS) ? ", ..." : "");

+

+	/* emit assembler instructions */

+	for (pc = prog; pc; pc = pc->next) {

+		if (pc->label) {

+			haslabel = 1;

+			printf("%s\n", symname(pc->label));

+		}

+		if (!pc->op)

+			continue;

+		if (pc->flags&BBENTRY && !haslabel)

+			printf("%s\n", symname(newlabel()));

+		(*optbl[pc->op].fun)();

+		if (!pc->label)

+			haslabel = 0;

+	}

+

+	puts("}");

+}

+

+static char *

+addr2txt(Addr *a)

+{

+	switch (a->kind) {

+	case SCONST:

+		sprintf(buff, "%llu", (unsigned long long) a->u.i);

+		return buff;

+	case SAUTO:

+	case SLABEL:

+	case STMP:

+	case SGLOB:

+	case SEXTRN:

+	case SPRIV:

+	case SLOCAL:

+		return symname(a->u.sym);

+	default:

+		abort();

+	}

+}

+

+static void

+binary(void)

+{

+	struct opdata *p = &optbl[pc->op];

+	char to[ADDR_LEN], from1[ADDR_LEN], from2[ADDR_LEN];

+

+	strcpy(to, addr2txt(&pc->to));

+	strcpy(from1, addr2txt(&pc->from1));

+	strcpy(from2, addr2txt(&pc->from2));

+	printf("\t%s =%c\t%s\t%s,%s\n", to, p->letter, p->txt, from1, from2);

+}

+

+static void

+ldir(void)

+{

+	struct opdata *p = &optbl[pc->op];

+	char to[ADDR_LEN], from[ADDR_LEN];

+	/* TODO: what type do we use for the size? */

+

+	/* TODO: it is pending */

+}

+

+static void

+store(void)

+{

+	struct opdata *p = &optbl[pc->op];

+	char to[ADDR_LEN], from[ADDR_LEN];

+

+	strcpy(to, addr2txt(&pc->to));

+	strcpy(from, addr2txt(&pc->from1));

+	printf("\t\t%s%c\t%s,%s\n", p->txt, p->letter, from, to);

+}

+

+static void

+unary(void)

+{

+	struct opdata *p = &optbl[pc->op];

+	char to[ADDR_LEN], from[ADDR_LEN];

+

+	strcpy(to, addr2txt(&pc->to));

+	strcpy(from, addr2txt(&pc->from1));

+	printf("\t%s =%c\t%s\t%s\n", to, p->letter, p->txt, from);

+}

+

+static void

+call(void)

+{

+	struct opdata *p = &optbl[pc->op];

+	char to[ADDR_LEN], from[ADDR_LEN];

+	Symbol *sym = pc->to.u.sym;

+

+	strcpy(to, addr2txt(&pc->to));

+	strcpy(from, addr2txt(&pc->from1));

+	printf("\t%s =%s\tcall\t%s(",

+	       to, size2stack(&sym->type), from);

+}

+

+static void

+param(void)

+{

+	Symbol *sym = pc->from2.u.sym;

+

+	printf(optbl[pc->op].txt,

+	       size2stack(&sym->type), addr2txt(&pc->from1));

+}

+

+static void

+ecall(void)

+{

+	struct opdata *p = &optbl[pc->op];

+

+	puts(p->txt);

+}

+

+static void

+ret(void)

+{

+	if (pc->from1.kind == SNONE)

+		puts("\t\tret");

+	else

+		printf("\t\tret\t%s\n", addr2txt(&pc->from1));

+}

+

+static void

+jmp(void)

+{

+	printf("\t\tjmp\t%s\n", addr2txt(&pc->from1));

+}

+

+static void

+branch(void)

+{

+	char to[ADDR_LEN], from1[ADDR_LEN], from2[ADDR_LEN];

+

+	strcpy(to, addr2txt(&pc->to));

+	strcpy(from1, addr2txt(&pc->from1));

+	strcpy(from2, addr2txt(&pc->from2));

+	printf("\t\tjnz\t%s,%s,%s\n", to, from1, from2);

+}

+

+static void

+vastart(void)

+{

+	printf("\t\tvastart %s\n", addr2txt(&pc->from1));

+}

+

+static void

+vaarg(void)

+{

+	Symbol *sym = pc->to.u.sym;

+	Type *tp = &sym->type;

+	char to[ADDR_LEN], from[ADDR_LEN];

+

+	strcpy(to, addr2txt(&pc->to));

+	strcpy(from, addr2txt(&pc->from1));

+	printf("\t\t%s =%s vaarg %s\n", to, size2asm(tp), from);

+}

+

+static void

+asalloc(void)

+{

+	Symbol *sym = pc->to.u.sym;

+	Type *tp = &sym->type;

+	extern Type ptrtype;

+

+	printf("\t%s =%s\talloc%lu\t%lu\n",

+	       symname(sym), size2asm(&ptrtype), tp->align+3 & ~3, tp->size);

+}

+

+static void

+form2local(void)

+{

+	Symbol *sym = pc->to.u.sym;

+	Type *tp = &sym->type;

+	char *name = symname(sym);

+

+	printf("\t\tstore%s\t%s.val,%s\n", size2asm(tp), name, name);

+}

+

+void

+endinit(void)

+{

+	puts("}");

+}

+

+void

+getbblocks(void)

+{

+	Inst *i;

+

+	if (!prog)

+		return;

+

+	prog->flags |= BBENTRY;

+	for (pc = prog; pc; pc = pc->next) {

+		switch (pc->op) {

+		case ASBRANCH:

+			i = pc->from2.u.sym->u.inst;

+			i->flags |= BBENTRY;

+		case ASJMP:

+			i = pc->from1.u.sym->u.inst;

+			i->flags |= BBENTRY;

+		case ASRET:

+			if (pc->next)

+				pc->next->flags |= BBENTRY;

+			break;

+		}

+	}

+}

--- /dev/null

+++ b/src/cmd/scc/cc2/target/qbe/optm.c

@@ -1,0 +1,58 @@

+static char sccsid[] = "@(#) ./cc2/arch/qbe/optm.c";

+

+#include <stddef.h>

+

+#include <scc/scc.h>

+

+#include "../../cc2.h"

+

+Node *

+optm_dep(Node *np)

+{

+	int op = np->op;

+	Node *p, *dst, *next = np->next;

+	Symbol *sym, *osym;

+

+	switch (op) {

+	case OEFUN:

+		/*

+		 * In QBE we need at the end of a basic block

+		 * a jump, so we have to ensure that the last

+		 * statement of the function is a ret, a jmp

+		 * or a branch. In the same way, QBE does

+		 * not accept labels at the end of a function

+		 * (ONOP is used for labels) so we have to add

+		 * a ret there, and in the case of branches

+		 * we need a label for the next statement

+		 */

+		op = (np->prev) ? np->prev->op : 0;

+		if (!op || op == ONOP || op == OBRANCH || (op != ORET && op != OJMP))

+			addstmt(node(ORET), KEEPCUR);

+		break;

+	case OBRANCH:

+		if (!next->label) {

+			sym = getsym(TMPSYM);

+			sym->kind = SLABEL;

+			next->label = sym;

+		}

+	case OJMP:

+		for (;;) {

+			dst = np->u.sym->u.stmt;

+			if (dst->op != OJMP)

+				break;

+			np->u.sym = dst->u.sym;

+		}

+		for (p = np->next; p; p = p->next) {

+			if (p == dst)

+				return NULL;

+			if (p->op == ONOP ||

+			    p->op == OBLOOP ||

+			    p->op == OELOOP) {

+				continue;

+			}

+			break;

+		}

+		break;

+	}

+	return np;

+}

--- /dev/null

+++ b/src/cmd/scc/cc2/target/qbe_amd64-sysv/target.mk

@@ -1,0 +1,8 @@

+OBJ-qbe_amd64-sysv = $(OBJS)  \

+        target/qbe/cgen.o \

+        target/qbe/optm.o \

+        target/qbe/code.o \

+        target/amd64-sysv/types.o

+

+$(LIBEXEC)/cc2-qbe_amd64-sysv: $(OBJ-qbe_amd64-sysv)

+	$(CC) $(SCC_LDFLAGS) $(OBJ-qbe_amd64-sysv) -lscc -o $@

--- /dev/null

+++ b/src/cmd/scc/cc2/target/qbe_arm64-sysv/target.mk

@@ -1,0 +1,5 @@

+OBJ-qbe_arm64-sysv = $(OBJS)  \

+        target/qbe/cgen.o \

+        target/qbe/optm.o \

+        target/qbe/code.o \

+        target/arm64-sysv/types.o \

--- /dev/null

+++ b/src/cmd/scc/cc2/target/z80-scc/arch.h

@@ -1,0 +1,5 @@

+enum asmop {

+	ASJMP = 0,

+	ASRET,

+	ASBRANCH,

+};

--- /dev/null

+++ b/src/cmd/scc/cc2/target/z80-scc/cgen.c

@@ -1,0 +1,161 @@

+static char sccsid[] = "@(#) ./cc2/arch/z80/cgen.c";

+

+#include <stdlib.h>

+

+#include <scc/scc.h>

+

+#include "arch.h"

+#include "../../cc2.h"

+

+static void

+swtch(Node *idx)

+{

+}

+

+static Node *

+rhs(Node *np, Node *ret)

+{

+}

+

+static Node *

+field(Node *np, Node *ret, int islhs)

+{

+}

+

+static Node *

+lhs(Node *np, Node *new)

+{

+	switch (np->op) {

+	case OMEM:

+	case OAUTO:

+		*new = *np;

+		return new;

+	case OPTR:

+		return rhs(np->left, new);

+	case OFIELD:

+		return field(np, new, 1);

+	default:

+		abort();

+	}

+}

+

+static void

+bool(Node *np, Symbol *true, Symbol *false)

+{

+	Node *l = np->left, *r = np->right;

+	Node ret, ifyes, ifno;

+	Symbol *label;

+

+	switch (np->op) {

+	case ONEG:

+		bool(l, false, true);

+		break;

+	case OAND:

+		label = newlabel();

+		bool(l, label, false);

+		setlabel(label);

+		bool(r, true, false);

+		break;

+	case OOR:

+		label = newlabel();

+		bool(l, true, label);

+		setlabel(label);

+		bool(r, true, false);

+		break;

+	default:

+		label2node(&ifyes, true);

+		label2node(&ifno, false);

+		code(ASBRANCH, rhs(np, &ret), &ifyes, &ifno);

+		break;

+	}

+}

+

+Node *

+cgen(Node *np)

+{

+	Node aux, *p, *next;

+

+	setlabel(np->label);

+	switch (np->op) {

+	case OJMP:

+		label2node(&aux, np->u.sym);

+		code(ASJMP, NULL, &aux, NULL);

+		break;

+	case OBRANCH:

+		next = np->next;

+		if (!next->label)

+			next->label = newlabel();

+		bool(np->left, np->u.sym, next->label);

+		break;

+	case ORET:

+		p = np->left;

+		if (p)

+			p = rhs(np->left, &aux);

+		code(ASRET, NULL, p, NULL);

+		break;

+	case OBSWITCH:

+		swtch(rhs(np->left, &aux));

+		break;

+	default:

+		rhs(np, &aux);

+		break;

+	}

+	return NULL;

+}

+

+/*

+ * This is strongly influenced by

+ * http://plan9.bell-labs.com/sys/doc/compiler.ps (/sys/doc/compiler.ps)

+ * calculate addresability as follows

+ *     AUTO => 11          value+fp

+ *     REG => 13           reg

+ *     STATIC => 12        (value)

+ *     CONST => 20         $value

+ */

+Node *

+sethi(Node *np)

+{

+	Node *lp, *rp;

+

+	if (!np)

+		return np;

+

+	np->complex = 0;

+	np->address = 0;

+	lp = np->left;

+	rp = np->right;

+	switch (np->op) {

+	case OAUTO:

+		np->address = 11;

+		break;

+	case OREG:

+		np->address = 13;

+		break;

+	case OMEM:

+		np->address = 12;

+		break;

+	case OCONST:

+		np->address = 20;

+		break;

+	default:

+		sethi(lp);

+		sethi(rp);

+		break;

+	}

+

+	if (np->address > 10)

+		return np;

+	if (lp)

+		np->complex = lp->complex;

+	if (rp) {

+		int d = np->complex - rp->complex;

+

+		if (d == 0)

+			++np->complex;

+		else if (d < 0)

+			np->complex = rp->complex;

+	}

+	if (np->complex == 0)

+		++np->complex;

+	return np;

+}

--- /dev/null

+++ b/src/cmd/scc/cc2/target/z80-scc/code.c

@@ -1,0 +1,229 @@

+static char sccsid[] = "@(#) ./cc2/arch/z80/code.c";

+

+#include <stdio.h>

+#include <stdlib.h>

+

+#include <scc/cstd.h>

+#include <scc/scc.h>

+

+#include "arch.h"

+#include "../../cc2.h"

+

+enum segment {

+	CODESEG,

+	DATASEG,

+	BSSSEG,

+	NOSEG

+};

+

+static int curseg = NOSEG;

+static unsigned long offpar, offvar;

+

+static void

+segment(int seg)

+{

+	static char *txt[] = {

+		[CODESEG] = "\tCSEG\n",

+		[DATASEG] = "\tDSEG\n",

+		[BSSSEG] = "\tASEG\n",

+	};

+

+	if (seg == curseg)

+		return;

+	fputs(txt[seg], stdout);

+	curseg = seg;

+}

+

+static char *

+symname(Symbol *sym)

+{

+	static char name[INTIDENTSIZ+1];

+

+	if (sym->name) {

+		switch (sym->kind) {

+		case SGLOB:

+		case SEXTRN:

+			snprintf(name, sizeof(name), "_%s", sym->name);

+			return name;

+		case SPRIV:

+			return sym->name;

+		}

+	}

+

+	sprintf(name, ".%d", sym->numid);

+

+	return name;

+}

+

+static void

+label(Symbol *sym)

+{

+	int seg;

+	char *name = symname(sym);

+

+	if (sym->type.flags & FUNF)

+		seg = CODESEG;

+	else if (sym->type.flags & INITF)

+		seg = DATASEG;

+	else

+		seg = BSSSEG;

+	segment(seg);

+

+	switch (sym->kind) {

+	case SEXTRN:

+		printf("\tEXTRN\t%s\n", name);

+		return;

+	case SGLOB:

+		printf("\tPUBLIC\t%s\n", name);

+		break;

+	}

+

+	printf("%s:\n", name);

+}

+

+static void

+emitconst(Node *np)

+{

+	switch (np->type.size) {

+	case 1:

+		printf("%d", (int) np->u.i & 0xFF);

+		break;

+	case 2:

+		printf("%d", (int) np->u.i & 0xFFFF);

+		break;

+	case 4:

+		printf("%ld", (long) np->u.i & 0xFFFFFFFF);

+		break;

+	default:

+		abort();

+	}

+}

+

+static void

+emittree(Node *np)

+{

+	if (!np)

+		return;

+

+	switch (np->op) {

+	case OSTRING:

+		printf("\"%s\"", np->u.s);

+		free(np->u.s);

+		np->u.s = NULL;

+		break;

+	case OCONST:

+		emitconst(np);

+		break;

+	case OADDR:

+		emittree(np->left);

+		break;

+	case OMEM:

+		fputs(symname(np->u.sym), stdout);

+		break;

+	default:

+		emittree(np->left);

+		printf(" %c ", np->op);

+		emittree(np->right);

+		break;

+	}

+}

+

+static void

+size2asm(Type *tp)

+{

+	char *s;

+

+	/*

+	 * In z80 we can ignore the alignment

+	 */

+	if (tp->flags & STRF) {

+		s = "\tDB\t";

+	} else {

+		switch (tp->size) {

+		case 1:

+			s = "\tDB\t";

+			break;

+		case 2:

+			s = "\tDW\t";

+			break;

+		case 4:

+			s = "\tDD\t";

+			break;

+		default:

+			s = "\tDS\t%lu,";

+			break;

+		}

+	}

+	printf(s, tp->size);

+}

+

+void

+newfun()

+{

+	offpar = offvar = 0;

+}

+

+void

+defpar(Symbol *sym)

+{

+	unsigned long align, size;

+

+	if (sym->kind != SREG && sym->kind != SAUTO)

+		return;

+	align = sym->type.align;

+	size = sym->type.size;

+

+	offpar -= align-1 & ~align;

+	sym->u.off = offpar;

+	offpar -= size;

+	sym->kind = SAUTO;

+}

+

+void

+defvar(Symbol *sym)

+{

+	unsigned long align, size;

+

+	if (sym->kind != SREG && sym->kind != SAUTO)

+		return;

+	align = sym->type.align;

+	size = sym->type.size;

+

+	offvar += align-1 & ~align;

+	sym->u.off = offvar;

+	offvar += size;

+	sym->kind = SAUTO;

+}

+

+void

+defglobal(Symbol *sym)

+{

+	label(sym);

+	if (sym->kind == SEXTRN || (sym->type.flags & INITF))

+		return;

+	size2asm(&sym->type);

+	puts("0");

+}

+

+void

+data(Node *np)

+{

+	size2asm(&np->type);

+	emittree(np);

+	putchar('\n');

+}

+

+void

+writeout(void)

+{

+}

+

+void

+endinit(void)

+{

+}

+

+void

+getbblocks(void)

+{

+}

--- /dev/null

+++ b/src/cmd/scc/cc2/target/z80-scc/optm.c

@@ -1,0 +1,11 @@

+static char sccsid[] = "@(#) ./cc2/arch/z80/optm.c";

+

+#include <scc/scc.h>

+

+#include "../../cc2.h"

+

+Node *

+optm_dep(Node *np)

+{

+	return np;

+}

--- /dev/null

+++ b/src/cmd/scc/cc2/target/z80-scc/target.mk

@@ -1,0 +1,8 @@

+OBJ-z80-scc = $(OBJS)  \

+        target/z80-scc/cgen.o \

+        target/z80-scc/optm.o \

+        target/z80-scc/code.o \

+        target/z80-scc/types.o \

+

+$(LIBEXEC)/cc2-z80-scc: $(OBJ-z80-scc)

+	$(CC) $(SCC_LDFLAGS) $(OBJ-z80-scc) -lscc -o $@

--- /dev/null

+++ b/src/cmd/scc/cc2/target/z80-scc/types.c

@@ -1,0 +1,95 @@

+static char sccsid[] = "@(#) ./cc2/arch/z80/types.c";

+

+#include <scc/scc.h>

+

+#include "../../cc2.h"

+

+

+Type int8type = {

+	.flags  = SIGNF | INTF,

+	.size   = 1,

+	.align  = 1

+};

+

+Type int16type = {

+	.flags  = SIGNF | INTF,

+	.size   = 2,

+	.align  = 1

+};

+

+Type int32type = {

+	.flags  = SIGNF | INTF,

+	.size   = 4,

+	.align  = 1

+};

+

+Type int64type = {

+	.flags  = SIGNF | INTF,

+	.size   = 8,

+	.align  = 1

+};

+

+Type uint8type = {

+	.flags  = INTF,

+	.size   = 1,

+	.align  = 1

+};

+

+Type uint16type = {

+	.flags  = INTF,

+	.size   = 2,

+	.align  = 1

+};

+

+Type uint32type = {

+	.flags  = INTF,

+	.size   = 4,

+	.align  = 1

+};

+

+Type uint64type = {

+	.flags  = INTF,

+	.size   = 8,

+	.align  = 1

+};

+

+Type ptrtype = {

+	.flags  = INTF,

+	.size   = 2,

+	.align  = 1

+};

+

+Type booltype = {

+	.flags  = INTF,

+	.size   = 1,

+	.align  = 1

+};

+

+Type float32type = {

+	.flags  = FLOATF,

+	.size   = 4,

+	.align  = 1

+};

+

+Type float64type = {

+	.flags  = FLOATF,

+	.size   = 4,

+	.align  = 1

+};

+

+Type float80type = {

+	.flags  = FLOATF,

+	.size   = 4,

+	.align  = 1

+};

+

+Type voidtype = {

+	.size = 0,

+	.align = 0

+};

+

+/* this types is not going to be used in this arch */

+Type arg_type = {

+        .size = 0,

+        .align = 0

+};

--- /dev/null

+++ b/src/cmd/scc/posix/Makefile

@@ -1,0 +1,39 @@

+.POSIX:

+

+PROJECTDIR = ../../../..

+include $(PROJECTDIR)/scripts/rules.mk

+

+# SYSLST is a list of backend-arch-abi-sys. First

+# element of the list becomes the default target

+

+SYSLST  = amd64-sysv-linux-elf z80-scc-none-none \

+          i386-sysv-linux-elf amd64-sysv-openbsd-elf

+

+STDCFLAGS =

+

+TARGETS = $(BINDIR)/scc $(BINDIR)/scpp

+

+all: $(TARGETS)

+

+$(BINDIR)/scc: scc.o

+	$(CC) $(SCC_LDFLAGS) scc.o -lscc -o $@

+

+$(BINDIR)/scpp: cpp.sh

+	set -x ;\

+	trap "rm -f $$$$.sh" 0 2 3;\

+	rm -f $@ ;\

+	sed "s%@PREFIX@%$(PREFIX)%" < cpp.sh > $$$$.sh && \

+	chmod +x $$$$.sh && \

+	mv $$$$.sh $@

+

+config.h:

+	PREFIX=$(PREFIX) mkconf $(SYSLST)

+

+dep: inc-dep

+

+clean:

+	rm -f scc scpp *.o

+	rm -f $(TARGETS)

+	rm -f config.h

+

+include deps.mk

--- /dev/null

+++ b/src/cmd/scc/posix/cpp.sh

@@ -1,0 +1,4 @@

+#!/bin/sh

+

+SCCPREFIX=${SCCPREFIX:-@PREFIX@}

+${SCCPREFIX}/bin/scc -E $@

--- /dev/null

+++ b/src/cmd/scc/posix/deps.mk

@@ -1,0 +1,8 @@

+#deps

+scc.o: $(INCDIR)/scc/scc/arg.h

+scc.o: $(INCDIR)/scc/scc/ldflags.h

+scc.o: $(INCDIR)/scc/scc/scc.h

+scc.o: $(INCDIR)/scc/scc/syscrts.h

+scc.o: $(INCDIR)/scc/scc/sysincludes.h

+scc.o: $(INCDIR)/scc/scc/syslibs.h

+scc.o: config.h

--- /dev/null

+++ b/src/cmd/scc/posix/mkconf

@@ -1,0 +1,16 @@

+#!/bin/sh

+

+set -e

+

+rm -f config.h

+trap "rm -f $$.h" 0 2 3

+

+PREFIX=${PREFIX-$HOME}

+

+echo $@ |

+(IFS='- 	' read arch abi sys format r

+echo \#define PREFIX \"$PREFIX\"

+echo \#define ARCH \"$arch\"

+echo \#define SYS  \"$sys\"

+echo \#define ABI  \"$abi\"

+echo \#define FORMAT \"$format\") > $$.h && mv $$.h config.h

--- /dev/null

+++ b/src/cmd/scc/posix/scc.c

@@ -1,0 +1,617 @@

+static char sccsid[] = "@(#) ./driver/posix/scc.c";

+#define _POSIX_SOURCE

+#define _XOPEN_SOURCE 500

+#include <sys/types.h>

+#include <sys/wait.h>

+#include <unistd.h>

+

+#include <errno.h>

+#include <fcntl.h>

+#include <limits.h>

+#include <signal.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+

+#include "config.h"

+#include <scc/arg.h>

+#include <scc/scc.h>

+#include <scc/syscrts.h>

+#include <scc/sysincludes.h>

+#include <scc/syslibs.h>

+#include <scc/ldflags.h>

+

+enum {

+	CC1,

+	TEEIR,

+	CC2,

+	TEEQBE,

+	QBE,

+	TEEAS,

+	AS,

+	LD,

+	STRIP,

+	LAST_TOOL,

+};

+

+static struct tool {

+	char   cmd[PATH_MAX];

+	char   bin[32];

+	char  *outfile;

+	struct items args;

+	unsigned nparams;

+	int    in, out, init;

+	pid_t  pid;

+} tools[] = {

+	[CC1]    = { .cmd = "cc1" },

+	[TEEIR]  = { .bin = "tee",   .cmd = "tee", },

+	[CC2]    = { .cmd = "cc2" },

+	[TEEQBE] = { .bin = "tee",   .cmd = "tee", },

+	[QBE]    = { .bin = "qbe",   .cmd = "qbe", },

+	[TEEAS]  = { .bin = "tee",   .cmd = "tee", },

+	[AS]     = { .bin = "as",    .cmd = "as", },

+	[LD]     = { .bin = "ld",    .cmd = "ld", },

+	[STRIP]  = { .bin = "strip", .cmd = "strip", },

+};

+

+char *argv0;

+static char *arch, *sys, *abi, *format;

+static char *prefix, *objfile, *outfile;

+static char *tmpdir;

+static size_t tmpdirln;

+static struct items objtmp, objout;

+static int Mflag, Eflag, Sflag, cflag, dflag, kflag, sflag, Qflag = 1; /* TODO: Remove Qflag */

+static int devnullfd = -1;

+

+extern int failure;

+

+static void

+terminate(void)

+{

+	unsigned i;

+

+	if (!kflag) {

+		for (i = 0; i < objtmp.n; ++i)

+			unlink(objtmp.s[i]);

+	}

+}

+

+static void

+addarg(int tool, char *arg)

+{

+	struct tool *t = &tools[tool];

+

+	if (t->args.n < 1)

+		t->args.n = 1;

+

+	newitem(&t->args, arg);

+}

+

+static void

+setargv0(int tool, char *arg)

+{

+	struct tool *t = &tools[tool];

+

+	if (t->args.n > 0)

+		t->args.s[0] = arg;

+	else

+		newitem(&t->args, arg);

+}

+

+static int

+qbe(int tool)

+{

+	if (tool != CC2 || !Qflag)

+		return 0;

+	if (!strcmp(arch, "amd64") && !strcmp(abi, "sysv"))

+		return 1;

+	return 0;

+}

+

+static int

+inittool(int tool)

+{

+	struct tool *t = &tools[tool];

+	char *crt, *fmt;

+	int n;

+

+	if (t->init)

+		return tool;

+

+	switch (tool) {

+	case CC1:

+		for (n = 0; sysincludes[n]; ++n) {

+			addarg(tool, "-I");

+			addarg(tool, sysincludes[n]);

+		}

+	case CC2:

+		fmt = (qbe(tool)) ? "%s-qbe_%s-%s" : "%s-%s-%s";

+		n = snprintf(t->bin, sizeof(t->bin), fmt, t->cmd, arch, abi);

+		if (n < 0 || n >= sizeof(t->bin))

+			die("scc: target tool name too long");

+

+		n = snprintf(t->cmd, sizeof(t->cmd),

+		             "%s/libexec/scc/%s", prefix, t->bin);

+		if (n < 0 || n >= sizeof(t->cmd))

+			die("scc: target tool path too long");

+		break;

+	case LD:

+		for (n = 0; ldflags[n]; ++n)

+			addarg(tool, ldflags[n]);

+		addarg(tool, "-o");

+		t->outfile = outfile ? outfile : xstrdup("a.out");

+		addarg(tool, t->outfile);

+		for (n = 0; syslibs[n]; ++n) {

+			addarg(tool, "-L");

+			addarg(tool, syslibs[n]);

+		}

+		if (syscrts[0]) {

+			for (n = 0; syscrts[n]; ++n)

+				addarg(tool, syscrts[n]);

+			break;

+		}

+		n = snprintf(NULL, 0,

+		             "%s/lib/scc/%s-%s-%s/crt.o",

+		             prefix, arch, abi, sys);

+		if (n < 0)

+			die("scc: wrong crt file name");

+		crt = xmalloc(++n);

+		sprintf(crt,

+		        "%s/lib/scc/%s-%s-%s/crt.o",

+		        prefix, arch, abi, sys);

+		addarg(tool, crt);

+		break;

+	case AS:

+		addarg(tool, "-o");

+		break;

+	default:

+		break;

+	}

+

+	setargv0(tool, t->bin);

+	t->nparams = t->args.n;

+	t->init = 1;

+

+	return tool;

+}

+

+static char *

+outfname(char *path, char *type)

+{

+	char *new, sep, *p;

+	size_t newsz, pathln;

+	int tmpfd, n;

+

+	if (path) {

+		sep = '.';

+		if (p = strrchr(path, '/'))

+			path = p + 1;

+		pathln = strlen(path);

+		if (p = strrchr(path, '.'))

+			pathln -= strlen(p);

+	} else {

+		sep = '/';

+		type = "scc-XXXXXX";

+		path = tmpdir;

+		pathln = tmpdirln;

+	}

+

+	newsz = pathln + 1 + strlen(type) + 1;

+	new = xmalloc(newsz);

+	n = snprintf(new, newsz, "%.*s%c%s", (int)pathln, path, sep, type);

+	if (n < 0 || n >= newsz)

+		die("scc: wrong output filename");

+	if (sep == '/') {

+		if ((tmpfd = mkstemp(new)) < 0)

+			die("scc: could not create output file '%s': %s",

+			    new, strerror(errno));

+		close(tmpfd);

+	}

+

+	return new;

+}

+

+static int

+settool(int tool, char *infile, int nexttool)

+{

+	struct tool *t = &tools[tool];

+	unsigned i;

+	int fds[2];

+	static int fdin = -1;

+

+	switch (tool) {

+	case TEEIR:

+		t->outfile = outfname(infile, "ir");

+		addarg(tool, t->outfile);

+		break;

+	case TEEQBE:

+		t->outfile = outfname(infile, "qbe");

+		addarg(tool, t->outfile);

+		break;

+	case TEEAS:

+		t->outfile = outfname(infile, "s");

+		addarg(tool, t->outfile);

+		break;

+	case AS:

+		if (cflag && outfile) {

+			objfile = outfile;

+		} else {

+			objfile = (cflag || kflag) ? infile : NULL;

+			objfile = outfname(objfile, "o");

+		}

+		t->outfile = xstrdup(objfile);

+		addarg(tool, t->outfile);

+		break;

+	case STRIP:

+		if (cflag || kflag) {

+			for (i = 0; i < objout.n; ++i)

+				addarg(tool, xstrdup(objout.s[i]));

+		}

+		if (!cflag && tools[LD].outfile)

+			addarg(tool, tools[LD].outfile);

+		break;

+	default:

+		break;

+	}

+

+	if (fdin > -1) {

+		t->in = fdin;

+		fdin = -1;

+	} else {

+		t->in = -1;

+		if (infile)

+			addarg(tool, xstrdup(infile));

+	}

+

+	if (nexttool < LAST_TOOL) {

+		if (pipe(fds))

+			die("scc: pipe: %s", strerror(errno));

+		t->out = fds[1];

+		fdin = fds[0];

+	} else {

+		t->out = -1;

+	}

+

+	addarg(tool, NULL);

+

+	return tool;

+}

+

+static void

+spawn(int tool)

+{

+	struct tool *t = &tools[tool];

+

+	switch (t->pid = fork()) {

+	case -1:

+		die("scc: %s: %s", t->bin, strerror(errno));

+	case 0:

+		if (t->out > -1)

+			dup2(t->out, 1);

+		if (t->in > -1)

+			dup2(t->in, 0);

+		if (!dflag && tool != CC1 && tool != LD)

+			dup2(devnullfd, 2);

+		execvp(t->cmd, t->args.s);

+		if (dflag) {

+			fprintf(stderr,

+			        "scc: execvp %s: %s\n",

+				t->cmd,

+			        strerror(errno));

+		}

+		abort();

+	default:

+		if (t->in > -1)

+			close(t->in);

+		if (t->out > -1)

+			close(t->out);

+		break;

+	}

+}

+

+static int

+toolfor(char *file)

+{

+	char *dot = strrchr(file, '.');

+

+	if (dot) {

+		if (!strcmp(dot, ".c"))

+			return CC1;

+		if (!strcmp(dot, ".ir"))

+			return CC2;

+		if (!strcmp(dot, ".qbe"))

+			return QBE;

+		if (!strcmp(dot, ".s"))

+			return AS;

+		if (!strcmp(dot, ".o"))

+			return LD;

+		if (!strcmp(dot, ".a"))

+			return LD;

+	} else if (!strcmp(file, "-")) {

+		return CC1;

+	}

+

+	die("scc: do not recognize filetype of %s", file);

+}

+

+static int

+valid(int tool, struct tool *t)

+{

+	int st;

+

+	if (waitpid(t->pid, &st, 0) == -1 || WIFSIGNALED(st))

+		goto internal;

+	if (WIFEXITED(st) && WEXITSTATUS(st) == 0)

+		return 1;

+	if (!failure && (tool == CC1 || tool == LD))

+		goto fail;

+

+internal:

+	fprintf(stderr, "scc:%s: internal error\n", t->bin);

+fail:

+	failure = 1;

+	return 0;

+}

+

+static int

+validatetools(void)

+{

+	struct tool *t;

+	unsigned i;

+	int tool, st, failed = LAST_TOOL;

+

+	for (tool = 0; tool < LAST_TOOL; ++tool) {

+		t = &tools[tool];

+		if (!t->pid)

+			continue;

+		if (!valid(tool, t))

+			failed = tool;

+		if (tool >= failed && t->outfile)

+			unlink(t->outfile);

+		for (i = t->nparams; i < t->args.n; ++i)

+			free(t->args.s[i]);

+		t->args.n = t->nparams;

+		t->pid = 0;

+	}

+	if (failed < LAST_TOOL) {

+		unlink(objfile);

+		free(objfile);

+		objfile = NULL;

+		return 0;

+	}

+

+	return 1;

+}

+

+static int

+buildfile(char *file, int tool)

+{

+	int nexttool;

+

+	for (; tool < LAST_TOOL; tool = nexttool) {

+		switch (tool) {

+		case CC1:

+			if (Eflag || Mflag)

+				nexttool = LAST_TOOL;

+			else

+				nexttool = kflag ? TEEIR : CC2;

+			break;

+		case TEEIR:

+			nexttool = CC2;

+			break;

+		case CC2:

+			if (Qflag)

+				nexttool = kflag ? TEEQBE : QBE;

+			else

+				nexttool = (Sflag || kflag) ? TEEAS : AS;

+			break;

+		case TEEQBE:

+			nexttool = QBE;

+			break;

+		case QBE:

+			nexttool = (Sflag || kflag) ? TEEAS : AS;

+			break;

+		case TEEAS:

+			nexttool = Sflag ? LAST_TOOL : AS;

+			break;

+		case AS:

+			nexttool = LAST_TOOL;

+			break;

+		default:

+			nexttool = LAST_TOOL;

+			continue;

+		}

+

+		spawn(settool(inittool(tool), file, nexttool));

+	}

+

+	return validatetools();

+}

+

+static void

+build(struct items *chain, int link)

+{

+	int i, tool;

+

+	if (link)

+		inittool(LD);

+

+	for (i = 0; i < chain->n; ++i) {

+		if (!strcmp(chain->s[i], "-l")) {

+			if (link) {

+				addarg(LD, xstrdup(chain->s[i++]));

+				addarg(LD, xstrdup(chain->s[i]));

+			} else {

+				++i;

+			}

+			continue;

+		}

+		tool = toolfor(chain->s[i]);

+		if (tool == LD) {

+			if (link)

+				addarg(LD, xstrdup(chain->s[i]));

+			continue;

+		}

+		if (buildfile(chain->s[i], tool)) {

+			if (link)

+				addarg(LD, xstrdup(objfile));

+			newitem((!link || kflag) ? &objout : &objtmp, objfile);

+		}

+	}

+}

+

+static void

+usage(void)

+{

+	fputs("usage: scc [-D def[=val]]... [-U def]... [-I dir]... "

+	       "[-L dir]... [-l dir]...\n"

+	       "           [-dgksw] [-m arch] [-M|-E|-S] [-o outfile] file...\n"

+	       "       scc [-D def[=val]]... [-U def]... [-I dir]... "

+	       "[-L dir]... [-l dir]...\n"

+	       "           [-dgksw] [-m arch] [-M|-E|-S] -c file...\n"

+	       "       scc [-D def[=val]]... [-U def]... [-I dir]... "

+	       "[-L dir]... [-l dir]...\n"

+	       "           [-dgksw] [-m arch] -c -o outfile file\n", stderr);

+	exit(1);

+}

+

+int

+main(int argc, char *argv[])

+{

+	struct items linkchain = { .n = 0, };

+	int link;

+

+	atexit(terminate);

+

+	if (!(arch = getenv("ARCH")))

+		arch = ARCH;

+	if (!(sys = getenv("SYS")))

+		sys = SYS;

+	if (!(abi = getenv("ABI")))

+		abi = ABI;

+	if (!(format = getenv("FORMAT")))

+		format = FORMAT;

+	if (!(prefix = getenv("SCCPREFIX")))

+		prefix = PREFIX;

+

+	ARGBEGIN {

+	case 'D':

+		addarg(CC1, "-D");

+		addarg(CC1, EARGF(usage()));

+		break;

+	case 'M':

+		Mflag = 1;

+		addarg(CC1, "-M");

+		break;

+	case 'E':

+		Eflag = 1;

+		addarg(CC1, "-E");

+		break;

+	case 'I':

+		addarg(CC1, "-I");

+		addarg(CC1, EARGF(usage()));

+		break;

+	case 'L':

+		addarg(LD, "-L");

+		addarg(LD, EARGF(usage()));

+		break;

+	case 'O':

+		EARGF(usage());

+		break;

+	case 'S':

+		Sflag = 1;

+		break;

+	case 'U':

+		addarg(CC1, "-U");

+		addarg(CC1, EARGF(usage()));

+		break;

+	case 'c':

+		cflag = 1;

+		break;

+	case 'd':

+		dflag = 1;

+		break;

+	case 'g':

+		addarg(AS, "-g");

+		addarg(LD, "-g");

+		break;

+	case 'k':

+		kflag = 1;

+		break;

+	case 'l':

+		newitem(&linkchain, "-l");

+		newitem(&linkchain, EARGF(usage()));

+		break;

+	case 'm':

+		arch = EARGF(usage());

+		break;

+	case 'o':

+		outfile = xstrdup(EARGF(usage()));

+		break;

+	case 's':

+		sflag = 1;

+		break;

+	case 't':

+		sys = EARGF(usage());

+		break;

+	case 'W':

+		EARGF(usage());

+	case 'w':

+		addarg(CC1, "-w");

+		break;

+	case 'q':

+		Qflag = 0;

+		break;

+	case 'Q':

+		Qflag = 1;

+		break;

+	case '-':

+		fprintf(stderr,

+		        "scc: ignored parameter --%s\n", EARGF(usage()));

+		break;

+	default:

+		usage();

+	} ARGOPERAND {

+operand:

+		newitem(&linkchain, ARGOP());

+	} ARGEND

+

+	for (; *argv; --argc, ++argv)

+		goto operand;

+

+	if (Eflag && linkchain.n == 0)

+		newitem(&linkchain, "-");

+

+	if (Eflag && Mflag ||

+            (Eflag || Mflag) && (Sflag || kflag) ||

+	    linkchain.n == 0 ||

+	    linkchain.n > 1 && cflag && outfile)

+		usage();

+

+	if (!dflag) {

+		if ((devnullfd = open("/dev/null", O_WRONLY)) < 0)

+			fputs("scc: could not open /dev/null\n", stderr);

+	}

+

+	if (!(tmpdir = getenv("TMPDIR")) || !tmpdir[0])

+		tmpdir = ".";

+	tmpdirln = strlen(tmpdir);

+

+	build(&linkchain, (link = !(Mflag || Eflag || Sflag || cflag)));

+

+	if (!(link || cflag))

+		return failure;

+

+	if (link && !failure) {

+		addarg(LD, xstrdup("-lc"));

+		spawn(settool(LD, NULL, LAST_TOOL));

+		validatetools();

+	}

+

+	if (sflag) {

+		spawn(settool(inittool(STRIP), NULL, LAST_TOOL));

+		validatetools();

+	}

+

+	return failure;

+}

--- a/src/driver/Makefile

+++ /dev/null

@@ -1,8 +1,0 @@

-.POSIX:

-

-DRIVER = posix

-PROJECTDIR = ../..

-include $(PROJECTDIR)/scripts/rules.mk

-

-all dep clean:

-	+@cd $(DRIVER) && $(MAKE) $@

--- a/src/driver/posix/Makefile

+++ /dev/null

@@ -1,39 +1,0 @@

-.POSIX:

-

-PROJECTDIR = ../..

-include $(PROJECTDIR)/rules.mk

-

-# SYSLST is a list of backend-arch-abi-sys. First

-# element of the list becomes the default target

-

-SYSLST  = amd64-sysv-linux-elf z80-scc-none-none \

-          i386-sysv-linux-elf amd64-sysv-openbsd-elf

-

-STDCFLAGS =

-

-TARGETS = $(BINDIR)/scc $(BINDIR)/scpp

-

-all: $(TARGETS)

-

-$(BINDIR)/scc: scc.o

-	$(CC) $(SCC_LDFLAGS) scc.o -lscc -o $@

-

-$(BINDIR)/scpp: cpp.sh config.h

-	set -x ;\

-	trap "rm -f $$$$.sh" 0 2 3;\

-	rm -f $@ ;\

-	sed "s%@PREFIX@%$(PREFIX)%" < cpp.sh > $$$$.sh && \

-	chmod +x $$$$.sh && \

-	mv $$$$.sh $@

-

-config.h:

-	PREFIX=$(PREFIX) config.sh $(SYSLST)

-

-dep: inc-dep

-

-clean:

-	rm -f scc scpp *.o

-	rm -f $(TARGETS)

-	rm -f config.h

-

-include deps.mk

--- a/src/driver/posix/config.h

+++ /dev/null

@@ -1,5 +1,0 @@

-#define PREFIX "/home/robvar01/src/tools/scc/driver/posix/../../root"

-#define ARCH "amd64"

-#define SYS "linux"

-#define ABI "sysv"

-#define FORMAT "elf"

--- a/src/driver/posix/config.sh

+++ /dev/null

@@ -1,16 +1,0 @@

-#!/bin/sh

-

-set -e

-

-rm -f config.h

-trap "rm -f $$.h" 0 2 3

-

-PREFIX=${PREFIX-$HOME}

-

-echo $@ |

-(IFS='- 	' read arch abi sys format r

-echo \#define PREFIX \"$PREFIX\"

-echo \#define ARCH \"$arch\"

-echo \#define SYS  \"$sys\"

-echo \#define ABI  \"$abi\"

-echo \#define FORMAT \"$format\") > $$.h && mv $$.h config.h

--- a/src/driver/posix/cpp.sh

+++ /dev/null

@@ -1,4 +1,0 @@

-#!/bin/sh

-

-SCCPREFIX=${SCCPREFIX:-@PREFIX@}

-${SCCPREFIX}/bin/scc -E $@

--- a/src/driver/posix/deps.mk

+++ /dev/null

@@ -1,8 +1,0 @@

-#deps

-scc.o: ../../inc/arg.h

-scc.o: ../../inc/ldflags.h

-scc.o: ../../inc/scc.h

-scc.o: ../../inc/syscrts.h

-scc.o: ../../inc/sysincludes.h

-scc.o: ../../inc/syslibs.h

-scc.o: config.h

--- a/src/driver/posix/scc.c

+++ /dev/null

@@ -1,617 +1,0 @@

-static char sccsid[] = "@(#) ./driver/posix/scc.c";

-#define _POSIX_SOURCE

-#define _XOPEN_SOURCE 500

-#include <sys/types.h>

-#include <sys/wait.h>

-#include <unistd.h>

-

-#include <errno.h>

-#include <fcntl.h>

-#include <limits.h>

-#include <signal.h>

-#include <stdio.h>

-#include <stdlib.h>

-#include <string.h>

-

-#include "config.h"

-#include "../../inc/arg.h"

-#include "../../inc/scc.h"

-#include "../../inc/syscrts.h"

-#include "../../inc/sysincludes.h"

-#include "../../inc/syslibs.h"

-#include "../../inc/ldflags.h"

-

-enum {

-	CC1,

-	TEEIR,

-	CC2,

-	TEEQBE,

-	QBE,

-	TEEAS,

-	AS,

-	LD,

-	STRIP,

-	LAST_TOOL,

-};

-

-static struct tool {

-	char   cmd[PATH_MAX];

-	char   bin[32];

-	char  *outfile;

-	struct items args;

-	unsigned nparams;

-	int    in, out, init;

-	pid_t  pid;

-} tools[] = {

-	[CC1]    = { .cmd = "cc1" },

-	[TEEIR]  = { .bin = "tee",   .cmd = "tee", },

-	[CC2]    = { .cmd = "cc2" },

-	[TEEQBE] = { .bin = "tee",   .cmd = "tee", },

-	[QBE]    = { .bin = "qbe",   .cmd = "qbe", },

-	[TEEAS]  = { .bin = "tee",   .cmd = "tee", },

-	[AS]     = { .bin = "as",    .cmd = "as", },

-	[LD]     = { .bin = "ld",    .cmd = "ld", },

-	[STRIP]  = { .bin = "strip", .cmd = "strip", },

-};

-

-char *argv0;

-static char *arch, *sys, *abi, *format;

-static char *prefix, *objfile, *outfile;

-static char *tmpdir;

-static size_t tmpdirln;

-static struct items objtmp, objout;

-static int Mflag, Eflag, Sflag, cflag, dflag, kflag, sflag, Qflag = 1; /* TODO: Remove Qflag */

-static int devnullfd = -1;

-

-extern int failure;

-

-static void

-terminate(void)

-{

-	unsigned i;

-

-	if (!kflag) {

-		for (i = 0; i < objtmp.n; ++i)

-			unlink(objtmp.s[i]);

-	}

-}

-

-static void

-addarg(int tool, char *arg)

-{

-	struct tool *t = &tools[tool];

-

-	if (t->args.n < 1)

-		t->args.n = 1;

-

-	newitem(&t->args, arg);

-}

-

-static void

-setargv0(int tool, char *arg)

-{

-	struct tool *t = &tools[tool];

-

-	if (t->args.n > 0)

-		t->args.s[0] = arg;

-	else

-		newitem(&t->args, arg);

-}

-

-static int

-qbe(int tool)

-{

-	if (tool != CC2 || !Qflag)

-		return 0;

-	if (!strcmp(arch, "amd64") && !strcmp(abi, "sysv"))

-		return 1;

-	return 0;

-}

-

-static int

-inittool(int tool)

-{

-	struct tool *t = &tools[tool];

-	char *crt, *fmt;

-	int n;

-

-	if (t->init)

-		return tool;

-

-	switch (tool) {

-	case CC1:

-		for (n = 0; sysincludes[n]; ++n) {

-			addarg(tool, "-I");

-			addarg(tool, sysincludes[n]);

-		}

-	case CC2:

-		fmt = (qbe(tool)) ? "%s-qbe_%s-%s" : "%s-%s-%s";

-		n = snprintf(t->bin, sizeof(t->bin), fmt, t->cmd, arch, abi);

-		if (n < 0 || n >= sizeof(t->bin))

-			die("scc: target tool name too long");

-

-		n = snprintf(t->cmd, sizeof(t->cmd),

-		             "%s/libexec/scc/%s", prefix, t->bin);

-		if (n < 0 || n >= sizeof(t->cmd))

-			die("scc: target tool path too long");

-		break;

-	case LD:

-		for (n = 0; ldflags[n]; ++n)

-			addarg(tool, ldflags[n]);

-		addarg(tool, "-o");

-		t->outfile = outfile ? outfile : xstrdup("a.out");

-		addarg(tool, t->outfile);

-		for (n = 0; syslibs[n]; ++n) {

-			addarg(tool, "-L");

-			addarg(tool, syslibs[n]);

-		}

-		if (syscrts[0]) {

-			for (n = 0; syscrts[n]; ++n)

-				addarg(tool, syscrts[n]);

-			break;

-		}

-		n = snprintf(NULL, 0,

-		             "%s/lib/scc/%s-%s-%s/crt.o",

-		             prefix, arch, abi, sys);

-		if (n < 0)

-			die("scc: wrong crt file name");

-		crt = xmalloc(++n);

-		sprintf(crt,

-		        "%s/lib/scc/%s-%s-%s/crt.o",

-		        prefix, arch, abi, sys);

-		addarg(tool, crt);

-		break;

-	case AS:

-		addarg(tool, "-o");

-		break;

-	default:

-		break;

-	}

-

-	setargv0(tool, t->bin);

-	t->nparams = t->args.n;

-	t->init = 1;

-

-	return tool;

-}

-

-static char *

-outfname(char *path, char *type)

-{

-	char *new, sep, *p;

-	size_t newsz, pathln;

-	int tmpfd, n;

-

-	if (path) {

-		sep = '.';

-		if (p = strrchr(path, '/'))

-			path = p + 1;

-		pathln = strlen(path);

-		if (p = strrchr(path, '.'))

-			pathln -= strlen(p);

-	} else {

-		sep = '/';

-		type = "scc-XXXXXX";

-		path = tmpdir;

-		pathln = tmpdirln;

-	}

-

-	newsz = pathln + 1 + strlen(type) + 1;

-	new = xmalloc(newsz);

-	n = snprintf(new, newsz, "%.*s%c%s", (int)pathln, path, sep, type);

-	if (n < 0 || n >= newsz)

-		die("scc: wrong output filename");

-	if (sep == '/') {

-		if ((tmpfd = mkstemp(new)) < 0)

-			die("scc: could not create output file '%s': %s",

-			    new, strerror(errno));

-		close(tmpfd);

-	}

-

-	return new;

-}

-

-static int

-settool(int tool, char *infile, int nexttool)

-{

-	struct tool *t = &tools[tool];

-	unsigned i;

-	int fds[2];

-	static int fdin = -1;

-

-	switch (tool) {

-	case TEEIR:

-		t->outfile = outfname(infile, "ir");

-		addarg(tool, t->outfile);

-		break;

-	case TEEQBE:

-		t->outfile = outfname(infile, "qbe");

-		addarg(tool, t->outfile);

-		break;

-	case TEEAS:

-		t->outfile = outfname(infile, "s");

-		addarg(tool, t->outfile);

-		break;

-	case AS:

-		if (cflag && outfile) {

-			objfile = outfile;

-		} else {

-			objfile = (cflag || kflag) ? infile : NULL;

-			objfile = outfname(objfile, "o");

-		}

-		t->outfile = xstrdup(objfile);

-		addarg(tool, t->outfile);

-		break;

-	case STRIP:

-		if (cflag || kflag) {

-			for (i = 0; i < objout.n; ++i)

-				addarg(tool, xstrdup(objout.s[i]));

-		}

-		if (!cflag && tools[LD].outfile)

-			addarg(tool, tools[LD].outfile);

-		break;

-	default:

-		break;

-	}

-

-	if (fdin > -1) {

-		t->in = fdin;

-		fdin = -1;

-	} else {

-		t->in = -1;

-		if (infile)

-			addarg(tool, xstrdup(infile));

-	}

-

-	if (nexttool < LAST_TOOL) {

-		if (pipe(fds))

-			die("scc: pipe: %s", strerror(errno));

-		t->out = fds[1];

-		fdin = fds[0];

-	} else {

-		t->out = -1;

-	}

-

-	addarg(tool, NULL);

-

-	return tool;

-}

-

-static void

-spawn(int tool)

-{

-	struct tool *t = &tools[tool];

-

-	switch (t->pid = fork()) {

-	case -1:

-		die("scc: %s: %s", t->bin, strerror(errno));

-	case 0:

-		if (t->out > -1)

-			dup2(t->out, 1);

-		if (t->in > -1)

-			dup2(t->in, 0);

-		if (!dflag && tool != CC1 && tool != LD)

-			dup2(devnullfd, 2);

-		execvp(t->cmd, t->args.s);

-		if (dflag) {

-			fprintf(stderr,

-			        "scc: execvp %s: %s\n",

-				t->cmd,

-			        strerror(errno));

-		}

-		abort();

-	default:

-		if (t->in > -1)

-			close(t->in);

-		if (t->out > -1)

-			close(t->out);

-		break;

-	}

-}

-

-static int

-toolfor(char *file)

-{

-	char *dot = strrchr(file, '.');

-

-	if (dot) {

-		if (!strcmp(dot, ".c"))

-			return CC1;

-		if (!strcmp(dot, ".ir"))

-			return CC2;

-		if (!strcmp(dot, ".qbe"))

-			return QBE;

-		if (!strcmp(dot, ".s"))

-			return AS;

-		if (!strcmp(dot, ".o"))

-			return LD;

-		if (!strcmp(dot, ".a"))

-			return LD;

-	} else if (!strcmp(file, "-")) {

-		return CC1;

-	}

-

-	die("scc: do not recognize filetype of %s", file);

-}

-

-static int

-valid(int tool, struct tool *t)

-{

-	int st;

-

-	if (waitpid(t->pid, &st, 0) == -1 || WIFSIGNALED(st))

-		goto internal;

-	if (WIFEXITED(st) && WEXITSTATUS(st) == 0)

-		return 1;

-	if (!failure && (tool == CC1 || tool == LD))

-		goto fail;

-

-internal:

-	fprintf(stderr, "scc:%s: internal error\n", t->bin);

-fail:

-	failure = 1;

-	return 0;

-}

-

-static int

-validatetools(void)

-{

-	struct tool *t;

-	unsigned i;

-	int tool, st, failed = LAST_TOOL;

-

-	for (tool = 0; tool < LAST_TOOL; ++tool) {

-		t = &tools[tool];

-		if (!t->pid)

-			continue;

-		if (!valid(tool, t))

-			failed = tool;

-		if (tool >= failed && t->outfile)

-			unlink(t->outfile);

-		for (i = t->nparams; i < t->args.n; ++i)

-			free(t->args.s[i]);

-		t->args.n = t->nparams;

-		t->pid = 0;

-	}

-	if (failed < LAST_TOOL) {

-		unlink(objfile);

-		free(objfile);

-		objfile = NULL;

-		return 0;

-	}

-

-	return 1;

-}

-

-static int

-buildfile(char *file, int tool)

-{

-	int nexttool;

-

-	for (; tool < LAST_TOOL; tool = nexttool) {

-		switch (tool) {

-		case CC1:

-			if (Eflag || Mflag)

-				nexttool = LAST_TOOL;

-			else

-				nexttool = kflag ? TEEIR : CC2;

-			break;

-		case TEEIR:

-			nexttool = CC2;

-			break;

-		case CC2:

-			if (Qflag)

-				nexttool = kflag ? TEEQBE : QBE;

-			else

-				nexttool = (Sflag || kflag) ? TEEAS : AS;

-			break;

-		case TEEQBE:

-			nexttool = QBE;

-			break;

-		case QBE:

-			nexttool = (Sflag || kflag) ? TEEAS : AS;

-			break;

-		case TEEAS:

-			nexttool = Sflag ? LAST_TOOL : AS;

-			break;

-		case AS:

-			nexttool = LAST_TOOL;

-			break;

-		default:

-			nexttool = LAST_TOOL;

-			continue;

-		}

-

-		spawn(settool(inittool(tool), file, nexttool));

-	}

-

-	return validatetools();

-}

-

-static void

-build(struct items *chain, int link)

-{

-	int i, tool;

-

-	if (link)

-		inittool(LD);

-

-	for (i = 0; i < chain->n; ++i) {

-		if (!strcmp(chain->s[i], "-l")) {

-			if (link) {

-				addarg(LD, xstrdup(chain->s[i++]));

-				addarg(LD, xstrdup(chain->s[i]));

-			} else {

-				++i;

-			}

-			continue;

-		}

-		tool = toolfor(chain->s[i]);

-		if (tool == LD) {

-			if (link)

-				addarg(LD, xstrdup(chain->s[i]));

-			continue;

-		}

-		if (buildfile(chain->s[i], tool)) {

-			if (link)

-				addarg(LD, xstrdup(objfile));

-			newitem((!link || kflag) ? &objout : &objtmp, objfile);

-		}

-	}

-}

-

-static void

-usage(void)

-{

-	fputs("usage: scc [-D def[=val]]... [-U def]... [-I dir]... "

-	       "[-L dir]... [-l dir]...\n"

-	       "           [-dgksw] [-m arch] [-M|-E|-S] [-o outfile] file...\n"

-	       "       scc [-D def[=val]]... [-U def]... [-I dir]... "

-	       "[-L dir]... [-l dir]...\n"

-	       "           [-dgksw] [-m arch] [-M|-E|-S] -c file...\n"

-	       "       scc [-D def[=val]]... [-U def]... [-I dir]... "

-	       "[-L dir]... [-l dir]...\n"

-	       "           [-dgksw] [-m arch] -c -o outfile file\n", stderr);

-	exit(1);

-}

-

-int

-main(int argc, char *argv[])

-{

-	struct items linkchain = { .n = 0, };

-	int link;

-

-	atexit(terminate);

-

-	if (!(arch = getenv("ARCH")))

-		arch = ARCH;

-	if (!(sys = getenv("SYS")))

-		sys = SYS;

-	if (!(abi = getenv("ABI")))

-		abi = ABI;

-	if (!(format = getenv("FORMAT")))

-		format = FORMAT;

-	if (!(prefix = getenv("SCCPREFIX")))

-		prefix = PREFIX;

-

-	ARGBEGIN {

-	case 'D':

-		addarg(CC1, "-D");

-		addarg(CC1, EARGF(usage()));

-		break;

-	case 'M':

-		Mflag = 1;

-		addarg(CC1, "-M");

-		break;

-	case 'E':

-		Eflag = 1;

-		addarg(CC1, "-E");

-		break;

-	case 'I':

-		addarg(CC1, "-I");

-		addarg(CC1, EARGF(usage()));

-		break;

-	case 'L':

-		addarg(LD, "-L");

-		addarg(LD, EARGF(usage()));

-		break;

-	case 'O':

-		EARGF(usage());

-		break;

-	case 'S':

-		Sflag = 1;

-		break;

-	case 'U':

-		addarg(CC1, "-U");

-		addarg(CC1, EARGF(usage()));

-		break;

-	case 'c':

-		cflag = 1;

-		break;

-	case 'd':

-		dflag = 1;

-		break;

-	case 'g':

-		addarg(AS, "-g");

-		addarg(LD, "-g");

-		break;

-	case 'k':

-		kflag = 1;

-		break;

-	case 'l':

-		newitem(&linkchain, "-l");

-		newitem(&linkchain, EARGF(usage()));

-		break;

-	case 'm':

-		arch = EARGF(usage());

-		break;

-	case 'o':

-		outfile = xstrdup(EARGF(usage()));

-		break;

-	case 's':

-		sflag = 1;

-		break;

-	case 't':

-		sys = EARGF(usage());

-		break;

-	case 'W':

-		EARGF(usage());

-	case 'w':

-		addarg(CC1, "-w");

-		break;

-	case 'q':

-		Qflag = 0;

-		break;

-	case 'Q':

-		Qflag = 1;

-		break;

-	case '-':

-		fprintf(stderr,

-		        "scc: ignored parameter --%s\n", EARGF(usage()));

-		break;

-	default:

-		usage();

-	} ARGOPERAND {

-operand:

-		newitem(&linkchain, ARGOP());

-	} ARGEND

-

-	for (; *argv; --argc, ++argv)

-		goto operand;

-

-	if (Eflag && linkchain.n == 0)

-		newitem(&linkchain, "-");

-

-	if (Eflag && Mflag ||

-            (Eflag || Mflag) && (Sflag || kflag) ||

-	    linkchain.n == 0 ||

-	    linkchain.n > 1 && cflag && outfile)

-		usage();

-

-	if (!dflag) {

-		if ((devnullfd = open("/dev/null", O_WRONLY)) < 0)

-			fputs("scc: could not open /dev/null\n", stderr);

-	}

-

-	if (!(tmpdir = getenv("TMPDIR")) || !tmpdir[0])

-		tmpdir = ".";

-	tmpdirln = strlen(tmpdir);

-

-	build(&linkchain, (link = !(Mflag || Eflag || Sflag || cflag)));

-

-	if (!(link || cflag))

-		return failure;

-

-	if (link && !failure) {

-		addarg(LD, xstrdup("-lc"));

-		spawn(settool(LD, NULL, LAST_TOOL));

-		validatetools();

-	}

-

-	if (sflag) {

-		spawn(settool(inittool(STRIP), NULL, LAST_TOOL));

-		validatetools();

-	}

-

-	return failure;

-}

-- 

⑨