ANSI C conversion and add procedure declarations.

util/ncgg/cgg.y

@@ -14,6 +14,9 @@ static char rcsid[]= "$Id$";
 #include "iocc.h"
 #include "instruct.h"
 #include "expr.h"
+#include "coerc.h"
+#include "hall.h"
+#include "subr.h"
 #include "extern.h"
 #include <cgg_cg.h>
 #include <em_reg.h>
@@ -49,6 +52,14 @@ iocc_t subr_iocc(),tokm_iocc(),ident_iocc(),all_iocc(),percident_iocc(), descr_i
 extern int narexpr;
 extern expr_t arexp[];
 
+extern void skipupto(int tok,char *str);
+extern void outpatterns(void);
+extern void dopattern(int stackcoerc, varinfo *kills, varinfo *allocates,
+			varinfo *generates, varinfo *yields, varinfo *leaving);
+extern int yylex(void);			
+extern int argtyp(int mn);
+extern void yyerror (char const *s);
+			
 int niops;
 iocc_t iops[20];
 %}

util/ncgg/coerc.c

@@ -3,7 +3,7 @@
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
 #ifndef NORCSID
-static char rcsid[]= "$Id$";
+static char rcsid[] = "$Id$";
 #endif
 
 #include <assert.h>
@@ -14,6 +14,9 @@ static char rcsid[]= "$Id$";
 #include "token.h"
 #include "varinfo.h"
 #include "iocc.h"
+#include "subr.h"
+#include "hall.h"
+#include "coerc.h"
 #include <cgg_cg.h>
 #include "pseudo.h"
 #include "extern.h"
@@ -22,165 +25,181 @@ extern set_t l_sets[];
 
 int nmoves;
 move_t l_moves[MAXMOVES];
-short posmoves[MAXREGS+MAXTOKENS][SETSIZE];
+short posmoves[MAXREGS + MAXTOKENS][SETSIZE];
 
-void
+void n_split(int , int, struct varinfo *, struct varinfo *, struct varinfo *, int);
-n_move(s1,e1,s2,e2,vi) struct varinfo *vi; {
+
+extern void dopattern(int stackcoerc, varinfo *kills, varinfo *allocates,
+			varinfo *generates, varinfo *yields, varinfo *leaving);;
+
+void n_move(int s1, int e1, int s2, int e2, struct varinfo *vi)
+{
 	register move_p mp;
-	register i,j;
+	register int i, j;
 
-	NEXT(nmoves,MAXMOVES,"Moves");
+	NEXT(nmoves, MAXMOVES, "Moves");
-	mp = &l_moves[nmoves-1];
+	mp = &l_moves[nmoves - 1];
 	mp->m_set1 = s1;
 	mp->m_expr1 = e1;
 	mp->m_set2 = s2;
 	mp->m_expr2 = e2;
 	mp->m_cindex = codeindex;
-	dopattern(0,VI_NULL,VI_NULL,vi,VI_NULL,VI_NULL);
+	dopattern(0, VI_NULL, VI_NULL, vi, VI_NULL, VI_NULL);
-	if (mp->m_expr1!=0 || mp->m_expr2!=0)
+	if (mp->m_expr1 != 0 || mp->m_expr2 != 0)
 		return;
-	for (i=0;i<MAXREGS+MAXTOKENS;i++)
+	for (i = 0; i < MAXREGS + MAXTOKENS; i++)
-	    if (BIT(l_sets[mp->m_set1].set_val,i))
+		if (BIT(l_sets[mp->m_set1].set_val, i))
-	    	for(j=0;j<SETSIZE;j++)
+			for (j = 0; j < SETSIZE; j++)
-		    posmoves[i][j] |= l_sets[mp->m_set2].set_val[j];
+				posmoves[i][j] |= l_sets[mp->m_set2].set_val[j];
 }
 
-existmove(from,sp) iocc_t from; short *sp; {
+int existmove(iocc_t from, short *sp)
-	register i;
+{
+	register int i;
 
-	for (i=0;i<MAXREGS+MAXTOKENS;i++)
+	for (i = 0; i < MAXREGS + MAXTOKENS; i++)
-	    if(BIT(from.in_set,i))
+		if (BIT(from.in_set, i))
-		if (!subset(sp,posmoves[i],SETSIZE))
+			if (!subset(sp, posmoves[i], SETSIZE))
-			return(0);
+				return (0);
-	return(1);
+	return (1);
 }
 
-existalmove(from,prpno) iocc_t from; {
+int existalmove(iocc_t from, int prpno)
+{
 	short s[SETSIZE];
-	register i;
+	register int i;
-	
+
-	for (i=0;i<SETSIZE;i++)
+	for (i = 0; i < SETSIZE; i++)
-		s[i] = i<SZOFSET(MAXREGS) ? l_props[prpno].pr_regset[i] : 0;
+		s[i] = i < SZOFSET(MAXREGS) ? l_props[prpno].pr_regset[i] : 0;
-	return(existmove(from,s));
+	return (existmove(from, s));
 }
 
-struct varinfo *gen_move(from,to) iocc_t from,to; {
+struct varinfo *gen_move(iocc_t from, iocc_t to)
+{
 	register struct varinfo *vp;
 
-	if (existmove(from,to.in_set)==0) {
+	if (existmove(from, to.in_set) == 0)
+	{
 		error("No such move defined");
-		return(VI_NULL);
+		return (VI_NULL );
 	}
-	NEW(vp,struct varinfo);
+	NEW(vp, struct varinfo);
 	vp->vi_int[0] = INSMOVE;
 	vp->vi_int[1] = from.in_index;
 	vp->vi_int[2] = to.in_index;
-	return(vp);
+	return (vp);
 }
 
 int ntests;
 test_t l_tests[MAXTESTS];
 short postests[SETSIZE];
 
-void
+void n_test(int s, int e, struct varinfo *vi)
-n_test(s,e,vi) struct varinfo *vi; {
+{
 	register test_p tp;
-	register i;
+	register int i;
 
-	NEXT(ntests,MAXTESTS,"Tests");
+	NEXT(ntests, MAXTESTS, "Tests");
-	tp = &l_tests[ntests-1];
+	tp = &l_tests[ntests - 1];
 	tp->t_set = s;
-	tp->t_expr = e;	
+	tp->t_expr = e;
 	tp->t_cindex = codeindex;
-	dopattern(0,VI_NULL,VI_NULL,vi,VI_NULL,VI_NULL);
+	dopattern(0, VI_NULL, VI_NULL, vi, VI_NULL, VI_NULL);
-	if (tp->t_expr!=0)
+	if (tp->t_expr != 0)
 		return;
-	for(i=0;i<SETSIZE;i++)
+	for (i = 0; i < SETSIZE; i++)
 		postests[i] |= l_sets[tp->t_set].set_val[i];
 }
 
-struct varinfo *gen_test(from) iocc_t from; {
+struct varinfo *gen_test(iocc_t from)
+{
 	register struct varinfo *vp;
 
-	if (!subset(from.in_set,postests,SETSIZE)) {
+	if (!subset(from.in_set, postests, SETSIZE))
+	{
 		error("No such test");
-		return(0);
+		return (0);
 	}
-	NEW(vp,struct varinfo);
+	NEW(vp, struct varinfo);
 	vp->vi_int[0] = INSTEST;
 	vp->vi_int[1] = from.in_index;
-	return(vp);
+	return (vp);
 }
 
-struct varinfo *gen_label(arg) int arg; {
+struct varinfo *gen_label(int arg)
+{
 	register struct varinfo *vp;
 
-	NEW(vp,struct varinfo);
+	NEW(vp, struct varinfo);
 	vp->vi_int[0] = INSLABDEF;
 	vp->vi_int[1] = arg;
-	return(vp);
+	return (vp);
 }
 
-struct varinfo *gen_preturn() {
+struct varinfo *gen_preturn(void)
+{
 	register struct varinfo *vp;
 
-	NEW(vp,struct varinfo);
+	NEW(vp, struct varinfo);
 	vp->vi_int[0] = INSPRETURN;
-	return(vp);
+	return (vp);
 }
 
-struct varinfo *gen_tlab(n) {
+struct varinfo *gen_tlab(int n)
+{
 	register struct varinfo *vp;
 
-	assert(n>=0 && n<=9);
+	assert(n >= 0 && n <= 9);
-	NEW(vp,struct varinfo);
+	NEW(vp, struct varinfo);
 	vp->vi_int[0] = INSTLAB;
 	vp->vi_int[1] = n;
-	return(vp);
+	return (vp);
 }
 
 int nstacks;
 c1_t l_stacks[MAXSTACKS];
-set_t ustackset,cstackset;
+set_t ustackset, cstackset;
 
-n_stack(s,e,p,vi) struct varinfo *vi; {
+void n_stack(int s, int e, int p, struct varinfo *vi)
+{
 	register c1_p c1p;
 	register short *sp;
-	register i;
+	register int i;
 
-	NEXT(nstacks,MAXSTACKS,"Stacks");
+	NEXT(nstacks, MAXSTACKS, "Stacks");
-	c1p= & l_stacks[nstacks-1];
+	c1p = &l_stacks[nstacks - 1];
 	c1p->c1_texpno = s;
 	c1p->c1_expr = e;
 	c1p->c1_prop = p;
 	c1p->c1_codep = codeindex;
-	dopattern(0,VI_NULL,VI_NULL,vi,VI_NULL,VI_NULL);
+	dopattern(0, VI_NULL, VI_NULL, vi, VI_NULL, VI_NULL);
 
-	if (e==0 && p== -1)
+	if (e == 0 && p == -1)
 		sp = ustackset.set_val;
 	else
 		sp = cstackset.set_val;
-	for(i=0;i<SETSIZE;i++)
+	for (i = 0; i < SETSIZE; i++)
 		sp[i] |= l_sets[s].set_val[i];
 }
 
-void
+void checkstacking(register short *sp)
-checkstacking(sp) register short *sp; {
+{
-	register i;
+	register int i;
 	register short *chkset;
 	char *warn;
 
-	if (subset(sp,ustackset.set_val,SETSIZE))
+	if (subset(sp, ustackset.set_val, SETSIZE))
 		return;
-	chkset = ustackset.set_val; warn = "";
+	chkset = ustackset.set_val;
-	for (i=1;i<nregs;i++)
+	warn = "";
-		if (BIT(sp,i) && !BIT(chkset,i))
+	for (i = 1; i < nregs; i++)
-			error("No %sstacking rule for register %s",warn,
+		if (BIT(sp,i) && !BIT(chkset, i))
-				l_regs[i].ri_name);
+			error("No %sstacking rule for register %s", warn,
-	for(;i<nregs+MAXTOKENS;i++)
+					l_regs[i].ri_name);
-		if (BIT(sp,i) && !BIT(chkset,i))
+	for (; i < nregs + MAXTOKENS; i++)
-			error("No %sstacking rule for token %s",warn,
+		if (BIT(sp,i) && !BIT(chkset, i))
-				l_tokens[i-nregs]->tk_name);
+			error("No %sstacking rule for token %s", warn,
+					l_tokens[i - nregs]->tk_name);
 }
 
 int ncoercs;
@@ -189,78 +208,89 @@ set_t unstackset;
 
 /*VARARGS5*/
 
-void
+void n_coerc(int ti, int be, struct varinfo *al, struct varinfo *ge, struct varinfo *rp, iocc_t in)
-n_coerc(ti,be,al,ge,rp,in) struct varinfo *al,*ge,*rp; iocc_t in; {
+{
 	register c3_p c3p;
-	register i;
+	register int i;
 	register struct varinfo *vi;
 
-	if (ti!=0) {
+	if (ti != 0)
-		for(i=0,vi=rp;vi!=0;vi=vi->vi_next,i++)
+	{
+		for (i = 0, vi = rp; vi != 0; vi = vi->vi_next, i++)
 			;
-		if (i>1) {
+		if (i > 1)
-			n_split(ti,be,al,ge,rp,i);
+		{
+			n_split(ti, be, al, ge, rp, i);
 			return;
-		} else {
+		}
-			if (i==0) {
+		else
+		{
+			if (i == 0)
+			{
 				error("Coercion should have a result!");
 				return;
 			}
 		}
-	} else {
+	}
-		NEW(rp,struct varinfo);
+	else
+	{
+		NEW(rp, struct varinfo);
 		rp->vi_next = 0;
 		rp->vi_int[0] = in.in_index;
 	}
-	if (nallreg>1)
+	if (nallreg > 1)
 		error("More than 1 register may not be allocated");
-	NEXT(ncoercs,MAXCOERCS,"Coercions");
+	NEXT(ncoercs, MAXCOERCS, "Coercions");
-	c3p = & l_coercs[ncoercs-1];
+	c3p = &l_coercs[ncoercs - 1];
 	c3p->c3_texpno = ti;
 	c3p->c3_expr = be;
-	c3p->c3_prop = nallreg==0 ? -1 : allreg[0];
+	c3p->c3_prop = nallreg == 0 ? -1 : allreg[0];
 	c3p->c3_repl = rp->vi_int[0];
 	c3p->c3_codep = codeindex;
-	dopattern(ti==0,VI_NULL,al,ge,rp,VI_NULL);
+	dopattern(ti == 0, VI_NULL, al, ge, rp, VI_NULL);
-	if (ti==0)
+	if (ti == 0)
-		for(i=0;i<SETSIZE;i++)
+		for (i = 0; i < SETSIZE; i++)
 			unstackset.set_val[i] |= in.in_set[i];
 	freevi(rp);
 }
 
-checkunstacking(setno) {
+void checkunstacking(int setno)
+{
 	register short *sp;
-	register i;
+	register int i;
 	short hallset[SETSIZE];
-	
+
 	sp = l_sets[setno].set_val;
-	for (i=0;i<SETSIZE;i++)
+	for (i = 0; i < SETSIZE; i++)
-		hallset[i]=sp[i]&unstackset.set_val[i];
+		hallset[i] = sp[i] & unstackset.set_val[i];
 	nexthall(hallset);
 }
 
-int nsplit,maxsplit;
+int nsplit, maxsplit;
 c2_t l_split[MAXSPLCOERC];
 
-n_split(ti,be,al,ge,rp,n) struct varinfo *al,*ge,*rp; {
+void n_split(int ti, int be, struct varinfo *al, struct varinfo *ge, struct varinfo *rp, int n)
+{
 	register c2_p c2p;
-	register i;
+	register int i;
 	register struct varinfo *vi;
 
-	NEXT(nsplit,MAXSPLCOERC,"Splitting coercions");
+	NEXT(nsplit, MAXSPLCOERC, "Splitting coercions");
-	c2p = &l_split[nsplit-1];
+	c2p = &l_split[nsplit - 1];
-	if (n>MAXSPLIT) {
+	if (n > MAXSPLIT)
-		error("Maximum split factor is %d",MAXSPLIT);
+	{
+		error("Maximum split factor is %d", MAXSPLIT);
 		n = MAXSPLIT;
 	}
-	if (n>maxsplit) maxsplit=n;
+	if (n > maxsplit)
+		maxsplit = n;
 	c2p->c2_texpno = ti;
 	c2p->c2_expr = be;
 	if (nallreg)
 		error("No register uses allowed in splitting coercion");
 	c2p->c2_nsplit = n;
-	for (i=0,vi=rp; i<n; i++,vi=vi->vi_next)
+	for (i = 0, vi = rp; i < n; i++, vi = vi->vi_next)
 		c2p->c2_repl[i] = vi->vi_int[0];
 	c2p->c2_codep = codeindex;
-	dopattern(0,VI_NULL,al,ge,rp,VI_NULL);
+	dopattern(0, VI_NULL, al, ge, rp, VI_NULL);
 }

util/ncgg/coerc.h

@@ -0,0 +1,30 @@
+/*  Copyright (c) 2019 ACK Project.
+ *  See the copyright notice in the ACK home directory, 
+ *  in the file "Copyright".
+ *
+ *  Created on: 2019-05-03
+ *  
+ */
+#ifndef COERC_H_
+#define COERC_H_
+
+#include "iocc.h"
+
+struct varinfo;
+
+
+void n_move(int s1, int e1, int s2, int e2, struct varinfo *vi);
+int existalmove(iocc_t from, int prpno);
+struct varinfo *gen_move(iocc_t from, iocc_t to);
+void n_test(int s, int e, struct varinfo *vi);
+struct varinfo *gen_test(iocc_t from);
+struct varinfo *gen_label(int arg);
+struct varinfo *gen_preturn(void);
+struct varinfo *gen_tlab(int n);
+void n_stack(int s, int e, int p, struct varinfo *vi);
+void checkstacking(register short *sp);
+/* cgg.y is buggy!!! it has one less parameter.. */
+/*void n_coerc(int ti, int be, struct varinfo *al, struct varinfo *ge, struct varinfo *rp, iocc_t in);*/
+void checkunstacking(int setno);
+
+#endif /* COERC_H_ */

util/ncgg/emlookup.c

@@ -3,7 +3,7 @@
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
 #ifndef NORCSID
-static char rcsid[]= "$Id$";
+static char rcsid[] = "$Id$";
 #endif
 
 #include <stdlib.h>
@@ -18,64 +18,76 @@ extern char em_mnem[][4];
 
 #define HASHSIZE        (2*(sp_lmnem-sp_fmnem))
 
-struct emhashmnem {
+struct emhashmnem
+{
 	char h_name[3];
 	char h_value;
 } emhashmnem[HASHSIZE];
 
-initemhash() {
+/* Forward declarations */
-	register i;
+static void enter(char *, int);
+static unsigned emhash(register char *);
 
-	for(i=0;i<=sp_lmnem-sp_fmnem;i++)
+
-		enter(em_mnem[i],i+sp_fmnem);
+void initemhash(void)
+{
+	register int i;
+
+	for (i = 0; i <= sp_lmnem - sp_fmnem; i++)
+		enter(em_mnem[i], i + sp_fmnem);
 	enter("lab", op_lab);
 }
 
-unsigned emhash(name) register char *name; {
+static unsigned emhash(register char *name)
-	register unsigned sum;
+{
-	register i;
+	register unsigned int sum;
+	register int i;
 
-	for (sum=i=0;*name;i+=3)
+	for (sum = i = 0; *name; i += 3)
-		sum ^= (*name++)<<(i&07);
+		sum ^= (*name++) << (i & 07);
-	return(sum);
+	return (sum);
 }
 
-enter(name,value) char *name; {
+static void enter(char *name, int value)
+{
 	register unsigned h;
 
-	h=emhash(name)%HASHSIZE;
+	h = emhash(name) % HASHSIZE;
 	while (emhashmnem[h].h_name[0] != 0)
-		h = (h+1)%HASHSIZE;
+		h = (h + 1) % HASHSIZE;
-	strncpy(emhashmnem[h].h_name,name,3);
+	strncpy(emhashmnem[h].h_name, name, 3);
 	emhashmnem[h].h_value = value;
 }
 
-int mlookup(name) char *name; {
+int mlookup(char *name)
+{
 	register unsigned h;
 
-	h = emhash(name)%HASHSIZE;
+	h = emhash(name) % HASHSIZE;
-	while (strncmp(emhashmnem[h].h_name,name,3) != 0 &&
+	while (strncmp(emhashmnem[h].h_name, name, 3) != 0
-	       emhashmnem[h].h_name[0] != 0)
+			&& emhashmnem[h].h_name[0] != 0)
-		h = (h+1)%HASHSIZE;
+		h = (h + 1) % HASHSIZE;
-	return(emhashmnem[h].h_value&0xFF);      /* 0 if not found */
+	return (emhashmnem[h].h_value & 0xFF); /* 0 if not found */
 }
 
 extern char em_flag[];
 
-argtyp(mn) {
+int argtyp(int mn)
+{
 
-	switch(em_flag[mn-sp_fmnem]&EM_PAR) {
+	switch (em_flag[mn - sp_fmnem] & EM_PAR)
-	case PAR_W:
+	{
-	case PAR_S:
+		case PAR_W:
-	case PAR_Z:
+		case PAR_S:
-	case PAR_O:
+		case PAR_Z:
-	case PAR_N:
+		case PAR_O:
-	case PAR_L:
+		case PAR_N:
-	case PAR_F:
+		case PAR_L:
-	case PAR_R:
+		case PAR_F:
-	case PAR_C:
+		case PAR_R:
-		return(TYPINT);
+		case PAR_C:
-	default:
+			return (TYPINT);
-		return(TYPADDR);
+		default:
+			return (TYPADDR);
 	}
 }

util/ncgg/error.c

@@ -13,12 +13,12 @@ static char rcsid[]= "$Id$";
 
 int nerrors=0;
 
-yyerror(s) char *s; {
+void yyerror(char *s)
-
+{
 	error("Parser gives %s",s);
 }
 
-goodbye() {
+void goodbye(void) {
 
 	error("This was fatal, goodbye!");
 #ifndef NDEBUG
@@ -60,7 +60,8 @@ void error(const char* s, ...)
 	va_end(ap);
 }
 
-tabovf(string) char *string; {
+int tabovf(char *string)
-
+{
 	fatal("%s overflow",string);
+	return 0;
 }

util/ncgg/expr.c

@@ -3,7 +3,7 @@
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
 #ifndef NORCSID
-static char rcsid[]= "$Id$";
+static char rcsid[] = "$Id$";
 #endif
 
 #include <assert.h>
@@ -24,263 +24,308 @@ static char rcsid[]= "$Id$";
 
 extern set_t l_sets[];
 
-i_expr(e) expr_t e; {
+int i_expr(expr_t e)
+{
 
 	if (e.ex_typ != TYPINT)
 		error("Expression should be integer");
-	return(e.ex_index);
+	return (e.ex_index);
 }
 
-b_expr(e) expr_t e; {
+int b_expr(expr_t e)
+{
 	if (e.ex_typ != TYPBOOL)
 		error("Expression should be boolean");
-	return(e.ex_index);
+	return (e.ex_index);
 }
 
-expr_t make_expr(type,operator,op1,op2) {
+expr_t make_expr(int type, int operator, int op1, int op2)
+{
 	expr_t result;
 
-	result.ex_typ=type;
+	result.ex_typ = type;
-	result.ex_index=ex_lookup(operator,op1,op2);
+	result.ex_index = ex_lookup(operator, op1, op2);
-	return(result);
+	return (result);
 }
 
-expr_t regno_expr(regno) {
+expr_t regno_expr(int regno)
+{
 	expr_t result;
-	register i;
+	register int i;
 
 	result.ex_typ = TYPREG;
-	result.ex_index = ex_lookup(EX_REG,regno,0);
+	result.ex_index = ex_lookup(EX_REG, regno, 0);
-	for (i=0;i<SZOFSET(MAXREGS);i++)
+	for (i = 0; i < SZOFSET(MAXREGS); i++)
 		result.ex_regset[i] = 0;
-	BIS(result.ex_regset,regno);
+	BIS(result.ex_regset, regno);
-	return(result);
+	return (result);
 }
 
-expr_t ident_expr(name) char *name; {
+expr_t ident_expr(char *name)
+{
 	register symbol *sy_p;
 
-	sy_p = lookup(name,symany,mustexist);
+	sy_p = lookup(name, symany, mustexist);
-	if (sy_p->sy_type==symconst)
+	if (sy_p->sy_type == symconst)
-		return(make_expr(TYPINT,EX_CON,
+		return (make_expr(TYPINT, EX_CON,
-			   (int) (sy_p->sy_value.syv_cstval&0xFFFF),
+				(int) (sy_p->sy_value.syv_cstval & 0xFFFF),
-			   (int) (sy_p->sy_value.syv_cstval>>16)));
+				(int) (sy_p->sy_value.syv_cstval >> 16)));
-	else if (sy_p->sy_type==symsconst)
+	else if (sy_p->sy_type == symsconst)
-		return(make_expr(TYPADDR,EX_STRING,sy_p->sy_value.syv_stringno,0));
+		return (make_expr(TYPADDR, EX_STRING, sy_p->sy_value.syv_stringno, 0));
-	else if (sy_p->sy_type!=symreg)
+	else if (sy_p->sy_type != symreg)
-		error("Wrong type of identifier %s",name);
+		error("Wrong type of identifier %s", name);
-	return(regno_expr(sy_p->sy_value.syv_regno));
+	return (regno_expr(sy_p->sy_value.syv_regno));
 }
 
-expr_t subreg_expr(tokarg,subreg) {
+expr_t subreg_expr(int tokarg, int subreg)
+{
 	expr_t result;
 
 	result.ex_typ = TYPREG;
-	subregset(l_sets[tokpatset[tokarg > 0 ? tokarg-1 : tokarg]].set_val,
+	subregset(l_sets[tokpatset[tokarg > 0 ? tokarg - 1 : tokarg]].set_val,
-		  subreg,result.ex_regset);
+			subreg, result.ex_regset);
-	result.ex_index = ex_lookup(EX_SUBREG,tokarg,subreg);
+	result.ex_index = ex_lookup(EX_SUBREG, tokarg, subreg);
-	return(result);
+	return (result);
 }
 
-subregset(sp,subreg,regset) register short *sp; register short *regset; {
+void subregset(register short *sp, int subreg, register short *regset)
-	register i;
+{
+	register int i;
 	register reginfo *rp;
 
-	for (i=0;i<SZOFSET(MAXREGS);i++)
+	for (i = 0; i < SZOFSET(MAXREGS); i++)
-		regset[i]=0;
+		regset[i] = 0;
-	for (i=1;i<nregs;i++)	if (BIT(sp,i)) {
+	for (i = 1; i < nregs; i++)
-		if(subreg) {
+		if (BIT(sp, i))
-			rp = &l_regs[i];
+		{
-			if (rp->ri_memb[subreg-1]==0)
+			if (subreg)
-				error("Register %s in set has no member %d",
+			{
-					rp->ri_name,subreg);
+				rp = &l_regs[i];
-			BIS(regset,rp->ri_memb[subreg-1]);
+				if (rp->ri_memb[subreg - 1] == 0)
-		} else
+					error("Register %s in set has no member %d", rp->ri_name,
-			BIS(regset,i);
+							subreg);
-	}
+				BIS(regset, rp->ri_memb[subreg - 1]);
-	for(;i<nregs+MAXTOKENS;i++) if(BIT(sp,i))
+			}
-		error("Set contains %s, which is not a register",
+			else
-			l_tokens[i-nregs]->tk_name);
+				BIS(regset, i);
+		}
+	for (; i < nregs + MAXTOKENS; i++)
+		if (BIT(sp, i))
+			error("Set contains %s, which is not a register",
+					l_tokens[i - nregs]->tk_name);
 }
 
-membset(setno,name,regset,appearance,restyp,typp)
+int membset(int setno, char *name, short *regset, char *appearance, int restyp, int *typp)
-char *name,*appearance;
-short *regset;
-int *typp;
 {
 	register short *sp;
 	register token_p tp;
-	register i,j,k;
+	register int i, j, k;
 	int thistyp;
-	int typesdiffer=0;
+	int typesdiffer = 0;
-	int res_j= -1;
+	int res_j = -1;
 
-	if (setno < 0) return 0;
+	if (setno < 0)
+		return 0;
 	sp = l_sets[setno].set_val;
-	for (i=1;i<nregs;i++) if (BIT(sp,i)) {
+	for (i = 1; i < nregs; i++)
-		error("Set in %s contains %s, which is not a token",
+		if (BIT(sp, i))
-			appearance,l_regs[i].ri_name);
+		{
-		break;
+			error("Set in %s contains %s, which is not a token", appearance,
-	}
+					l_regs[i].ri_name);
-	for (i=0;i<SZOFSET(MAXREGS);i++)
+			break;
+		}
+	for (i = 0; i < SZOFSET(MAXREGS); i++)
 		regset[i] = 0;
-	for (i=nregs;i<nregs+MAXTOKENS;i++) if (BIT(sp,i)) {
+	for (i = nregs; i < nregs + MAXTOKENS; i++)
-		tp = l_tokens[i-nregs];
+		if (BIT(sp, i))
-		for(j=0;j<MAXATT &&
+		{
-		        (tp->tk_att[j].ta_type == -3 ||
+			tp = l_tokens[i - nregs];
-			 strcmp(tp->tk_att[j].ta_name,name));j++)
+			for (j = 0;
-			;
+					j < MAXATT
-		if (j==MAXATT)
+							&& (tp->tk_att[j].ta_type == -3
-			error("Token %s does not contain %s",tp->tk_name,name);
+									|| strcmp(tp->tk_att[j].ta_name, name));
-		else if (j!=res_j && res_j != -1)
+					j++)
-			typesdiffer=1;
+				;
-		else {
+			if (j == MAXATT)
-			res_j = j;
+				error("Token %s does not contain %s", tp->tk_name, name);
-			thistyp = tp->tk_att[j].ta_type;
+			else if (j != res_j && res_j != -1)
-			if (thistyp== -2) {
+				typesdiffer = 1;
-				if (restyp!=TYPADDR && restyp!=0)
+			else
-					typesdiffer=1;
+			{
+				res_j = j;
+				thistyp = tp->tk_att[j].ta_type;
+				if (thistyp == -2)
+				{
+					if (restyp != TYPADDR && restyp != 0)
+						typesdiffer = 1;
+					else
+						restyp = TYPADDR;
+				}
+				else if (thistyp == -1)
+				{
+					if (restyp != TYPINT && restyp != 0)
+						typesdiffer = 1;
+					else
+						restyp = TYPINT;
+				}
 				else
-					restyp=TYPADDR;
+				{
-			} else if (thistyp== -1) {
+					if (restyp != TYPREG && restyp != 0)
-				if (restyp!=TYPINT && restyp!=0)
+						typesdiffer = 1;
-					typesdiffer=1;
+					else
-				else
+					{
-					restyp=TYPINT;
+						restyp = TYPREG;
-			} else {
+						for (k = 0; k < SZOFSET(MAXREGS); k++)
-				if (restyp!=TYPREG && restyp!=0)
+							regset[k] |=
-					typesdiffer=1;
+									l_props[tp->tk_att[j].ta_type].pr_regset[k];
-				else {
+					}
-					restyp=TYPREG;
-					for(k=0;k<SZOFSET(MAXREGS);k++)
-						regset[k] |=
-						    l_props[tp->tk_att[j].ta_type].pr_regset[k];
 				}
 			}
 		}
-	}
 	if (typesdiffer)
 		error("%s is not a valid expression; types differ in the set",
-			appearance);
+				appearance);
-	*typp = restyp==0 ? TYPINT : restyp;
+	*typp = restyp == 0 ? TYPINT : restyp;
-	return(res_j == -1 ? 0 : res_j);
+	return (res_j == -1 ? 0 : res_j);
 }
 
-expr_t memb_expr(setno,name,appearance,tokarg) char *name,*appearance; {
+expr_t memb_expr(int setno, char *name, char *appearance, int tokarg)
+{
 	expr_t result;
 	int res_j;
 
-	res_j = membset(setno,name,result.ex_regset,appearance,0,&result.ex_typ);
+	res_j = membset(setno, name, result.ex_regset, appearance, 0,
-	result.ex_index = ex_lookup(EX_TOKFIELD,tokarg,res_j+1);
+			&result.ex_typ);
-	return(result);
+	result.ex_index = ex_lookup(EX_TOKFIELD, tokarg, res_j + 1);
+	return (result);
 }
 
-expr_t tokm_expr(tokarg,name) char *name; {
+expr_t tokm_expr(int tokarg, char *name)
+{
 	char app[100];
 	int tokarg1 = tokarg > 0 ? tokarg : 1;
 
-	sprintf(app,"%%%d.%s",tokarg1,name);
+	sprintf(app, "%%%d.%s", tokarg1, name);
-	return(memb_expr(tokpatset[tokarg1-1],name,app,tokarg));
+	return (memb_expr(tokpatset[tokarg1 - 1], name, app, tokarg));
 }
 
-expr_t perc_ident_expr(name) char *name; {
+expr_t perc_ident_expr(char *name)
+{
 	char app[100];
 
-	sprintf(app,"%%%s",name);
+	sprintf(app, "%%%s", name);
-	return(memb_expr(cursetno,name,app,0));
+	return (memb_expr(cursetno, name, app, 0));
 }
 
-expr_t all_expr(all_no,subreg) {
+expr_t all_expr(int all_no, int subreg)
+{
 	set_t localset;
-	register i;
+	register int i;
 	register short *sp;
 	expr_t result;
 
 	sp = l_props[allreg[all_no]].pr_regset;
-	for (i=0;i<SETSIZE;i++)
+	for (i = 0; i < SETSIZE; i++)
-		localset.set_val[i] = i<SZOFSET(MAXREGS) ? sp[i] : 0;
+		localset.set_val[i] = i < SZOFSET(MAXREGS) ? sp[i] : 0;
-	subregset(localset.set_val,subreg,result.ex_regset);
+	subregset(localset.set_val, subreg, result.ex_regset);
 	result.ex_typ = TYPREG;
-	result.ex_index = ex_lookup(EX_ALLREG,all_no+1,subreg);
+	result.ex_index = ex_lookup(EX_ALLREG, all_no + 1, subreg);
-	return(result);
+	return (result);
 }
 
-eq2expr(e1,e2) expr_t e1,e2; {
+int eq2expr(expr_t e1, expr_t e2)
+{
 
 	if (e1.ex_typ != e2.ex_typ)
 		error("Expressions around == should have equal type");
-	switch (e1.ex_typ) {
+	switch (e1.ex_typ)
-	default: assert(0);
+	{
-	case TYPBOOL:
+		default:
-		error("== on booleans not implemented");
+			assert(0);
-	case TYPINT:
+		case TYPBOOL:
-		return(EX_NCPEQ);
+			error("== on booleans not implemented");
-	case TYPADDR:
+		case TYPINT:
-		return(EX_SCPEQ);
+			return (EX_NCPEQ);
-	case TYPREG:
+		case TYPADDR:
-		return(EX_RCPEQ);
+			return (EX_SCPEQ);
+		case TYPREG:
+			return (EX_RCPEQ);
 	}
 }
 
-ne2expr(e1,e2) expr_t e1,e2; {
+int ne2expr(expr_t e1, expr_t e2)
+{
 
 	if (e1.ex_typ != e2.ex_typ)
 		error("Expressions around != should have equal type");
-	switch (e1.ex_typ) {
+	switch (e1.ex_typ)
-	default: assert(0);
+	{
-	case TYPBOOL:
+		default:
-		error("!= on booleans not implemented");
+			assert(0);
-	case TYPINT:
+		case TYPBOOL:
-		return(EX_NCPNE);
+			error("!= on booleans not implemented");
-	case TYPADDR:
+		case TYPINT:
-		return(EX_SCPNE);
+			return (EX_NCPNE);
-	case TYPREG:
+		case TYPADDR:
-		return(EX_RCPNE);
+			return (EX_SCPNE);
+		case TYPREG:
+			return (EX_RCPNE);
 	}
 }
 
-expr_t sum_expr(e1,e2) expr_t e1,e2; {
+expr_t sum_expr(expr_t e1, expr_t e2)
-	int operator,op1,op2;
+{
+	int operator, op1, op2;
 	expr_t result;
 
-	operator = EX_CAT; op1 = e1.ex_index; op2 = e2.ex_index;
+	operator = EX_CAT;
-	if (e1.ex_typ==e2.ex_typ) {
+	op1 = e1.ex_index;
+	op2 = e2.ex_index;
+	if (e1.ex_typ == e2.ex_typ)
+	{
 		result.ex_typ = e1.ex_typ;
 		if (e1.ex_typ == TYPINT)
 			operator = EX_PLUS;
 		else if (e1.ex_typ != TYPADDR)
 			error("+ is not implemented on this type");
-	} else {
+	}
+	else
+	{
 		result.ex_typ = TYPADDR;
-		if (e1.ex_typ != TYPADDR) {
+		if (e1.ex_typ != TYPADDR)
-			if (e1.ex_typ!=TYPINT)
+		{
+			if (e1.ex_typ != TYPINT)
 				error("Wrong left operand of +");
-			op1 = ex_lookup(EX_TOSTRING,op1,0);
+			op1 = ex_lookup(EX_TOSTRING, op1, 0);
 		}
-		if (e2.ex_typ != TYPADDR) {
+		if (e2.ex_typ != TYPADDR)
-			if (e2.ex_typ!=TYPINT)
+		{
+			if (e2.ex_typ != TYPINT)
 				error("Wrong right operand of +");
-			op2 = ex_lookup(EX_TOSTRING,op2,0);
+			op2 = ex_lookup(EX_TOSTRING, op2, 0);
 		}
 	}
-	result.ex_index=ex_lookup(operator,op1,op2);
+	result.ex_index = ex_lookup(operator, op1, op2);
-	return(result);
+	return (result);
 }
 
-expr_t iextoaddr(e) expr_t e; {
+expr_t iextoaddr(expr_t e)
+{
 	expr_t result;
 
 	result.ex_typ = TYPADDR;
-	result.ex_index = ex_lookup(EX_TOSTRING,e.ex_index,0);
+	result.ex_index = ex_lookup(EX_TOSTRING, e.ex_index, 0);
-	return(result);
+	return (result);
 }
 
-expr_t regvar_expr(e,regtyp,regsiz) expr_t e; {
+expr_t regvar_expr(expr_t e, int regtyp, int regsiz)
+{
 	expr_t result;
 	int i, regno, s, two_sizes;
 
 	two_sizes = (regtyp == reg_float && reglap != 0);
-	if (regsiz == -1) {
+	if (regsiz == -1)
+	{
 		/* reglap: Can't guess between 2 sizes of reg_float. */
 		if (two_sizes && regsiz == -1)
 			error("Must use regvar_w() or regvar_d()");
@@ -288,36 +333,40 @@ expr_t regvar_expr(e,regtyp,regsiz) expr_t e; {
 			regsiz = rvsize[regtyp];
 	}
 
-	result = make_expr(TYPREG,EX_REGVAR,i_expr(e),regsiz);
+	result = make_expr(TYPREG, EX_REGVAR, i_expr(e), regsiz);
-	for(i=0;i<SZOFSET(MAXREGS);i++)
+	for (i = 0; i < SZOFSET(MAXREGS); i++)
-		result.ex_regset[i]=0;
+		result.ex_regset[i] = 0;
 
 	/* s = the size of the registers in rvnumbers[regtyp] */
 	s = two_sizes ? reglap : rvsize[regtyp];
-	if (s == regsiz) {
+	if (s == regsiz)
-		for(i=0;i<nregvar[regtyp];i++)
+	{
-			BIS(result.ex_regset,rvnumbers[regtyp][i]);
+		for (i = 0; i < nregvar[regtyp]; i++)
+			BIS(result.ex_regset, rvnumbers[regtyp][i]);
 	}
 	/* reglap: Also check the 2nd size of reg_float. */
-	if (two_sizes && rvsize[regtyp] == regsiz) {
+	if (two_sizes && rvsize[regtyp] == regsiz)
-		for(i=0;i<nregvar[regtyp];i++) {
+	{
+		for (i = 0; i < nregvar[regtyp]; i++)
+		{
 			/* regno = first subregister */
 			regno = l_regs[rvnumbers[regtyp][i]].ri_memb[0];
 			if (regno != 0)
 				BIS(result.ex_regset, regno);
 		}
 	}
-	return(result);
+	return (result);
 }
-		
+
 /*
  * Node table lookup part
  */
 
 node_t nodes[MAXNODES];
-int nnodes=0;
+int nnodes = 0;
 
-initnodes() {
+void initnodes(void)
+{
 
 	nodes[0].ex_operator = EX_CON;
 	nodes[0].ex_lnode = 0;
@@ -325,21 +374,23 @@ initnodes() {
 	nnodes++;
 }
 
-ex_lookup(operator,lnode,rnode) {
+int ex_lookup(int operator, int lnode, int rnode)
+{
 	register node_p p;
 
-	for(p=nodes+1;p< &nodes[nnodes];p++) {
+	for (p = nodes + 1; p < &nodes[nnodes]; p++)
+	{
 		if (p->ex_operator != operator)
 			continue;
 		if (p->ex_lnode != lnode)
 			continue;
 		if (p->ex_rnode != rnode)
 			continue;
-		return(p-nodes);
+		return (p - nodes);
 	}
-	NEXT(nnodes,MAXNODES,"Node");
+	NEXT(nnodes, MAXNODES, "Node");
 	p->ex_operator = operator;
 	p->ex_lnode = lnode;
 	p->ex_rnode = rnode;
-	return(p-nodes);
+	return (p - nodes);
 }

util/ncgg/expr.h

@@ -3,6 +3,8 @@
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
 /* $Id$ */
+#ifndef EXPR_H_
+#define EXPR_H_
 
 typedef struct expr {
 	int	ex_typ;
@@ -15,6 +17,27 @@ typedef struct expr {
 #define TYPADDR 3
 #define TYPREG  4
 
+int ex_lookup(int operator, int lnode, int rnode);
+void initnodes(void);
+expr_t regvar_expr(expr_t e, int regtyp, int regsiz);
+expr_t iextoaddr(expr_t e);
+expr_t sum_expr(expr_t e1, expr_t e2);
+int ne2expr(expr_t e1, expr_t e2);
+int eq2expr(expr_t e1, expr_t e2);
+expr_t all_expr(int all_no, int subreg);
+expr_t perc_ident_expr(char *name);
+expr_t tokm_expr(int tokarg, char *name);
+int membset(int setno, char *name, short *regset, char *appearance, int restyp, int *typp);
+void subregset(register short *sp, int subreg, register short *regset);
+expr_t subreg_expr(int tokarg, int subreg);
+expr_t ident_expr(char *name);
+expr_t make_expr(int type, int operator, int op1, int op2);
+int b_expr(expr_t e);
+int i_expr(expr_t e);
+
+
 /* When the type is register the regset contains the set of
    possible registers for checking purposes only.
 */
+
+#endif /* EXPR_H_ */

util/ncgg/extern.h

@@ -38,9 +38,8 @@ extern int maxtokensize;
 extern int nprocargs, maxprocargs;
 extern int use_tes;
 
-extern char *mystrcpy();
-extern char *myalloc();
-
 extern void error(const char* s, ...);
 extern void fatal(const char* s, ...);
-
+extern int tabovf(char *string);
+extern int strlookup(char *str);
+extern void errorexit(void);

util/ncgg/hall.c

@@ -3,18 +3,19 @@
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
 #ifndef NORCSID
-static char rcsid[]= "$Id$";
+static char rcsid[] = "$Id$";
 #endif
 
 #include <assert.h>
 #include "param.h"
 #include "set.h"
 #include "extern.h"
+#include "hall.h"
 #include <stdio.h>
 
 /*
  * This file implements the marriage thesis from Hall.
- * The thesis says that given a number, say N, of subsets from
+ * The thesis says that givoid hallverbose(void)ven a number, say N, of subsets from
  * a finite set, it is possible to create a set with cardinality N,
  * that contains one member for each of the subsets,
  * iff for each number, say M, of subsets from 2 to N the union of
@@ -29,56 +30,66 @@ static char rcsid[]= "$Id$";
 
 #define MAXHALL (TOKPATMAX+MAXALLREG)
 short hallsets[MAXHALL][SETSIZE];
-int nhallsets= -1;
+int nhallsets = -1;
 int hallfreq[MAXHALL][2];
 
-hallverbose() {
+int recurhall(int, short [][SETSIZE]);
-	register i;
+void unite(register short *, short *);
-	register max;
+
-	
+
-	fprintf(stderr,"Table of hall frequencies\n   #   pre   post\n");
+void hallverbose(void)
-	for (max=MAXHALL-1;hallfreq[max][0]==0 && hallfreq[max][1]==0;max--)
+{
+	register int i;
+	register int max;
+
+	fprintf(stderr, "Table of hall frequencies\n   #   pre   post\n");
+	for (max = MAXHALL - 1; hallfreq[max][0] == 0 && hallfreq[max][1] == 0;
+			max--)
 		;
-	for (i=0;i<=max;i++)
+	for (i = 0; i <= max; i++)
-		fprintf(stderr,"%3d%6d%6d\n",i,hallfreq[i][0],hallfreq[i][1]);
+		fprintf(stderr, "%3d%6d%6d\n", i, hallfreq[i][0], hallfreq[i][1]);
 }
 
-inithall() {
+void inithall(void)
+{
 
 	assert(nhallsets == -1);
-	nhallsets=0;
+	nhallsets = 0;
 }
 
-nexthall(sp) register short *sp; {
+void nexthall(register short *sp)
-	register i;
+{
-	
+	register int i;
-	assert(nhallsets>=0);
+
-	for(i=0;i<SETSIZE;i++)
+	assert(nhallsets >= 0);
+	for (i = 0; i < SETSIZE; i++)
 		hallsets[nhallsets][i] = sp[i];
 	nhallsets++;
 }
 
-card(sp) register short *sp; {
+int card(register short *sp)
-	register sum,i;
+{
-	
+	register int sum, i;
-	sum=0;
+
-	for(i=0;i<8*sizeof(short)*SETSIZE;i++)
+	sum = 0;
-		if (BIT(sp,i))
+	for (i = 0; i < 8 * sizeof(short) * SETSIZE; i++)
+		if (BIT(sp, i))
 			sum++;
-	return(sum);
+	return (sum);
 }
 
-checkhall() {
+void checkhall(void)
-
+{
-	assert(nhallsets>=0);
+	assert(nhallsets >= 0);
 	if (!hall())
 		error("Hall says: \"You can't have those registers\"");
 }
 
-hall() {
+int hall(void)
-	register i,j,k;
+{
+	register int i, j, k;
 	int ok;
-	
+
 	hallfreq[nhallsets][0]++;
 	/*
 	 * If a set has cardinality >= nhallsets it can never be the cause
@@ -86,66 +97,72 @@ hall() {
 	 * But then nhallsets is less, so this step can be re-applied.
 	 */
 
-	do {
+	do
+	{
 		ok = 0;
-		for(i=0;i<nhallsets;i++)
+		for (i = 0; i < nhallsets; i++)
-			if (card(hallsets[i])>=nhallsets) {
+			if (card(hallsets[i]) >= nhallsets)
-				for (j=i+1;j<nhallsets;j++)
+			{
-					for(k=0;k<SETSIZE;k++)
+				for (j = i + 1; j < nhallsets; j++)
-						hallsets[j-1][k] =
+					for (k = 0; k < SETSIZE; k++)
-							hallsets[j][k];
+						hallsets[j - 1][k] = hallsets[j][k];
 				nhallsets--;
 				ok = 1;
 				break;
 			}
 	} while (ok);
-	
+
 	/*
 	 * Now all sets have cardinality < nhallsets
 	 */
-	
+
 	hallfreq[nhallsets][1]++;
-	ok=recurhall(nhallsets,hallsets);
+	ok = recurhall(nhallsets, hallsets);
 	nhallsets = -1;
-	return(ok);
+	return (ok);
 }
 
-recurhall(nhallsets,hallsets) short hallsets[][SETSIZE]; {
+int recurhall(int nhallsets, short hallsets[][SETSIZE])
+{
 	short copysets[MAXHALL][SETSIZE];
 	short setsum[SETSIZE];
-	register i,j,k,ncopys;
+	register int i, j, k, ncopys;
-	
+
 	/*
 	 * First check cardinality of union of all
 	 */
-	for(k=0;k<SETSIZE;k++)
+	for (k = 0; k < SETSIZE; k++)
-		setsum[k]=0;
+		setsum[k] = 0;
-	for(i=0;i<nhallsets;i++)
+	for (i = 0; i < nhallsets; i++)
-		unite(hallsets[i],setsum);
+		unite(hallsets[i], setsum);
-	if (card(setsum)<nhallsets)
+	if (card(setsum) < nhallsets)
-		return(0);
+		return (0);
 	/*
 	 * Now check the hall property of everything but one set,
 	 * for all sets
 	 */
-	for(i=0;i<nhallsets;i++) {
+	for (i = 0; i < nhallsets; i++)
-		ncopys=0;
+	{
-		for(j=0;j<nhallsets;j++) if (j!=i) {
+		ncopys = 0;
-			for(k=0;k<SETSIZE;k++)
+		for (j = 0; j < nhallsets; j++)
-				copysets[ncopys][k] = hallsets[j][k];
+			if (j != i)
-			ncopys++;
+			{
-		}
+				for (k = 0; k < SETSIZE; k++)
-		assert(ncopys == nhallsets-1);
+					copysets[ncopys][k] = hallsets[j][k];
-		if (!recurhall(ncopys,copysets))
+				ncopys++;
-			return(0);
+			}
+		assert(ncopys == nhallsets - 1);
+		if (!recurhall(ncopys, copysets))
+			return (0);
 	}
-	return(1);
+	return (1);
 }
 
-unite(sp,into) register short *sp,*into; {
+void unite(register short *sp, short *into)
-	register i;
+{
-	
+	register int i;
-	for(i=0;i<SETSIZE;i++)
+
+	for (i = 0; i < SETSIZE; i++)
 		into[i] |= sp[i];
 }
 

util/ncgg/hall.h

@@ -0,0 +1,17 @@
+/*  Copyright (c) 2019 ACK Project.
+ *  See the copyright notice in the ACK home directory, 
+ *  in the file "Copyright".
+ *
+ *  Created on: 2019-05-03
+ *  
+ */
+#ifndef HALL_H_
+#define HALL_H_
+
+void hallverbose(void);
+void inithall(void);
+int hall(void);
+void checkhall(void);
+void nexthall(register short *sp);
+
+#endif /* HALL_H_ */

util/ncgg/instruct.c

@@ -3,7 +3,7 @@
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
 #ifndef NORCSID
-static char rcsid[]= "$Id$";
+static char rcsid[] = "$Id$";
 #endif
 
 #include <string.h>
@@ -14,192 +14,198 @@ static char rcsid[]= "$Id$";
 #include "set.h"
 #include "expr.h"
 #include "iocc.h"
+#include "subr.h"
 #include <cgg_cg.h>
 #include "extern.h"
 
 extern int niops;
 extern iocc_t iops[];
-extern inproc;
+extern int inproc;
 
 extern set_t l_sets[];
 extern inst_t l_instances[];
 
-extern expr_t subreg_expr(),regno_expr();
+extern expr_t subreg_expr(), regno_expr();
 
-struct varinfo * setcoco(n) {
+static struct varinfo * setcoco(int n)
+{
 	struct varinfo *vi;
-	
+
-	NEW(vi,struct varinfo);
+	NEW(vi, struct varinfo);
 	vi->vi_next = VI_NULL;
 	vi->vi_int[0] = INSSETCC;
 	vi->vi_int[1] = n;
-	return(vi);
+	return (vi);
 }
 
-struct varinfo * generase(n) {
+static struct varinfo * generase(int n)
+{
 	struct varinfo *vi;
 
-	NEW(vi,struct varinfo);
+	NEW(vi, struct varinfo);
 	vi->vi_next = VI_NULL;
 	vi->vi_int[0] = INSERASE;
 	vi->vi_int[1] = n;
-	return(vi);
+	return (vi);
 }
 
-struct varinfo * genremove(n) {
+static struct varinfo * genremove(int n)
+{
 	struct varinfo *vi;
 
-	NEW(vi,struct varinfo);
+	NEW(vi, struct varinfo);
 	vi->vi_next = VI_NULL;
 	vi->vi_int[0] = INSREMOVE;
 	vi->vi_int[1] = n;
-	return(vi);
+	return (vi);
 }
 
-onlyreg(argno) {
+static int onlyreg(int argno)
-	register bitno;
+{
+	register int bitno;
 	register short *sp;
-	
+
-	if (! argno) argno++;
+	if (!argno)
-	sp = l_sets[tokpatset[argno-1]].set_val;
+		argno++;
-	for(bitno=nregs;bitno<nregs+ntokens;bitno++)
+	sp = l_sets[tokpatset[argno - 1]].set_val;
-		if (BIT(sp,bitno))
+	for (bitno = nregs; bitno < nregs + ntokens; bitno++)
-			return(0);
+		if (BIT(sp, bitno))
-	return(1);
+			return (0);
+	return (1);
 }
 
-makescratch(argno) {
+static void makescratch(int argno)
+{
 	set_t s;
 
-	if (! argno) argno++;
+	if (!argno)
-	if (tokpatro[argno-1])
+		argno++;
-		error("Instruction destroys %%%d, not allowed here",argno);
+	if (tokpatro[argno - 1])
-	s = l_sets[tokpatset[argno-1]];
+		error("Instruction destroys %%%d, not allowed here", argno);
-	BIC(s.set_val,0);
+	s = l_sets[tokpatset[argno - 1]];
-	tokpatset[argno-1] = setlookup(s);
+	BIC(s.set_val, 0);
+	tokpatset[argno - 1] = setlookup(s);
 }
 
-struct varinfo *gen_inst(ident,star) char *ident; {
+struct varinfo *gen_inst(char *ident, int star)
-	register struct varinfo *vi,*retval,*eravi;
+{
+	register struct varinfo *vi, *retval, *eravi;
 	register instr_p ip;
 	register struct operand *op;
-	register i;
+	register int i;
 	register inst_p insta;
-	
+
 	if (star && !inproc)
 		error("Variable instruction only allowed inside proc");
-	for (ip=l_instr;ip<l_instr+ninstr;ip++) {
+	for (ip = l_instr; ip < l_instr + ninstr; ip++)
-		if(strcmp(ident,ip->i_name))
+	{
+		if (strcmp(ident, ip->i_name))
 			continue;
-		if (ip->i_nops!=niops)
+		if (ip->i_nops != niops)
 			continue;
-		for(i=0,op=ip->i_oplist;i<niops;i++,op=op->o_next) {
+		for (i = 0, op = ip->i_oplist; i < niops; i++, op = op->o_next)
-			if (!subset(iops[i].in_set,l_sets[op->o_setno].set_val,SETSIZE))
+		{
+			if (!subset(iops[i].in_set, l_sets[op->o_setno].set_val, SETSIZE))
 				goto cont;
 		}
-		goto found;		/* oh well, one more won't hurt */
+		goto found;
-	    cont:;
+		/* oh well, one more won't hurt */
+		cont: ;
 	}
-	error("Such an \"%s\" does not exist",ident);
+	error("Such an \"%s\" does not exist", ident);
-	return(0);
+	return (0);
-found:
+	found:
-	NEW(vi,struct varinfo);
+	NEW(vi, struct varinfo);
-	vi->vi_int[0] = ip-l_instr;
+	vi->vi_int[0] = ip - l_instr;
 	vi->vi_int[1] = star;
-	vi->vi_next=0;
+	vi->vi_next = 0;
 	retval = vi;
-	for(i=0;i<niops;i++) {
+	for (i = 0; i < niops; i++)
-		NEW(vi->vi_vi,struct varinfo);
+	{
-		vi=vi->vi_vi;
+		NEW(vi->vi_vi, struct varinfo);
+		vi = vi->vi_vi;
 		vi->vi_int[0] = iops[i].in_index;
 	}
 	vi->vi_vi = 0;
 	vi = retval;
-	for(i=0,op=ip->i_oplist;i<niops;i++,op=op->o_next) {
+	for (i = 0, op = ip->i_oplist; i < niops; i++, op = op->o_next)
-	    if(op->o_adorn&AD_CC) {
+	{
-		vi->vi_next = setcoco(iops[i].in_index);
+		if (op->o_adorn & AD_CC)
-		vi=vi->vi_next;
+		{
-	    }
+			vi->vi_next = setcoco(iops[i].in_index);
-	    switch(op->o_adorn&AD_RWMASK) {
-	    default:
-		/* Nothing possible to do */
-		break;
-	    case AD_RO:
-		/* It might be possible to do something
-		 * here but not now.
-		 */
-		break;
-	    case AD_RW:
-	    case AD_WO:
-		/* Treated the same for now */
-		insta = &l_instances[iops[i].in_index];
-		switch(insta->in_which) {
-		case IN_COPY:
-			if(insta->in_info[1]==0 && !onlyreg(insta->in_info[0]))
-				break;
-			makescratch(insta->in_info[0]);
-			vi->vi_next = generase(
-			               ex_lookup(
-				        EX_SUBREG,insta->in_info[0],
-					          insta->in_info[1]
-				       )
-				      );
 			vi = vi->vi_next;
-			break;
-		case IN_MEMB:
-			vi->vi_next = generase(
-				       ex_lookup(
-				        EX_TOKFIELD,insta->in_info[0],
-					            insta->in_info[1]
-				       )
-				      );
-			vi=vi->vi_next;
-			break;
-		case IN_RIDENT:
-			vi->vi_next = generase(
-				       ex_lookup(
-				        EX_REG,insta->in_info[0],0
-				       )
-				      );
-			vi = vi->vi_next;
-			break;
-		case IN_ALLOC:
-			vi->vi_next = generase(
-				       ex_lookup(
-				        EX_ALLREG,insta->in_info[0]+1,
-						  insta->in_info[1]
-				       )
-				      );
-			vi = vi->vi_next;
-			break;
-		case IN_S_DESCR:
-		case IN_D_DESCR:
-			{ int temp;
-
-			if (insta->in_which == IN_S_DESCR)
-				temp = wordsize;
-			else
-				temp = 2 * wordsize;
-			temp=ex_lookup(EX_REGVAR,insta->in_info[1],temp);
-			vi->vi_next = generase(temp);
-			vi = vi->vi_next;
-			vi->vi_next = genremove(temp);
-			vi = vi->vi_next;
-			break;
-			}
 		}
-		break;
+		switch (op->o_adorn & AD_RWMASK)
-	    }
+		{
+			default:
+				/* Nothing possible to do */
+				break;
+			case AD_RO:
+				/* It might be possible to do something
+				 * here but not now.
+				 */
+				break;
+			case AD_RW:
+			case AD_WO:
+				/* Treated the same for now */
+				insta = &l_instances[iops[i].in_index];
+				switch (insta->in_which)
+				{
+					case IN_COPY:
+						if (insta->in_info[1] == 0
+								&& !onlyreg(insta->in_info[0]))
+							break;
+						makescratch(insta->in_info[0]);
+						vi->vi_next = generase(ex_lookup(
+						EX_SUBREG, insta->in_info[0], insta->in_info[1]));
+						vi = vi->vi_next;
+						break;
+					case IN_MEMB:
+						vi->vi_next = generase(ex_lookup(
+						EX_TOKFIELD, insta->in_info[0], insta->in_info[1]));
+						vi = vi->vi_next;
+						break;
+					case IN_RIDENT:
+						vi->vi_next = generase(ex_lookup(
+						EX_REG, insta->in_info[0], 0));
+						vi = vi->vi_next;
+						break;
+					case IN_ALLOC:
+						vi->vi_next = generase(ex_lookup(
+						EX_ALLREG, insta->in_info[0] + 1, insta->in_info[1]));
+						vi = vi->vi_next;
+						break;
+					case IN_S_DESCR:
+					case IN_D_DESCR:
+					{
+						int temp;
+
+						if (insta->in_which == IN_S_DESCR)
+							temp = wordsize;
+						else
+							temp = 2 * wordsize;
+						temp = ex_lookup(EX_REGVAR, insta->in_info[1], temp);
+						vi->vi_next = generase(temp);
+						vi = vi->vi_next;
+						vi->vi_next = genremove(temp);
+						vi = vi->vi_next;
+						break;
+					}
+				}
+				break;
+		}
 	}
-	for (eravi=ip->i_erases;eravi != VI_NULL;eravi=eravi->vi_next) {
+	for (eravi = ip->i_erases; eravi != VI_NULL ; eravi = eravi->vi_next)
+	{
 		if (eravi->vi_int[0] < 0)
 			vi->vi_next = setcoco(0);
-		else {
+		else
+		{
 			vi->vi_next = generase(eravi->vi_int[0]);
-			vi=vi->vi_next;
+			vi = vi->vi_next;
 			vi->vi_next = genremove(eravi->vi_int[0]);
 		}
-		vi=vi->vi_next;
+		vi = vi->vi_next;
 	}
-	return(retval);
+	return (retval);
 }

util/ncgg/instruct.h

@@ -3,6 +3,8 @@
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
 /* $Id$ */
+#ifndef INSTRUCT_H_
+#define INSTRUCT_H_
 
 #ifndef _COST_
 #include "cost.h"
@@ -39,3 +41,8 @@ extern instr_t l_instr[];
  * if it contains the same information and is allowed as an operand
  * in this place. Too difficult for now.
  */
+struct varinfo;
+
+struct varinfo *gen_inst(char *ident, int star);
+
+#endif /* INSTRUCT_H_ */

util/ncgg/iocc.c

@@ -3,7 +3,7 @@
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
 #ifndef NORCSID
-static char rcsid[]= "$Id$";
+static char rcsid[] = "$Id$";
 #endif
 
 #include <assert.h>
@@ -14,6 +14,7 @@ static char rcsid[]= "$Id$";
 #include "set.h"
 #include "expr.h"
 #include "lookup.h"
+#include "subr.h"
 #include "token.h"
 #include "property.h"
 #include "iocc.h"
@@ -28,184 +29,204 @@ expr_t arexp[MAXATT];
 
 expr_t iextoaddr();
 
-iocc_t subr_iocc(tokarg,subreg) {
+/* Forward declarations */
+static int instalookup(inst_t, int);
+
+iocc_t subr_iocc(int tokarg, int subreg)
+{
 	inst_t insta;
-	iocc_t  result;
+	iocc_t result;
-	register i;
+	register int i;
 
 	insta.in_which = IN_COPY;
 	insta.in_info[0] = tokarg;
 	insta.in_info[1] = subreg;
-	result.in_index = instalookup(insta,2);
+	result.in_index = instalookup(insta, 2);
-	if (tokarg < 1) tokarg = 1;
+	if (tokarg < 1)
-	if (subreg==0)
+		tokarg = 1;
-		for (i=0;i<SETSIZE;i++)
+	if (subreg == 0)
-			result.in_set[i] = l_sets[tokpatset[tokarg-1]].set_val[i];
+		for (i = 0; i < SETSIZE; i++)
-	else {
+			result.in_set[i] = l_sets[tokpatset[tokarg - 1]].set_val[i];
-		for (i=0;i<SETSIZE;i++)
+	else
+	{
+		for (i = 0; i < SETSIZE; i++)
 			result.in_set[i] = 0;
-		subregset(l_sets[tokpatset[tokarg-1]].set_val,subreg,result.in_set);
+		subregset(l_sets[tokpatset[tokarg - 1]].set_val, subreg, result.in_set);
 	}
-	return(result);
+	return (result);
 }
 
-iocc_t tokm_iocc(tokarg,ident) char *ident; {
+iocc_t tokm_iocc(int tokarg, char *ident)
+{
 	iocc_t result;
 	inst_t insta;
-	register i;
+	register int i;
 	char app[100];
 	int dummy;
-	
+
-	for(i=0;i<SETSIZE;i++)
+	for (i = 0; i < SETSIZE; i++)
 		result.in_set[i] = 0;
 	insta.in_which = IN_MEMB;
 	insta.in_info[0] = tokarg;
-	if (tokarg < 1) tokarg = 1;
+	if (tokarg < 1)
-	sprintf(app,"%%%d.%s",tokarg,ident);
+		tokarg = 1;
-	insta.in_info[1] = 1+membset(tokpatset[tokarg-1],ident,result.in_set,
+	sprintf(app, "%%%d.%s", tokarg, ident);
-				    app,TYPREG,&dummy);
+	insta.in_info[1] = 1
-	result.in_index = instalookup(insta,2);
+			+ membset(tokpatset[tokarg - 1], ident, result.in_set, app, TYPREG,
-	return(result);
+					&dummy);
+	result.in_index = instalookup(insta, 2);
+	return (result);
 }
 
-iocc_t percident_iocc(ident) char *ident; {
+iocc_t percident_iocc(char *ident)
+{
 	iocc_t result;
 	inst_t insta;
-	register i;
+	register int i;
 	char app[100];
 	int dummy;
-	
+
-	for(i=0;i<SETSIZE;i++)
+	for (i = 0; i < SETSIZE; i++)
 		result.in_set[i] = 0;
 	insta.in_which = IN_MEMB;
 	insta.in_info[0] = 0;
-	sprintf(app,"%%%s",ident);
+	sprintf(app, "%%%s", ident);
-	insta.in_info[1] = 1+membset(cursetno,ident,result.in_set,
+	insta.in_info[1] = 1
-				    app,TYPREG,&dummy);
+			+ membset(cursetno, ident, result.in_set, app, TYPREG, &dummy);
-	result.in_index = instalookup(insta,2);
+	result.in_index = instalookup(insta, 2);
-	return(result);
+	return (result);
 }
 
-iocc_t ident_iocc(ident) char *ident; {
+iocc_t ident_iocc(char *ident)
+{
 	iocc_t result;
 	inst_t insta;
-	register i;
+	register int i;
 	register symbol *sy_p;
 
-	for(i=0;i<SETSIZE;i++)
+	for (i = 0; i < SETSIZE; i++)
 		result.in_set[i] = 0;
 	insta.in_which = IN_RIDENT;
-	sy_p = lookup(ident,symreg,mustexist);
+	sy_p = lookup(ident, symreg, mustexist);
 	insta.in_info[0] = sy_p->sy_value.syv_regno;
-	result.in_index = instalookup(insta,1);
+	result.in_index = instalookup(insta, 1);
-	BIS(result.in_set,sy_p->sy_value.syv_regno);
+	BIS(result.in_set, sy_p->sy_value.syv_regno);
-	return(result);
+	return (result);
 }
 
-iocc_t all_iocc(all_no,subreg) {
+iocc_t all_iocc(int all_no, int subreg)
+{
 	iocc_t result;
 	inst_t insta;
-	register i;
+	register int i;
 	set_t localset;
 	register short *sp;
 
 	sp = l_props[allreg[all_no]].pr_regset;
-	for (i=0;i<SETSIZE;i++)
+	for (i = 0; i < SETSIZE; i++)
-		localset.set_val[i] = i<SZOFSET(MAXREGS) ? sp[i] : 0;
+		localset.set_val[i] = i < SZOFSET(MAXREGS) ? sp[i] : 0;
-	for(i=0;i<SETSIZE;i++)
+	for (i = 0; i < SETSIZE; i++)
 		result.in_set[i] = 0;
 	insta.in_which = IN_ALLOC;
 	insta.in_info[0] = all_no;
 	insta.in_info[1] = subreg;
-	subregset(localset.set_val,subreg,result.in_set);
+	subregset(localset.set_val, subreg, result.in_set);
-	result.in_index = instalookup(insta,2);
+	result.in_index = instalookup(insta, 2);
-	return(result);
+	return (result);
 }
 
-iocc_t descr_iocc(ident) char *ident; {
+iocc_t descr_iocc(char *ident)
+{
 	iocc_t result;
 	inst_t insta;
 	register symbol *sy_p;
 	register token_p tp;
-	register i;
+	register int i;
 	int typerr;
 
-	for(i=0;i<SETSIZE;i++)
+	for (i = 0; i < SETSIZE; i++)
 		result.in_set[i] = 0;
-	sy_p = lookup(ident,symtok,mustexist);
+	sy_p = lookup(ident, symtok, mustexist);
 	tp = l_tokens[sy_p->sy_value.syv_tokno];
-	BIS(result.in_set,sy_p->sy_value.syv_tokno+nregs);
+	BIS(result.in_set, sy_p->sy_value.syv_tokno + nregs);
 	insta.in_which = IN_DESCR;
-	if (rvused&SL_REGVAR && strcmp(ident,"LOCAL")==0)
+	if (rvused & SL_REGVAR && strcmp(ident, "LOCAL") == 0)
 		insta.in_which = IN_S_DESCR;
-	else if (rvused&DL_REGVAR && strcmp(ident,"DLOCAL")==0)
+	else if (rvused & DL_REGVAR && strcmp(ident, "DLOCAL") == 0)
 		insta.in_which = IN_D_DESCR;
 	insta.in_info[0] = sy_p->sy_value.syv_tokno;
-	for (i=0;i<MAXATT;i++) {
+	for (i = 0; i < MAXATT; i++)
-		if (tp->tk_att[i].ta_type == -3) {
+	{
-			if (narexpr>i)
+		if (tp->tk_att[i].ta_type == -3)
-				error("token %s initialized with too many attributes",ident);
+		{
+			if (narexpr > i)
+				error("token %s initialized with too many attributes", ident);
 			break;
 		}
-		if (i>= narexpr) {
+		if (i >= narexpr)
-			error("token %s initialized with too few attributes",
+		{
-					ident);
+			error("token %s initialized with too few attributes", ident);
 			break;
 		}
 		typerr = 0;
-		switch(arexp[i].ex_typ) {
+		switch (arexp[i].ex_typ)
-		default: assert(0);
+		{
-		case TYPINT:
+			default:
-			if (tp->tk_att[i].ta_type != -1)
+				assert(0);
-				if (tp->tk_att[i].ta_type == -2)
+			case TYPINT:
-					arexp[i] = iextoaddr(arexp[i]);
+				if (tp->tk_att[i].ta_type != -1)
-				else
+					if (tp->tk_att[i].ta_type == -2)
+						arexp[i] = iextoaddr(arexp[i]);
+					else
+						typerr++;
+				break;
+			case TYPBOOL:
+				typerr++;
+				break;
+			case TYPADDR:
+				if (tp->tk_att[i].ta_type != -2)
 					typerr++;
-			break;
+				break;
-		case TYPBOOL:
+			case TYPREG:
-			typerr++; break;
+				if (tp->tk_att[i].ta_type < 0)
-		case TYPADDR:
+					typerr++;
-			if (tp->tk_att[i].ta_type != -2)
+				else if (!subset(arexp[i].ex_regset,
-				typerr++;
+						l_props[tp->tk_att[i].ta_type].pr_regset,
-			break;
+						SZOFSET(MAXREGS)))
-		case TYPREG:
+					typerr++;
-			if (tp->tk_att[i].ta_type<0)
+				break;
-				typerr++;
-			else if (!subset(arexp[i].ex_regset,
-			           l_props[tp->tk_att[i].ta_type].pr_regset,
-				   SZOFSET(MAXREGS)))
-				typerr++;
-			break;
 		}
 		if (typerr)
-			error("Attribute %s.%s given wrong type of value",
+			error("Attribute %s.%s given wrong type of value", ident,
-				ident,tp->tk_att[i].ta_name);
+					tp->tk_att[i].ta_name);
-		insta.in_info[i+1] = arexp[i].ex_index;
+		insta.in_info[i + 1] = arexp[i].ex_index;
 	}
-	result.in_index = instalookup(insta,i+1);
+	result.in_index = instalookup(insta, i + 1);
-	return(result);
+	return (result);
 }
 
 /* low level instance package */
 
-int ninstances=1;
+int ninstances = 1;
 inst_t l_instances[MAXINSTANCES];
 
-instalookup(insta,filled) inst_t insta; {
+static int instalookup(inst_t insta, int filled)
-	register i,j;
+{
+	register int i, j;
 
-	for (j=filled;j<=MAXATT;j++)
+	for (j = filled; j <= MAXATT; j++)
 		insta.in_info[j] = 0;
-	for (i=0;i<ninstances;i++) {
+	for (i = 0; i < ninstances; i++)
+	{
 		if (insta.in_which != l_instances[i].in_which)
 			continue;
-		for(j=0;j<=MAXATT;j++)
+		for (j = 0; j <= MAXATT; j++)
-			if (insta.in_info[j]!= l_instances[i].in_info[j])
+			if (insta.in_info[j] != l_instances[i].in_info[j])
 				goto cont;
-		return(i);
+		return (i);
-	    cont:;
+		cont: ;
 	}
-	NEXT(ninstances,MAXINSTANCES,"Instances");
+	NEXT(ninstances, MAXINSTANCES, "Instances");
 	l_instances[i] = insta;
-	return(i);
+	return (i);
 }

util/ncgg/iocc.h

@@ -3,8 +3,14 @@
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
 /* $Id$ */
+#ifndef IOCC_H_
+#define IOCC_H_
+
+#include "param.h"
 
 typedef struct iocc {
 	short in_set[SETSIZE];
 	int   in_index;
 } iocc_t,*iocc_p;
+
+#endif

util/ncgg/lookup.c

@@ -3,7 +3,7 @@
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
 #ifndef NORCSID
-static char rcsid[]= "$Id$";
+static char rcsid[] = "$Id$";
 #endif
 
 #include <assert.h>
@@ -11,61 +11,66 @@ static char rcsid[]= "$Id$";
 #include "param.h"
 #include "lookup.h"
 #include "extern.h"
+#include "subr.h"
 
-char *myalloc();
+;
-char *mystrcpy();
 
-symbol dumsym;	/* dummy to return in case of error */
+symbol dumsym; /* dummy to return in case of error */
 
-symbol *lookup(name,type,style)
+/* Forward declarations */
-char *name;
+static int hashvalue(register char *);
-symtype type;
+
-lookupstyle style;
+symbol *lookup(char *name, symtype type, lookupstyle style)
 {
-	symbol *sy_p,**sy_pp;
+	symbol *sy_p, **sy_pp;
 
-	for (sy_pp = &symhash[hashvalue(name)];(sy_p= *sy_pp) != 0;sy_pp= &sy_p->sy_next) {
+	for (sy_pp = &symhash[hashvalue(name)]; (sy_p = *sy_pp) != 0;
-		if (strcmp(sy_p->sy_name,name)!=0)
+			sy_pp = &sy_p->sy_next)
+	{
+		if (strcmp(sy_p->sy_name, name) != 0)
 			continue;
-		switch(style) {
+		switch (style)
+		{
+			default:
+				assert(0);
+			case justlooking:
+			case mustexist:
+			case makeexist:
+				if (type == symany || type == sy_p->sy_type)
+					return (sy_p);
+				continue;
+			case newsymbol:
+				error("%s already defined", name);
+				return (&dumsym);
+		}
+	}
+	switch (style)
+	{
 		default:
 			assert(0);
 		case justlooking:
+			return ((symbol *) 0);
 		case mustexist:
-		case makeexist:
+			fatal("%s is unknown symbol", name);
-			if (type==symany || type==sy_p->sy_type)
+			/* NOTREACHED */
-				return(sy_p);
-			continue;
 		case newsymbol:
-			error("%s already defined",name);
+		case makeexist:
-			return(&dumsym);
+			NEW(sy_p, symbol);
-		}
+			sy_p->sy_next = 0;
-	}
+			sy_p->sy_name = mystrcpy(name);
-	switch(style) {
+			assert(type != symany);
-	default:
+			sy_p->sy_type = type;
-		assert(0);
+			*sy_pp = sy_p;
-	case justlooking:
+			return (sy_p);
-		return((symbol *) 0);
-	case mustexist:
-		fatal("%s is unknown symbol",name);
-		/* NOTREACHED */
-	case newsymbol:
-	case makeexist:
-		NEW(sy_p,symbol);
-		sy_p->sy_next = 0;
-		sy_p->sy_name = mystrcpy(name);
-		assert(type!=symany);
-		sy_p->sy_type = type;
-		*sy_pp = sy_p;
-		return(sy_p);
 	}
 }
 
-hashvalue(s) register char *s; {
+static int hashvalue(register char *s)
-	register unsigned sum=0;
+{
-	register i;
+	register unsigned sum = 0;
+	register int i;
 
-	for(i=0;*s;s++,i=(i+3)&07)
+	for (i = 0; *s; s++, i = (i + 3) & 07)
-		sum += *s<<i;
+		sum += *s << i;
-	return(sum%NSYMHASH);
+	return (sum % NSYMHASH);
 }

util/ncgg/lookup.h

@@ -3,6 +3,8 @@
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
 /* $Id$ */
+#ifndef LOOKUP_H_
+#define LOOKUP_H_
 
 typedef enum {
 	justlooking,mustexist,newsymbol,makeexist
@@ -30,4 +32,7 @@ typedef struct symbol {
 
 #define NSYMHASH 61
 extern symbol *symhash[NSYMHASH];	/* chained hashtable */
-extern symbol *lookup();
+
+symbol *lookup(char *name, symtype type, lookupstyle style);
+
+#endif /* LOOKUP_H_ */

util/ncgg/main.c

@@ -3,60 +3,81 @@
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
 #ifndef NORCSID
-static char rcsid[]= "$Id$";
+static char rcsid[] = "$Id$";
 #endif
 
 #include <stdlib.h>
 #include <stdio.h>
+#include "param.h"
+#include "hall.h"
+#include "expr.h"
 #include "extern.h"
 
 char *filename;
 
-main(argc,argv) char **argv; {
+extern void enterkeyw(void);
+extern void initio(void);
+extern void initemhash(void);
+extern void finishio(void);
+extern void statistics(void);
+extern int yyparse(void);
+
+int main(int argc, char **argv)
+{
 	extern int nerrors;
 	extern int code_in_c;
 	extern int tabledebug;
 	extern int verbose;
 
-	while (argc >1 && argv[1][0]=='-') {
+	while (argc > 1 && argv[1][0] == '-')
-		switch(argv[1][1]) {
+	{
-		case 'c':
+		switch (argv[1][1])
-			code_in_c = 0;
+		{
-			break;
+			case 'c':
-		case 'd':
+				code_in_c = 0;
-			tabledebug++;
+				break;
-			break;
+			case 'd':
-		case 'v':
+				tabledebug++;
-			verbose++;
+				break;
-			break;
+			case 'v':
-		default:
+				verbose++;
-			error("Unknown flag -%c",argv[1][1]);
+				break;
+			default:
+				error("Unknown flag -%c", argv[1][1]);
 		}
-		argc--; argv++;
+		argc--;
+		argv++;
 	}
-	if (argc==2) {
+	if (argc == 2)
-		if (freopen(argv[1],"r",stdin)==NULL) {
+	{
-			error("Can't open %s",argv[1]);
+		if (freopen(argv[1], "r", stdin) == NULL)
+		{
+			error("Can't open %s", argv[1]);
 			exit(-1);
 		}
 		filename = argv[1];
 	}
-	else if (argc == 1) {
+	else if (argc == 1)
+	{
 		filename = "";
-	} else
+	}
-		error("Usage: %s [-c] [-d] [-v] [table]",argv[0]);
+	else
+		error("Usage: %s [-c] [-d] [-v] [table]", argv[0]);
 	initemhash();
 	enterkeyw();
 	initnodes();
 	initio();
 	yyparse();
-	if (nerrors==0) {
+	if (nerrors == 0)
+	{
 		finishio();
 		statistics();
 		if (verbose)
 			hallverbose();
-	} else {
+	}
+	else
+	{
 		errorexit();
 	}
-	exit(nerrors==0 ? 0 : -1);
+	exit(nerrors == 0 ? 0 : -1);
 }

util/ncgg/scan.l

@@ -15,14 +15,14 @@ static char rcsid2[]= "$Id$";
 #include "instruct.h"
 #include "expr.h"
 #include "extern.h"
+#include "subr.h"
 #include <cgg_cg.h>
 #include <em_reg.h>
 #include "y.tab.h"
 
 extern int emhere;
 
-char *mystrcpy();
+extern int mlookup(char *name);
-int   myatoi();
 
 int lineno=1;
 extern char *filename;
@@ -101,7 +101,7 @@ extern char *filename;
 %%
 int skipping=0;
 
-yywrap() {
+int yywrap(void) {
 
 	if (skipping)
 		fatal("EOF reached during error recovery");
@@ -113,8 +113,8 @@ yywrap() {
  
 #define yytext_ptr yytext
 
-skipupto(tok,str) char *str; {
+void skipupto(int tok,char *str)  {
-	register i; 
+	register int i; 
 
 	skipping=1; 
 	while (yylex()!=tok)

util/ncgg/set.c

@@ -3,7 +3,7 @@
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
 #ifndef NORCSID
-static char rcsid[]= "$Id$";
+static char rcsid[] = "$Id$";
 #endif
 
 #include "param.h"
@@ -12,143 +12,161 @@ static char rcsid[]= "$Id$";
 #include "token.h"
 #include "lookup.h"
 #include "reg.h"
+#include "subr.h"
 #include <cgg_cg.h>
 #include "extern.h"
 
 extern set_t l_sets[];
-
-setlookup(s) set_t s; {
-	register set_p p;
-	register i;
-	int setno;
-
-	for(p=l_sets;p<&l_sets[nsets];p++) {
-		if (p->set_size != s.set_size)
-			continue;
-		for (i=0;i<SETSIZE;i++)
-			if (p->set_val[i] != s.set_val[i])
-				goto cont;
-		return(p-l_sets);
-	    cont:;
-	}
-	setno = NEXT(nsets,MAXSETS,"Sets");
-	l_sets[setno] = s;
-	return(setno);
-}
-
-make_std_sets() {
-	set_t s;
-	register i;
-
-	for(i=0;i<SETSIZE;i++)
-		s.set_val[i]=0;
-	for(i=0;i<nregs+ntokens;i++)
-		BIS(s.set_val,i);
-	s.set_size = 0;
-	allsetno = setlookup(s);
-	n_set("ALL",allsetno);
-}
-
 set_t emptyset;
 
-set_t ident_to_set(name) char *name; {
+
+int setlookup(set_t s)
+{
+	register set_p p;
+	register int i;
+	int setno;
+
+	for (p = l_sets; p < &l_sets[nsets]; p++)
+	{
+		if (p->set_size != s.set_size)
+			continue;
+		for (i = 0; i < SETSIZE; i++)
+			if (p->set_val[i] != s.set_val[i])
+				goto cont;
+		return (p - l_sets);
+		cont: ;
+	}
+	setno = NEXT(nsets, MAXSETS, "Sets");
+	l_sets[setno] = s;
+	return (setno);
+}
+
+void make_std_sets(void)
+{
+	set_t s;
+	register int i;
+
+	for (i = 0; i < SETSIZE; i++)
+		s.set_val[i] = 0;
+	for (i = 0; i < nregs + ntokens; i++)
+		BIS(s.set_val, i);
+	s.set_size = 0;
+	allsetno = setlookup(s);
+	n_set("ALL", allsetno);
+}
+
+set_t ident_to_set(char *name)
+{
 	register symbol *sy_p;
-	register i;
+	register int i;
 	register struct propinfo *pp;
 	int bitno;
 	set_t result;
 
-	sy_p = lookup(name,symany,mustexist);
+	sy_p = lookup(name, symany, mustexist);
-	switch(sy_p->sy_type) {
+	switch (sy_p->sy_type)
-	default:
+	{
-		error("%s is wrong kind of symbol",name);
+		default:
-		return(emptyset);
+			error("%s is wrong kind of symbol", name);
-	case symprop:
+			return (emptyset);
-		pp = &l_props[sy_p->sy_value.syv_propno];
+		case symprop:
-		result.set_size = pp->pr_size;
+			pp = &l_props[sy_p->sy_value.syv_propno];
-		for (i=0;i<SZOFSET(MAXREGS);i++)
+			result.set_size = pp->pr_size;
-			result.set_val[i] = pp->pr_regset[i];
+			for (i = 0; i < SZOFSET(MAXREGS); i++)
-		BIS(result.set_val,0);
+				result.set_val[i] = pp->pr_regset[i];
-		for (;i<SETSIZE;i++)
+			BIS(result.set_val, 0);
-			result.set_val[i] = 0;
+			for (; i < SETSIZE; i++)
-		break;
+				result.set_val[i] = 0;
-	case symtok:
+			break;
-		bitno = sy_p->sy_value.syv_tokno+nregs;
+		case symtok:
-		for (i=0;i<SETSIZE;i++)
+			bitno = sy_p->sy_value.syv_tokno + nregs;
-			result.set_val[i] = 0;
+			for (i = 0; i < SETSIZE; i++)
-		BIS(result.set_val,bitno);
+				result.set_val[i] = 0;
-		result.set_size = l_tokens[sy_p->sy_value.syv_tokno]->tk_size;
+			BIS(result.set_val, bitno);
-		break;
+			result.set_size = l_tokens[sy_p->sy_value.syv_tokno]->tk_size;
-	case symset:
+			break;
-		return(l_sets[sy_p->sy_value.syv_setno]);
+		case symset:
+			return (l_sets[sy_p->sy_value.syv_setno]);
 	}
-	return(result);
+	return (result);
 }
 
-static void
+static void checksize(register set_p s)
-checksize(s)
-	register set_p s;
 {
 	register int i;
 	register int size = -1;
 
 	s->set_size = 0;
-	for (i = 1; i <= nregs; i++) {
+	for (i = 1; i <= nregs; i++)
-		if (BIT(s->set_val, i)) {
+	{
+		if (BIT(s->set_val, i))
+		{
 			register int sz = l_regs[i].ri_size;
 
-			if (size == -1) size = sz;
+			if (size == -1)
-			else if (size != sz) return;
+				size = sz;
+			else if (size != sz)
+				return;
 		}
 	}
-	for (i = 1; i <= ntokens; i++) {
+	for (i = 1; i <= ntokens; i++)
-		if (BIT(s->set_val, i+nregs)) {
+	{
+		if (BIT(s->set_val, i + nregs))
+		{
 			register int sz = l_tokens[i]->tk_size;
-			if (size == -1) size = sz;
+			if (size == -1)
-			else if (size != sz) return;
+				size = sz;
+			else if (size != sz)
+				return;
 		}
 	}
-	if (size != -1) s->set_size = size;
+	if (size != -1)
+		s->set_size = size;
 }
 
-set_t setproduct(s1,s2) set_t s1,s2; {
+set_t setproduct(set_t s1, set_t s2)
+{
 	set_t result;
-	register i;
+	register int i;
 
-	for(i=0;i<SETSIZE;i++)
+	for (i = 0; i < SETSIZE; i++)
 		result.set_val[i] = s1.set_val[i] & s2.set_val[i];
 	checksize(&result);
-	return(result);
+	return (result);
 }
 
-set_t setsum(s1,s2) set_t s1,s2; {
+set_t setsum(set_t s1, set_t s2)
+{
 	set_t result;
-	register i;
+	register int i;
 
 	if (s1.set_size == s2.set_size)
 		result.set_size = s1.set_size;
 	else
 		result.set_size = 0;
-	for(i=0;i<SETSIZE;i++)
+	for (i = 0; i < SETSIZE; i++)
 		result.set_val[i] = s1.set_val[i] | s2.set_val[i];
-	return(result);
+	return (result);
 }
 
-set_t setdiff(s1,s2) set_t s1,s2; {
+set_t setdiff(set_t s1, set_t s2)
+{
 	set_t result;
-	register i;
+	register int i;
 
-	for(i=0;i<SETSIZE;i++)
+	for (i = 0; i < SETSIZE; i++)
-		result.set_val[i] = s1.set_val[i] & ~ s2.set_val[i];
+		result.set_val[i] = s1.set_val[i] & ~s2.set_val[i];
 	/* make sure that we don't loose the lowest bit of the set, which
-	   indicates that it contains registers
+	 indicates that it contains registers
-	*/
+	 */
-	for (i=1;i <= nregs; i++) {
+	for (i = 1; i <= nregs; i++)
-		if (BIT(result.set_val, i)) {
+	{
-			BIS(result.set_val,0);
+		if (BIT(result.set_val, i))
+		{
+			BIS(result.set_val, 0);
 			break;
 		}
 	}
 	checksize(&result);
-	return(result);
+	return (result);
 }

util/ncgg/set.h

@@ -3,7 +3,21 @@
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
 /* $Id$ */
+#ifndef SET_H_
+#define SET_H_
+
+#include <cgg_cg.h>
 
 #define BIS(sp,n) (sp)[(n)>>4] |= 1<<((n)&0xF)
 #define BIC(sp,n) (sp)[(n)>>4] &= ~(1<<((n)&0xF))
 #define BIT(sp,n) (((sp)[(n)>>4]&(1<<((n)&0xF)))!=0)
+
+int setlookup(set_t s);
+void make_std_sets(void);
+set_t ident_to_set(char *name);
+set_t setproduct(set_t s1, set_t s2);
+set_t setsum(set_t s1, set_t s2);
+set_t setdiff(set_t s1, set_t s2);
+
+
+#endif /* SET_H_ */

util/ncgg/strlookup.c

@@ -3,24 +3,25 @@
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
 #ifndef NORCSID
-static char rcsid[]= "$Id$";
+static char rcsid[] = "$Id$";
 #endif
 
 #include <string.h>
 #include "param.h"
+#include "subr.h"
 #include "extern.h"
 
-int nstrings=0;
+int nstrings = 0;
 char *l_strings[MAXSTRINGS];
 
-strlookup(str) char *str; {
+int strlookup(char *str)
-	register i;
+{
-	extern char *mystrcpy();
+	register int i;
 
-	for(i=0;i<nstrings;i++)
+	for (i = 0; i < nstrings; i++)
-		if (strcmp(str,l_strings[i])==0)
+		if (strcmp(str, l_strings[i]) == 0)
-			return(i);
+			return (i);
-	NEXT(nstrings,MAXSTRINGS,"String table");
+	NEXT(nstrings, MAXSTRINGS, "String table");
 	l_strings[i] = mystrcpy(str);
-	return(i);
+	return (i);
 }

util/ncgg/subr.c

@@ -3,7 +3,7 @@
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
 #ifndef NORCSID
-static char rcsid[]= "$Id$";
+static char rcsid[] = "$Id$";
 #endif
 
 #include <stdlib.h>
@@ -20,77 +20,86 @@ static char rcsid[]= "$Id$";
 #include "regvar.h"
 #include <cgg_cg.h>
 #include <em_reg.h>
+#include "subr.h"
+#include "hall.h"
 #include "extern.h"
 
-n_proc(name) char *name; {
+extern int npatbytes;
-	register symbol *sy_p;
+extern set_t l_sets[];
-	extern int npatbytes;
 
-	sy_p = lookup(name,symproc,newsymbol);
+
+void n_proc(char *name)
+{
+	register symbol *sy_p;
+
+	sy_p = lookup(name, symproc, newsymbol);
 	sy_p->sy_value.syv_procoff = npatbytes + 1;
 }
 
-struct varinfo *
+struct varinfo * make_erase(char *name)
-make_erase(name) char *name; {
+{
-	expr_t e,ident_expr();
+	expr_t e;
 	struct varinfo *result;
 
 	e = ident_expr(name);
 	if (e.ex_typ != TYPREG)
 		error("Register name required here");
-	NEW(result,struct varinfo);
+	NEW(result, struct varinfo);
 	result->vi_next = VI_NULL;
 	result->vi_int[0] = e.ex_index;
-	return(result);
+	return (result);
 }
 
-n_instr(name,asname,oplist,eraselist,cost)
+void n_instr(char *name, char *asname, operand *oplist, struct varinfo *eraselist,
-char *name,*asname;
+		  struct varinfo *cost)
-operand *oplist;
-struct varinfo *eraselist,*cost;
 {
-	register instrno;
+	register int instrno;
-	register cc_count;
+	register int cc_count;
 	register instr_p ip;
 
-	instrno = NEXT(ninstr,MAXINSTR,"Instructions");
+	instrno = NEXT(ninstr, MAXINSTR, "Instructions");
 	ip = &l_instr[instrno];
 	ip->i_name = name;
-	ip->i_asname = strlookup(asname!=0 ? asname : name);
+	ip->i_asname = strlookup(asname != 0 ? asname : name);
 	ip->i_nops = 0;
 	ip->i_oplist = oplist;
 	ip->i_erases = eraselist;
-	if (cost==0) {
+	if (cost == 0)
+	{
 		ip->i_cost.ct_space = 0;
 		ip->i_cost.ct_time = 0;
-	} else {
+	}
+	else
+	{
 		ip->i_cost.ct_space = cost->vi_int[0];
 		ip->i_cost.ct_space = cost->vi_int[1];
 	}
-	for (cc_count=0; oplist!=0; oplist = oplist->o_next) {
+	for (cc_count = 0; oplist != 0; oplist = oplist->o_next)
+	{
 		ip->i_nops++;
-		if(oplist->o_adorn&AD_CC)
+		if (oplist->o_adorn & AD_CC)
 			cc_count++;
 	}
-	while (eraselist!=VI_NULL) {
+	while (eraselist != VI_NULL )
+	{
 		if (eraselist->vi_int[0] == -1 && cc_count)
 			error("Instruction can't both set and break the condition codes");
-		eraselist=eraselist->vi_next;
+		eraselist = eraselist->vi_next;
 	}
-	if (cc_count>1)
+	if (cc_count > 1)
 		error("No instruction can set condition codes more than once");
 }
 
-n_set(name,number) char *name; {
+void n_set(char *name, int number)
+{
 	register symbol *sy_p;
 
-	sy_p = lookup(name,symset,newsymbol);
+	sy_p = lookup(name, symset, newsymbol);
 	sy_p->sy_value.syv_setno = number;
 }
 
-n_tok(name,atts,size,cost,format)
+void n_tok(char *name, struct varinfo *atts, int size,
-char *name;
+		 struct varinfo *cost, struct varinfo *format)
-struct varinfo *atts,*cost,*format;
 {
 	register symbol *sy_p;
 	register token_p tp;
@@ -98,146 +107,164 @@ struct varinfo *atts,*cost,*format;
 	int i;
 	int tokno;
 	int thistokensize;
-	char formstr[50],smallstr[2];
+	char formstr[50], smallstr[2];
 
-	sy_p = lookup(name,symtok,newsymbol);
+	sy_p = lookup(name, symtok, newsymbol);
-	NEW(tp,token_t);
+	NEW(tp, token_t);
-	tokno = NEXT(ntokens,MAXTOKENS,"Tokens");
+	tokno = NEXT(ntokens, MAXTOKENS, "Tokens");
 	sy_p->sy_value.syv_tokno = tokno;
 	l_tokens[tokno] = tp;
 	tp->tk_name = sy_p->sy_name;
 	tp->tk_size = size;
-	if (cost != 0) {
+	if (cost != 0)
+	{
 		tp->tk_cost.ct_space = cost->vi_int[0];
-		tp->tk_cost.ct_time  = cost->vi_int[1];
+		tp->tk_cost.ct_time = cost->vi_int[1];
-	} else {
-		tp->tk_cost.ct_space = 0;
-		tp->tk_cost.ct_time  = 0;
 	}
-	for(i=0,vip=atts;i<MAXATT && vip!=0;i++,vip=vip->vi_next) {
+	else
+	{
+		tp->tk_cost.ct_space = 0;
+		tp->tk_cost.ct_time = 0;
+	}
+	for (i = 0, vip = atts; i < MAXATT && vip != 0; i++, vip = vip->vi_next)
+	{
 		tp->tk_att[i].ta_type = vip->vi_int[0];
 		tp->tk_att[i].ta_name = vip->vi_str[0];
-		vip->vi_str[0]=0;
+		vip->vi_str[0] = 0;
 	}
-	thistokensize=i;
+	thistokensize = i;
-	if (i>maxtokensize)
+	if (i > maxtokensize)
-		maxtokensize=i;
+		maxtokensize = i;
-	if (vip!=0)
+	if (vip != 0)
-		error("More then %d attributes, rest discarded",MAXATT);
+		error("More then %d attributes, rest discarded", MAXATT);
-	for(;i<MAXATT;i++)
+	for (; i < MAXATT; i++)
-		tp->tk_att[i].ta_type= -3;
+		tp->tk_att[i].ta_type = -3;
-	if (format!=0) {
+	if (format != 0)
+	{
 		formstr[0] = 0;
-		for (vip=format;vip!=0;vip=vip->vi_next) {
+		for (vip = format; vip != 0; vip = vip->vi_next)
-			if (vip->vi_int[0]==0)
+		{
-				strcat(formstr,vip->vi_str[0]);
+			if (vip->vi_int[0] == 0)
-			else {
+				strcat(formstr, vip->vi_str[0]);
-				for(i=0;i<thistokensize;i++) {
+			else
-					if (strcmp(vip->vi_str[0],tp->tk_att[i].ta_name)==0) {
+			{
-						smallstr[0] = i+1;
+				for (i = 0; i < thistokensize; i++)
+				{
+					if (strcmp(vip->vi_str[0], tp->tk_att[i].ta_name) == 0)
+					{
+						smallstr[0] = i + 1;
 						smallstr[1] = 0;
-						strcat(formstr,smallstr);
+						strcat(formstr, smallstr);
 						break;
 					}
 				}
-				if (i==thistokensize)
+				if (i == thistokensize)
-					error("%s not a known attribute",
+					error("%s not a known attribute", vip->vi_str[0]);
-						vip->vi_str[0]);
 			}
 		}
 		tp->tk_format = strlookup(formstr);
-	} else
+	}
+	else
 		tp->tk_format = -1;
 }
 
-checkprintformat(n) {
+void checkprintformat(int n)
+{
 	register short *s;
-	register i;
+	register int i;
-	extern set_t l_sets[];
+
-	
+	s = l_sets[n].set_val;
-	s= l_sets[n].set_val;
+	for (i = nregs; i < nregs + ntokens; i++)
-	for(i=nregs;i<nregs+ntokens;i++)
+		if (BIT(s,i) && l_tokens[i - nregs]->tk_format < 0)
-		if (BIT(s,i) && l_tokens[i-nregs]->tk_format<0)
 			error("Token %s in set does not have printformat",
-				l_tokens[i-nregs]->tk_name);
+					l_tokens[i - nregs]->tk_name);
 }
 
-n_prop(name,size) char *name; int size; {
+void n_prop(char *name, int size)
+{
 	int propno;
 	register symbol *sp;
 
-	propno = NEXT(nprops,MAXPROPS,"Properties");
+	propno = NEXT(nprops, MAXPROPS, "Properties");
-	sp = lookup(name,symprop,newsymbol);
+	sp = lookup(name, symprop, newsymbol);
 	sp->sy_value.syv_propno = propno;
-	if (size <= 0) {
+	if (size <= 0)
+	{
 		error("Size of property must be >0");
 		size = wordsize;
 	}
 	l_props[propno].pr_size = size;
 }
 
-void
+void prophall(int n)
-prophall(n) {
+{
-	register i;
+	register int i;
 	short hallset[SETSIZE];
-	
+
-	if (n < 0) return;
+	if (n < 0)
-	for(i=0;i<SETSIZE;i++)
+		return;
-		hallset[i] = i<SZOFSET(MAXREGS) ? l_props[n].pr_regset[i] : 0;
+	for (i = 0; i < SETSIZE; i++)
+		hallset[i] = i < SZOFSET(MAXREGS) ? l_props[n].pr_regset[i] : 0;
 	nexthall(hallset);
 }
 
-n_reg(name,printstring,nmemb,member1,member2) char *name,*printstring; {
+int n_reg(char *name, char *printstring, int nmemb, int member1, int member2)
+{
 	register symbol *sy_p;
 	register reginfo *ri_p;
 	int regno;
 
-	sy_p = lookup(name,symreg,newsymbol);
+	sy_p = lookup(name, symreg, newsymbol);
-	sy_p->sy_value.syv_regno = regno = NEXT(nregs,MAXREGS,"Number of registers");
+	sy_p->sy_value.syv_regno = regno = NEXT(nregs, MAXREGS,
+			"Number of registers");
 	ri_p = &l_regs[regno];
 	ri_p->ri_name = mystrcpy(name);
-	ri_p->ri_repr = printstring!=0 ? mystrcpy(printstring) : ri_p->ri_name;
+	ri_p->ri_repr = printstring != 0 ? mystrcpy(printstring) : ri_p->ri_name;
 	ri_p->ri_memb[0] = member1;
 	ri_p->ri_memb[1] = member2;
-	if (nmemb>maxmembers)
+	if (nmemb > maxmembers)
-		maxmembers=nmemb;
+		maxmembers = nmemb;
-	return(regno);
+	return (regno);
 }
 
-make_const() {
+void make_const(void)
+{
 
 	wordsize = cmustbeset("EM_WSIZE");
 	pointersize = cmustbeset("EM_PSIZE");
 }
 
-cmustbeset(ident) char *ident; {
+int cmustbeset(char *ident)
+{
 
-	return(lookup(ident,symconst,mustexist)->sy_value.syv_cstval);
+	return (lookup(ident, symconst, mustexist)->sy_value.syv_cstval);
 }
 
-n_const(ident,val) char *ident; {
+void n_const(char *ident, int val)
+{
 	register symbol *sy_p;
 
-	sy_p = lookup(ident,symconst,newsymbol);
+	sy_p = lookup(ident, symconst, newsymbol);
 	sy_p->sy_value.syv_cstval = val;
 }
 
-n_sconst(ident,val) char *ident,*val; {
+void n_sconst(char *ident, char *val)
+{
 	register symbol *sy_p;
 
-	sy_p = lookup(ident,symsconst,newsymbol);
+	sy_p = lookup(ident, symsconst, newsymbol);
 	sy_p->sy_value.syv_stringno = strlookup(val);
 }
 
-static void
+static void add_regvar(int rvnum, reginfo *regp, int rv)
-add_regvar(int rvnum, reginfo *regp, int rv)
 {
 	int overlap, wrong;
 
 	overlap = wrong = 0;
-	if (regp->ri_memb[0]!=0) {
+	if (regp->ri_memb[0] != 0)
+	{
 		/* reglap: float may overlap with one subregister */
-		if (rv==reg_float && regp->ri_memb[1]==0)
+		if (rv == reg_float && regp->ri_memb[1] == 0)
 			overlap = 1;
 		else
 			wrong = 1;
@@ -248,28 +275,34 @@ add_regvar(int rvnum, reginfo *regp, int rv)
 	rvused |= ANY_REGVAR;
 	if (regp->ri_size == wordsize)
 		rvused |= SL_REGVAR;
-	else if (regp->ri_size == 2*wordsize)
+	else if (regp->ri_size == 2 * wordsize)
 		rvused |= DL_REGVAR;
 
 	wrong = 0;
-	if (overlap) {
+	if (overlap)
+	{
 		/* reglap = size of overlap float */
-		if (reglap==0) {
+		if (reglap == 0)
+		{
 			reglap = regp->ri_size;
 			if (reglap == rvsize[reg_float])
 				error("Two sizes of reg_float can't be same size");
-		} else if (reglap!=regp->ri_size)
+		}
+		else if (reglap != regp->ri_size)
 			wrong = 1;
-	} else {
+	}
-		if (nregvar[rv]==0)
+	else
+	{
+		if (nregvar[rv] == 0)
 			rvsize[rv] = regp->ri_size;
-		else if (rvsize[rv]!=regp->ri_size)
+		else if (rvsize[rv] != regp->ri_size)
 			wrong = 1;
 	}
 	if (wrong)
 		error("All register variables of one type must have the same size");
 
-	if (overlap) {
+	if (overlap)
+	{
 		reginfo *member_p = &l_regs[regp->ri_memb[0]];
 		int i;
 
@@ -278,54 +311,59 @@ add_regvar(int rvnum, reginfo *regp, int rv)
 		 *   Add reg_p in its place.
 		 */
 		wrong = 1;
-		for (i = 0; i < nregvar[rv]; i++) {
+		for (i = 0; i < nregvar[rv]; i++)
-			if (rvnumbers[rv][i] == regp->ri_memb[0]) {
+		{
+			if (rvnumbers[rv][i] == regp->ri_memb[0])
+			{
 				rvnumbers[rv][i] = rvnum;
 				wrong = 0;
 				break;
 			}
 		}
 		if (wrong)
-			error("Register variable %s can't overlap %s",
+			error("Register variable %s can't overlap %s", regp->ri_name,
-			    regp->ri_name, member_p->ri_name);
+					member_p->ri_name);
-	} else {
+	}
-		NEXT(nregvar[rv],MAXREGVAR,"Register variable");
+	else
-		rvnumbers[rv][nregvar[rv]-1] = rvnum;
+	{
+		NEXT(nregvar[rv], MAXREGVAR, "Register variable");
+		rvnumbers[rv][nregvar[rv] - 1] = rvnum;
 	}
 }
 
-void
+void regline(varinfo *rl, varinfo *pl, int rv)
-regline(rl,pl,rv) varinfo *rl,*pl; {
+{
-	register varinfo *rrl,*rpl;
+	register varinfo *rrl, *rpl;
 	register short *sp;
 	register reginfo *regp;
 	int thissize;
 	int propno;
 
-	for(rrl=rl;rrl!=0;rrl=rrl->vi_next) {
+	for (rrl = rl; rrl != 0; rrl = rrl->vi_next)
+	{
 		regp = &l_regs[rrl->vi_int[0]];
 		thissize = 0;
-		for(rpl=pl;rpl!=0;rpl=rpl->vi_next) {
+		for (rpl = pl; rpl != 0; rpl = rpl->vi_next)
+		{
 			propno = rpl->vi_int[0];
-			sp= l_props[propno].pr_regset;
+			sp = l_props[propno].pr_regset;
-			BIS(sp,rrl->vi_int[0]);
+			BIS(sp, rrl->vi_int[0]);
-			if (thissize==0)
+			if (thissize == 0)
 				thissize = l_props[propno].pr_size;
-			else if (thissize!=-1 && thissize!=l_props[propno].pr_size)
+			else if (thissize != -1 && thissize != l_props[propno].pr_size)
-				error("Register %s has no clear size",
+				error("Register %s has no clear size", regp->ri_name);
-					regp->ri_name);
 		}
 		regp->ri_size = thissize;
 		regp->ri_class = regclass;
 		regp->ri_rregvar = rv;
-		if (rv>=0)
+		if (rv >= 0)
 			add_regvar(rrl->vi_int[0], regp, rv);
 	}
 	regclass++;
 }
 
-void
+void check_reglap(void)
-check_reglap() {
+{
 	reginfo *regp;
 	int i;
 
@@ -333,129 +371,147 @@ check_reglap() {
 		return;
 
 	/* reglap: Check that every reg_float has size == reglap. */
-	for (i = 0; i < nregvar[reg_float]; i++) {
+	for (i = 0; i < nregvar[reg_float]; i++)
+	{
 		regp = &l_regs[rvnumbers[reg_float][i]];
 		if (regp->ri_size != reglap)
-			error("Missing reg_float of size %d to contain %s",
+			error("Missing reg_float of size %d to contain %s", reglap,
-			      reglap, regp->ri_name);
+					regp->ri_name);
 	}
 }
 
-setallreg(vi) struct varinfo *vi; {
+void setallreg(struct varinfo *vi)
+{
 
-	nallreg=0;
+	nallreg = 0;
-	for(;vi!=0;vi=vi->vi_next) {
+	for (; vi != 0; vi = vi->vi_next)
-		if (vi->vi_int[0]<0)
+	{
+		if (vi->vi_int[0] < 0)
 			continue;
 		allreg[nallreg++] = vi->vi_int[0];
 	}
 }
 
-void
+void freevi(register struct varinfo *vip)
-freevi(vip) register struct varinfo *vip; {
+{
-	register i;
+	register int i;
 
-	if (vip==0)
+	if (vip == 0)
 		return;
 	freevi(vip->vi_next);
 	freevi(vip->vi_vi);
-	for (i=0;i<VI_NSTR;i++)
+	for (i = 0; i < VI_NSTR; i++)
 		free((char *) vip->vi_str[i]);
 	free(vip);
 }
 
-int myatoi(s) register char *s; {
+int myatoi(register char *s)
-	register int base=10;
+{
-	register sum=0;
+	register int base = 10;
+	register int sum = 0;
 
-	if (*s=='0') {
+	if (*s == '0')
+	{
 		base = 8;
 		s++;
-		if (*s=='x') {
+		if (*s == 'x')
-			base=16;
+		{
+			base = 16;
 			s++;
 		}
 	}
-	for (;;) {
+	for (;;)
-		switch (*s) {
+	{
-		default:	return(sum);
+		switch (*s)
-		case '8':
+		{
-		case '9':
+			default:
-			if (base==8) error("Bad digit in octal number");
+				return (sum);
-		case '0':
+			case '8':
-		case '1':
+			case '9':
-		case '2':
+				if (base == 8)
-		case '3':
+					error("Bad digit in octal number");
-		case '4':
+			case '0':
-		case '5':
+			case '1':
-		case '6':
+			case '2':
-		case '7':
+			case '3':
-			sum = sum*base + *s++ - '0';
+			case '4':
-			break;
+			case '5':
-		case 'a':
+			case '6':
-		case 'b':
+			case '7':
-		case 'c':
+				sum = sum * base + *s++ - '0';
-		case 'd':
+				break;
-		case 'e':
+			case 'a':
-		case 'f':
+			case 'b':
-			if (base!=16) error("Hexletter in number not expected");
+			case 'c':
-			sum = sum*base + 10 + *s++ - 'a';
+			case 'd':
-			break;
+			case 'e':
-		case 'A':
+			case 'f':
-		case 'B':
+				if (base != 16)
-		case 'C':
+					error("Hexletter in number not expected");
-		case 'D':
+				sum = sum * base + 10 + *s++ - 'a';
-		case 'E':
+				break;
-		case 'F':
+			case 'A':
-			if (base!=16) error("Hexletter in number not expected");
+			case 'B':
-			sum = sum*base + 10 + *s++ - 'A';
+			case 'C':
-			break;
+			case 'D':
+			case 'E':
+			case 'F':
+				if (base != 16)
+					error("Hexletter in number not expected");
+				sum = sum * base + 10 + *s++ - 'A';
+				break;
 		}
 	}
 }
 
-char *mystrcpy(s) char *s; {
+char *mystrcpy(char *s)
+{
 	register char *p;
-	char *myalloc();
 
-	p=myalloc(strlen(s)+1);
+	p = myalloc(strlen(s) + 1);
-	strcpy(p,s);
+	strcpy(p, s);
-	return(p);
+	return (p);
 }
 
-char *myalloc(n) register n; {
+char *myalloc(register int n)
-	register char *p,*result;
+{
+	register char *p, *result;
 
-	result=p=malloc(n);
+	result = p = malloc(n);
-	if (p== (char *) 0)
+	if (p == (char *) 0)
 		fatal("Out of memory");
-	do *p++=0; while (--n);
+	do
-	return(result);
+		*p++ = 0;
+	while (--n);
+	return (result);
 }
 
-chkincl(value,lwb,upb) {
+int chkincl(int value, int lwb, int upb)
+{
 
-	if (value<lwb || value>upb)
+	if (value < lwb || value > upb)
-		error("Number %d should have been between %d and %d",
+		error("Number %d should have been between %d and %d", value, lwb, upb);
-			value,lwb,upb);
+	return (value);
-	return(value);
 }
 
-subset(sp1,sp2,setsize) short *sp1,*sp2; {
+int subset(short *sp1, short *sp2, int setsize)
-	register i;
+{
+	register int i;
 
-	for(i=0;i<setsize;i++)
+	for (i = 0; i < setsize; i++)
-		if ( (sp1[i] | sp2[i]) != sp2[i])
+		if ((sp1[i] | sp2[i]) != sp2[i])
-			return(0);
+			return (0);
-	return(1);
+	return (1);
 }
 
-vilength(vip) register struct varinfo *vip; {
+int vilength(register struct varinfo *vip)
-	register l=0;
+{
+	register int l = 0;
 
-	while(vip!=0) {
+	while (vip != 0)
-		vip=vip->vi_next;
+	{
+		vip = vip->vi_next;
 		l++;
 	}
-	return(l);
+	return (l);
 }

util/ncgg/subr.h

@@ -0,0 +1,42 @@
+/*  Copyright (c) 2019 ACK Project.
+ *  See the copyright notice in the ACK home directory, 
+ *  in the file "Copyright".
+ *
+ *  Created on: 2019-05-02
+ *  
+ */
+#ifndef SUBR_H_
+#define SUBR_H_
+
+#include "instruct.h"
+
+struct varinfo;
+
+
+void n_proc(char *name);
+struct varinfo * make_erase(char *name);
+void n_instr(char *name, char *asname, operand *oplist, struct varinfo *eraselist,
+		  struct varinfo *cost);
+void n_set(char *name, int number);
+void n_tok(char *name, struct varinfo *atts, int size,
+		 struct varinfo *cost, struct varinfo *format);
+void checkprintformat(int n);
+void n_prop(char *name, int size);
+void prophall(int n);
+int n_reg(char *name, char *printstring, int nmemb, int member1, int member2);
+void make_const(void);
+int cmustbeset(char *ident);
+void n_const(char *ident, int val);
+void n_sconst(char *ident, char *val);
+void regline(struct varinfo *rl, struct varinfo *pl, int rv);
+void check_reglap(void);
+void setallreg(struct varinfo *vi);
+void freevi(register struct varinfo *vip);
+int myatoi(register char *s);
+char *mystrcpy(char *s);
+char *myalloc(register int n);
+int chkincl(int value, int lwb, int upb);
+int subset(short *sp1, short *sp2, int setsize);
+int vilength(register struct varinfo *vip);
+
+#endif /* SUBR_H_ */