static char rcsid[] = "$Id$";
#endif
+#if __STDC__
+#include <stdarg.h>
+#endif
+
/* This program converts either human-readable or compact EM
assembly code to calls of the procedure-interface.
It must be linked with two libraries:
linked.
*/
+#include <stdio.h>
#include <stdlib.h>
#include "system.h"
#include "em_pseu.h"
#include "em.h"
#include "em_comp.h"
+#if __STDC__
+void error(char *fmt, ...);
+void fatal(char *fmt, ...);
+#else
+void error();
+void fatal();
+#endif
+
char *filename; /* Name of input file */
int errors; /* Number of errors */
extern char *C_error;
-main(argc,argv)
- char **argv;
+int main(int argc, char *argv[])
{
struct e_instr buf;
- register struct e_instr *p = &buf;
+ struct e_instr *p = &buf;
if (argc >= 2) {
filename = argv[1];
C_close();
EM_close();
exit(errors);
+ return errors;
+}
+
+
+#if __STDC__
+void error(char *fmt, ...)
+{
+ va_list ap;
+ fprint(stderr,
+ "%s, line %d: ",
+ filename ? filename : "standard input",
+ EM_lineno);
+
+ va_start(ap, fmt);
+ vfprintf(stderr, fmt, ap);
+ fprintf(stderr, "\n");
+ va_end(ap);
+}
+
+void fatal(char *fmt, ...)
+{
+ va_list ap;
+
+ if (C_busy()) C_close();
+
+ fprint(stderr,
+ "%s, line %d: ",
+ filename ? filename : "standard input",
+ EM_lineno);
+
+ va_start(ap, fmt);
+ vfprintf(stderr, fmt, ap);
+ fprintf(stderr, "\n");
+ va_end(ap);
+
+ exit(1);
}
+#else /* __STDC__ */
/* VARARGS */
error(s,a1,a2,a3,a4)
error(s,a1,a2,a3,a4);
exit(1);
}
+#endif /* __STDC__ */
long ptr7;
long ptr8;
-main(argc, argv)
- int argc;
- char *argv[];
+void esize(char *fname);
+void rd_close();
+
+int main(int argc, char *argv[])
{
printf("TPFCRE uref vers w/p text nproc szdata\n");
}
}
exit(0);
+ return 0;
}
-esize(fname)
- char *fname;
+void esize(char *fname)
{
eof = 0;
if (!rd_open(fname)) {
#define btol(a) ((long)(((long) (a)) & 0xFF))
-int
-rd_open(load_file)
- char *load_file;
+int rd_open(char *load_file)
{
return (load_fp = fopen(load_file, "r")) != NULL;
}
-int
-rd_byte()
+int rd_byte()
{
int i;
return (i);
}
-long
-rd_int(n)
- long n;
+long rd_int(long n)
{
long l;
- register int i;
+ int i;
l = btol(rd_byte());
for (i = 1; i < n; i++)
#define rd_ptr() ((ptr) rd_int(psize))
-int
-rd_header()
+int rd_header()
{
magic = rd_int(2L);
if (magic != MAGIC || eof)
return 0;
-
+
flags = rd_int(2L);
uref = rd_int(2L);
version = rd_int(2L);
return !eof;
}
-rd_close()
+void rd_close()
{
fclose(load_fp);
}
move_t l_moves[MAXMOVES];
short posmoves[MAXREGS+MAXTOKENS][SETSIZE];
-n_move(s1,e1,s2,e2,vi) struct varinfo *vi; {
- register move_p mp;
- register i,j;
+void n_split(int ti, int be, struct varinfo *al, struct varinfo *ge, struct varinfo *rp, int n);
+
+void n_move(int s1, int e1,int s2, int e2, struct varinfo *vi)
+{
+ move_p mp;
+ int i,j;
NEXT(nmoves,MAXMOVES,"Moves");
mp = &l_moves[nmoves-1];
posmoves[i][j] |= l_sets[mp->m_set2].set_val[j];
}
-existmove(from,sp) iocc_t from; short *sp; {
- register i;
+int existmove(iocc_t from, short *sp)
+{
+ int i;
for (i=0;i<MAXREGS+MAXTOKENS;i++)
if(BIT(from.in_set,i))
return(1);
}
-existalmove(from,prpno) iocc_t from; {
+int existalmove(iocc_t from, int prpno)
+{
short s[SETSIZE];
- register i;
+ int i;
for (i=0;i<SETSIZE;i++)
s[i] = i<SZOFSET(MAXREGS) ? l_props[prpno].pr_regset[i] : 0;
return(existmove(from,s));
}
-struct varinfo *gen_move(from,to) iocc_t from,to; {
- register struct varinfo *vp;
+struct varinfo *gen_move(iocc_t from, iocc_t to)
+{
+ struct varinfo *vp;
if (existmove(from,to.in_set)==0) {
error("No such move defined");
test_t l_tests[MAXTESTS];
short postests[SETSIZE];
-n_test(s,e,vi) struct varinfo *vi; {
- register test_p tp;
- register i;
+void n_test(int s, int e, struct varinfo *vi)
+{
+ test_p tp;
+ int i;
NEXT(ntests,MAXTESTS,"Tests");
tp = &l_tests[ntests-1];
postests[i] |= l_sets[tp->t_set].set_val[i];
}
-struct varinfo *gen_test(from) iocc_t from; {
- register struct varinfo *vp;
+struct varinfo *gen_test(iocc_t from)
+{
+ struct varinfo *vp;
if (!subset(from.in_set,postests,SETSIZE)) {
error("No such test");
return(vp);
}
-struct varinfo *gen_label(arg) int arg; {
- register struct varinfo *vp;
+struct varinfo *gen_label(int arg)
+{
+ struct varinfo *vp;
NEW(vp,struct varinfo);
vp->vi_int[0] = INSLABDEF;
return(vp);
}
-struct varinfo *gen_preturn() {
- register struct varinfo *vp;
+struct varinfo *gen_preturn()
+{
+ struct varinfo *vp;
NEW(vp,struct varinfo);
vp->vi_int[0] = INSPRETURN;
return(vp);
}
-struct varinfo *gen_tlab(n) {
- register struct varinfo *vp;
+struct varinfo *gen_tlab(int n)
+{
+ struct varinfo *vp;
- assert(n>=0 && n<=9);
+ assert((n>=0) && (n<=9));
NEW(vp,struct varinfo);
vp->vi_int[0] = INSTLAB;
vp->vi_int[1] = n;
c1_t l_stacks[MAXSTACKS];
set_t ustackset,cstackset;
-n_stack(s,e,p,vi) struct varinfo *vi; {
- register c1_p c1p;
- register short *sp;
- register i;
+void n_stack(int s, int e, int p, struct varinfo *vi)
+{
+ c1_p c1p;
+ short *sp;
+ int i;
NEXT(nstacks,MAXSTACKS,"Stacks");
c1p= & l_stacks[nstacks-1];
sp[i] |= l_sets[s].set_val[i];
}
-checkstacking(sp) register short *sp; {
- register i;
- register short *chkset;
+void checkstacking(short *sp)
+{
+ int i;
+ short *chkset;
char *warn;
if (subset(sp,ustackset.set_val,SETSIZE))
/*VARARGS5*/
-n_coerc(ti,be,al,ge,rp,in) struct varinfo *al,*ge,*rp; iocc_t in; {
- register c3_p c3p;
- register i;
- register struct varinfo *vi;
+void n_coerc(int ti, int be, struct varinfo *al, struct varinfo *ge, struct varinfo *rp, iocc_t in)
+{
+ c3_p c3p;
+ int i;
+ struct varinfo *vi;
if (ti!=0) {
for(i=0,vi=rp;vi!=0;vi=vi->vi_next,i++)
freevi(rp);
}
-checkunstacking(setno) {
- register short *sp;
- register i;
+void checkunstacking(int setno) {
+ short *sp;
+ int i;
short hallset[SETSIZE];
sp = l_sets[setno].set_val;
int nsplit,maxsplit;
c2_t l_split[MAXSPLCOERC];
-n_split(ti,be,al,ge,rp,n) struct varinfo *al,*ge,*rp; {
- register c2_p c2p;
- register i;
- register struct varinfo *vi;
+void n_split(int ti, int be, struct varinfo *al, struct varinfo *ge, struct varinfo *rp, int n)
+{
+ c2_p c2p;
+ int i;
+ struct varinfo *vi;
NEXT(nsplit,MAXSPLCOERC,"Splitting coercions");
c2p = &l_split[nsplit-1];
.r tokendefs
a
-enterkeyw() {
+void enterkeyw() {
register symbol *sy_p;
.
#define HASHSIZE (2*(sp_lmnem-sp_fmnem))
+void enter(char *name, int value);
+
struct emhashmnem {
char h_name[3];
char h_value;
} emhashmnem[HASHSIZE];
-initemhash() {
- register i;
+void initemhash()
+{
+ 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; {
- register unsigned sum;
- register i;
+unsigned int emhash(char *name)
+{
+ unsigned int sum;
+ int i;
for (sum=i=0;*name;i+=3)
sum ^= (*name++)<<(i&07);
return(sum);
}
-enter(name,value) char *name; {
- register unsigned h;
+void enter(char *name, int value)
+{
+ unsigned int h;
h=emhash(name)%HASHSIZE;
while (emhashmnem[h].h_name[0] != 0)
emhashmnem[h].h_value = value;
}
-int mlookup(name) char *name; {
- register unsigned h;
+int mlookup(char *name)
+{
+ unsigned int h;
h = emhash(name)%HASHSIZE;
while (strncmp(emhashmnem[h].h_name,name,3) != 0 &&
extern char em_flag[];
-argtyp(mn) {
-
+int argtyp(int mn)
+{
switch(em_flag[mn-sp_fmnem]&EM_PAR) {
case PAR_W:
case PAR_S:
static char rcsid[]= "$Id$";
#endif
+#if __STDC__
+#include <stdarg.h>
+#endif
+
#include <stdlib.h>
#include <stdio.h>
-int nerrors=0;
+#if __STDC__
+void error(char *fmt, ...);
+#else
+void error();
+#endif
-yyerror(s) char *s; {
+int nerrors=0;
+void yyerror(char *s)
+{
error("Parser gives %s",s);
}
-goodbye() {
+void goodbye()
+{
error("This was fatal, goodbye!");
#ifndef NDEBUG
#endif
}
+#if __STDC__
+/*VARARGS1*/
+void error(char *fmt, ...)
+{
+ extern int lineno;
+ extern char *filename;
+ va_list ap;
+ fprintf(stderr,"\"%s\", line %d:",filename,lineno);
+ va_start(ap, fmt);
+ vfprintf(stderr, fmt, ap);
+ fprintf(stderr, "\n");
+ va_end(ap);
+ nerrors++;
+}
+/*VARARGS1*/
+void fatal(char *fmt, ...)
+{
+ extern int lineno;
+ extern char *filename;
+
+ va_list ap;
+ fprintf(stderr,"\"%s\", line %d:",filename,lineno);
+ va_start(ap, fmt);
+ vfprintf(stderr, fmt, ap);
+ fprintf(stderr, "\n");
+ va_end(ap);
+ nerrors++;
+
+ errorexit();
+ goodbye();
+ exit(-1);
+}
+#else /* __STDC__ */
/*VARARGS1*/
fatal(s,a,b,c,d) char *s; {
fprintf(stderr,"\n");
nerrors++;
}
+#endif
#ifndef NDEBUG
-badassertion(string,file,line) char *string,*file; {
-
+void badassertion(char *string, char *file, int line)
+{
fprintf(stderr,"\"%s\", line %d: Assertion failed \"%s\"\n",
file,line,string);
goodbye();
}
#endif
-tabovf(string) char *string; {
-
- fatal("%s overflow",string);
+void tabovf(char *string)
+{
+ fatal("%s overflow", string);
}
static char rcsid[]= "$Id$";
#endif
+#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "assert.h"
extern set_t l_sets[];
-i_expr(e) expr_t e; {
+void subregset(short *sp, int subreg, short *regset);
+int i_expr(expr_t e)
+{
if (e.ex_typ != TYPINT)
error("Expression should be integer");
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);
}
-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;
return(result);
}
-expr_t regno_expr(regno) {
+expr_t regno_expr(int regno)
+{
expr_t result;
- register i;
+ int i;
result.ex_typ = TYPREG;
result.ex_index = ex_lookup(EX_REG,regno,0);
return(result);
}
-expr_t ident_expr(name) char *name; {
- register symbol *sy_p;
+expr_t ident_expr(char *name)
+{
+ symbol *sy_p;
sy_p = lookup(name,symany,mustexist);
if (sy_p->sy_type==symconst)
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;
return(result);
}
-subregset(sp,subreg,regset) register short *sp; register short *regset; {
- register i;
- register reginfo *rp;
+void subregset(short *sp, int subreg, short *regset)
+{
+ int i;
+ reginfo *rp;
for (i=0;i<SZOFSET(MAXREGS);i++)
regset[i]=0;
l_tokens[i-nregs]->tk_name);
}
-membset(setno,name,regset,appearance,restyp,typp)
-char *name,*appearance;
-short *regset;
-int *typp;
+int membset(int setno, char *name, short *regset, char *appearance, int restyp, int *typp)
{
register short *sp;
register token_p tp;
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;
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;
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);
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 short *sp;
+ int i;
+ short *sp;
expr_t result;
sp = l_props[allreg[all_no]].pr_regset;
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) {
}
}
-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) {
}
}
-expr_t sum_expr(e1,e2) expr_t e1,e2; {
+expr_t sum_expr(expr_t e1, expr_t e2)
+{
int operator,op1,op2;
expr_t result;
return(result);
}
-expr_t iextoaddr(e) expr_t e; {
+expr_t iextoaddr(expr_t e)
+{
expr_t result;
result.ex_typ = TYPADDR;
return(result);
}
-expr_t regvar_expr(e,regtyp) expr_t e; {
+expr_t regvar_expr(expr_t e, int regtyp)
+{
expr_t result;
- register i;
+ int i;
result = make_expr(TYPREG,EX_REGVAR,i_expr(e),0);
for(i=0;i<SZOFSET(MAXREGS);i++)
BIS(result.ex_regset,rvnumbers[regtyp][i]);
return(result);
}
-
+
/*
* Node table lookup part
*/
node_t nodes[MAXNODES];
int nnodes=0;
-initnodes() {
-
+void initnodes()
+{
nodes[0].ex_operator = EX_CON;
nodes[0].ex_lnode = 0;
nodes[0].ex_rnode = 0;
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++) {
* See the copyright notice in the ACK home directory, in the file "Copyright".
*/
/* $Id$ */
+#ifndef UTIL_NCGG_EXTERN_H
+#define UTIL_NCGG_EXTERN_H
extern int wordsize;
extern int pointersize;
extern int nprocargs, maxprocargs;
extern int use_tes;
-extern char *mystrcpy();
-extern char *myalloc();
+char *myalloc(int n);
+char *mystrcpy(char *s);
+
+#endif /* UTIL_NCGG_EXTERN_H */
\ No newline at end of file
#include "set.h"
#include <stdio.h>
+void unite(short *sp, short *into);
+
/*
* This file implements the marriage thesis from Hall.
* The thesis says that given a number, say N, of subsets from
int nhallsets= -1;
int hallfreq[MAXHALL][2];
-hallverbose() {
- register i;
- register max;
+void hallverbose()
+{
+ int i;
+ 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--)
fprintf(stderr,"%3d%6d%6d\n",i,hallfreq[i][0],hallfreq[i][1]);
}
-inithall() {
-
+void inithall()
+{
assert(nhallsets == -1);
nhallsets=0;
}
-nexthall(sp) register short *sp; {
- register i;
-
+void nexthall(short *sp)
+{
+ int i;
+
assert(nhallsets>=0);
for(i=0;i<SETSIZE;i++)
hallsets[nhallsets][i] = sp[i];
nhallsets++;
}
-card(sp) register short *sp; {
- register sum,i;
-
+int card(short *sp)
+{
+ int sum,i;
+
sum=0;
for(i=0;i<8*sizeof(short)*SETSIZE;i++)
if (BIT(sp,i))
return(sum);
}
-checkhall() {
-
+void checkhall()
+{
assert(nhallsets>=0);
if (!hall())
error("Hall says: \"You can't have those registers\"");
}
-hall() {
- register i,j,k;
+int hall()
+{
+ int i,j,k;
int ok;
hallfreq[nhallsets][0]++;
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;
-
+ int i,j,k,ncopys;
+
/*
* First check cardinality of union of all
*/
return(1);
}
-unite(sp,into) register short *sp,*into; {
- register i;
-
+void unite(short *sp, short *into)
+{
+ int i;
+
for(i=0;i<SETSIZE;i++)
into[i] |= sp[i];
}
static char rcsid[]= "$Id$";
#endif
+#include <string.h>
+
#include "param.h"
#include "instruct.h"
#include "pseudo.h"
extern expr_t subreg_expr(),regno_expr();
-struct varinfo * setcoco(n) {
+struct varinfo *setcoco(int n)
+{
struct varinfo *vi;
NEW(vi,struct varinfo);
return(vi);
}
-struct varinfo * generase(n) {
+struct varinfo *generase(int n)
+{
struct varinfo *vi;
NEW(vi,struct varinfo);
return(vi);
}
-struct varinfo * genremove(n) {
+struct varinfo *genremove(int n)
+{
struct varinfo *vi;
NEW(vi,struct varinfo);
return(vi);
}
-onlyreg(argno) {
- register bitno;
- register short *sp;
-
+int onlyreg(int argno)
+{
+ int bitno;
+ short *sp;
+
if (! argno) argno++;
sp = l_sets[tokpatset[argno-1]].set_val;
for(bitno=nregs;bitno<nregs+ntokens;bitno++)
return(1);
}
-makescratch(argno) {
+void makescratch(int argno)
+{
set_t s;
if (! argno) argno++;
tokpatset[argno-1] = setlookup(s);
}
-struct varinfo *gen_inst(ident,star) char *ident; {
- register struct varinfo *vi,*retval,*eravi;
- register instr_p ip;
- register struct operand *op;
- register i;
- register inst_p insta;
+struct varinfo *gen_inst(char *ident, int star)
+{
+ struct varinfo *vi,*retval,*eravi;
+ instr_p ip;
+ struct operand *op;
+ int i;
+ inst_p insta;
if (star && !inproc)
error("Variable instruction only allowed inside proc");
static char rcsid[]= "$Id$";
#endif
+#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "assert.h"
int narexpr;
expr_t arexp[MAXATT];
-expr_t iextoaddr();
+expr_t iextoaddr(expr_t e);
-iocc_t subr_iocc(tokarg,subreg) {
+
+iocc_t subr_iocc(int tokarg, int subreg)
+{
inst_t insta;
iocc_t result;
- register i;
+ int i;
insta.in_which = IN_COPY;
insta.in_info[0] = tokarg;
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;
+ int i;
char app[100];
int dummy;
return(result);
}
-iocc_t percident_iocc(ident) char *ident; {
+iocc_t percident_iocc(char *ident)
+{
iocc_t result;
inst_t insta;
- register i;
+ int i;
char app[100];
int dummy;
return(result);
}
-iocc_t ident_iocc(ident) char *ident; {
+iocc_t ident_iocc(char *ident)
+{
iocc_t result;
inst_t insta;
- register i;
- register symbol *sy_p;
+ int i;
+ symbol *sy_p;
for(i=0;i<SETSIZE;i++)
result.in_set[i] = 0;
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;
+ int i;
set_t localset;
- register short *sp;
+ short *sp;
sp = l_props[allreg[all_no]].pr_regset;
for (i=0;i<SETSIZE;i++)
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;
+ symbol *sy_p;
+ token_p tp;
+ int i;
int typerr;
for(i=0;i<SETSIZE;i++)
default: assert(0);
case TYPINT:
if (tp->tk_att[i].ta_type != -1)
+ {
if (tp->tk_att[i].ta_type == -2)
+ {
arexp[i] = iextoaddr(arexp[i]);
+ }
else
+ {
typerr++;
+ }
+ }
break;
case TYPBOOL:
typerr++; break;
int ninstances=1;
inst_t l_instances[MAXINSTANCES];
-instalookup(insta,filled) inst_t insta; {
- register i,j;
+int instalookup(inst_t insta, int filled)
+{
+ int i,j;
for (j=filled;j<=MAXATT;j++)
insta.in_info[j] = 0;
static char rcsid[]= "$Id$";
#endif
+#include <string.h>
#include "assert.h"
#include "param.h"
#include "lookup.h"
+#include "extern.h"
-char *myalloc();
-char *mystrcpy();
+unsigned int hashvalue(char *s);
symbol dumsym; /* dummy to return in case of error */
-symbol *lookup(name,type,style)
-char *name;
-symtype type;
-lookupstyle style;
+symbol *lookup(char *name, symtype type, lookupstyle style)
{
symbol *sy_p,**sy_pp;
}
}
-hashvalue(s) register char *s; {
- register unsigned sum=0;
- register i;
+unsigned int hashvalue(char *s)
+{
+ unsigned int sum=0;
+ int i;
for(i=0;*s;s++,i=(i+3)&07)
sum += *s<<i;
* (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
* See the copyright notice in the ACK home directory, in the file "Copyright".
*/
-/* #define CODEDEBUG /* print readable code */
+/* #define CODEDEBUG */ /* print readable code */
#ifdef CODEDEBUG
int code_in_c=0; /* put readable code in "code" */
int tabledebug=1; /* generate code for table debugging */
int maxregvars=0;
int setsize;
-opnfile(f,s) FILE **f; char *s; {
+void pat(int n);
+void patbyte(int n);
+void patshort(int n);
+void opnfile(FILE **f, char *s)
+{
if ((*f=fopen(s,"w"))==NULL)
fatal("Can't create %s",s);
}
-unlfile(f,s) FILE *f; char *s; {
-
+void unlfile(FILE *f, char *s)
+{
if (f) fclose(f);
if (unlink(s)<0)
error("%s incorrect, must be removed!!",s);
}
-initio() {
- extern char *myalloc();
-
+void initio()
+{
opnfile(&ctable,c_file);
opnfile(&htable,h_file);
if (code_in_c)
lineset = (short *) myalloc(SZOFSET(MAXSOURCELINES)*sizeof(short));
}
-finishcode() {
-
+void finishcode()
+{
if (code_in_c)
fprintf(ctable,"\n};\n\n");
fprintf(ctable, "int allsetno = %d;\n", allsetno);
}
}
-errorexit() {
-
+void errorexit()
+{
unlfile(ctable,c_file);
unlfile(htable,h_file);
if (!code_in_c)
#define code53(x,y) fprintf(code,"%s-%d","x",y)
#define codeint(x) fprintf(code," %d",x)
#define codenl() fprintf(code,"\n")
-#else
+#else /* CODEDEBUG */
#define codenl()
#define code8nl(x) code8(x)
-code8(x) {
-
+void code8(int x)
+{
codeindex++;
if (code_in_c)
fprintf(ctable,"%d,",x&0377);
putc(x,code);
}
-code53(x,y) {
-
+void code53(int x, int y)
+{
code8(x+(y<<5));
}
-codeint(x) {
-
+void codeint(int x)
+{
assert(x>=0 && x<=32767);
if (x<128) {
code8(x);
}
}
-#endif
+#endif /* CODEDEBUG */
+
int prevind=0;
int npatbytes= -1;
char pattern[MAXPATBYTES];
int pathash[256];
-outpatterns() {
+void outpatterns()
+{
extern int npatterns;
extern int patindex[];
extern int empatlen;
extern int emmnem[];
extern int empatexpr;
- register i;
+ int i;
if (!inproc) {
patbyte(0);
}
}
-pat(n) {
-
+void pat(int n)
+{
assert(n>=0);
if (n<128)
patbyte(n);
}
}
-patshort(n) {
-
+void patshort(int n)
+{
patbyte(n%256);
patbyte(n/256);
}
-patbyte(n) {
-
+void patbyte(int n)
+{
NEXT(npatbytes, MAXPATBYTES, "Pattern bytes");
pattern[npatbytes]=n;
}
-hashpatterns() {
+void hashpatterns()
+{
short index;
- register char *bp,*tp;
- register short i;
- unsigned short hashvalue;
+ char *bp,*tp;
+ short i;
+ short hashvalue;
int patlen;
index = prevind;
}
}
-outincludes() {
-
+void outincludes()
+{
fprintf(ctable,"#include \"param.h\"\n");
fprintf(ctable,"#include \"tables.h\"\n");
fprintf(ctable,"#include \"types.h\"\n");
fprintf(ctable,"#include \"data.h\"\n");
}
-outregs() {
- register i,j,k;
+void outregs()
+{
+ int i,j,k;
short rset[SZOFSET(MAXREGS)];
short clashlist[MAXREGS*MAXREGS];
int iclashlist = 0;
fprintf(ctable, "0};\n\n");
}
-outregvars() {
- register i,j;
+void outregvars()
+{
+ int i,j;
fprintf(htable,"#define REGVARS\n");
fprintf(ctable,"#include \"regvar.h\"\n");
fprintf(ctable,"};\n");
}
-typeconv(n) {
-
+int typeconv(int n)
+{
if (n>=0) return(2);
if (n== -1) return(1);
if (n== -2) return(3);
return(0);
}
-outfmt(p)
-register char *p;
+void outfmt(char *p)
{
register int c;
fprintf(ctable,"\"");
fprintf(ctable,"\"");
}
-outtokens() {
- register tokno,i;
- register token_p tp;
+void outtokens()
+{
+ int tokno,i;
+ token_p tp;
fprintf(ctable,"tkdef_t tokens[] = {{0},\n");
for (tokno=1;tokno<ntokens;tokno++) {
fprintf(ctable,"{0}};\n\n");
}
-outenodes() {
- register node_p np;
+void outenodes()
+{
+ node_p np;
extern node_t nodes[];
extern int nnodes;
fprintf(ctable,"};\n\n");
}
-outstrings() {
- register i;
- register char *p;
- register int c;
+void outstrings()
+{
+ int i;
+ char *p;
+ int c;
extern char * filename;
if (tabledebug)
extern set_t unstackset;
-outsets() {
- register i;
- register set_p sp;
+void outsets()
+{
+ int i;
+ set_p sp;
fprintf(ctable,"set_t machsets[] = {\n");
for (sp=l_sets;sp< &l_sets[nsets]; sp++) {
fprintf(ctable,"}};\n\n");
}
-outinstances() {
- register inst_p ip;
- register i;
+void outinstances()
+{
+ inst_p ip;
+ int i;
fprintf(ctable,"inst_t tokeninstances[] = {\n");
for (ip=l_instances;ip< &l_instances[ninstances]; ip++) {
fprintf(ctable,"};\n\n");
}
-outmoves() {
- register move_p mp;
+void outmoves()
+{
+ move_p mp;
fprintf(ctable,"move_t moves[] = {\n");
for (mp=l_moves; mp< &l_moves[nmoves]; mp++)
fprintf(ctable,"{-1}\n};\n\n");
}
-outtests() {
- register test_p tp;
+void outtests()
+{
+ test_p tp;
fprintf(ctable,"test_t tests[] = {\n");
for (tp=l_tests; tp< &l_tests[ntests]; tp++)
fprintf(ctable,"{-1}\n};\n\n");
}
-outstacks() {
- register c1_p cp;
+void outstacks()
+{
+ c1_p cp;
fprintf(ctable,"c1_t c1coercs[] = {\n");
for (cp=l_stacks; cp< &l_stacks[nstacks]; cp++)
fprintf(ctable,"{-1}\n};\n\n");
}
-outsplits() {
- register c2_p cp;
- register i;
+void outsplits()
+{
+ c2_p cp;
+ int i;
fprintf(ctable,"c2_t c2coercs[] = {\n");
for (cp=l_split; cp< &l_split[nsplit]; cp++) {
fprintf(ctable,"{-1}\n};\n\n");
}
-outcoercs() {
- register c3_p cp;
+void outcoercs()
+{
+ c3_p cp;
fprintf(ctable,"c3_t c3coercs[] = {\n");
for (cp=l_coercs; cp< &l_coercs[ncoercs]; cp++)
fprintf(ctable,"{-1}\n};\n\n");
}
-outproplists() {
- register propno;
- register regno;
+void outproplists()
+{
+ int propno;
+ int regno;
for(propno=0;propno<nprops;propno++) {
fprintf(ctable,"struct reginfo *rlist%d[] = {\n",propno);
fprintf(ctable,"};\n\n");
}
-outconsts() {
-
+void outconsts()
+{
fprintf(ctable,"unsigned cc1 = %u;\n",fc1);
fprintf(ctable,"unsigned cc2 = %u;\n",fc2);
fprintf(ctable,"unsigned cc3 = %u;\n",fc3);
fprintf(ctable,"unsigned cc4 = %u;\n",fc4);
}
-cdef(s,n) char *s; {
-
+void cdef(char *s, int n)
+{
fprintf(htable,"#define %s %d\n",s,n);
}
-passon(s) char *s; {
+void passon(char *s)
+{
char buf[32];
sprintf(buf,"T%s",s);
cdef(buf,cmustbeset(s));
}
-outdefs() {
- register symbol *sy_p;
+void outdefs()
+{
+ symbol *sy_p;
extern int maxempatlen,maxrule;
char *wrdfmt;
cdef("USE_TES",1);
}
-outars() {
- register i;
+void outars()
+{
+ int i;
if (code_in_c)
fprintf(htable,"#define CODEINC 1\n");
fprintf(ctable,"};\n");
}
-finishio() {
- extern int nregs;
+void finishio()
+{
+ int nregs;
finishcode();
hashpatterns();
outars();
}
-codecoco(cocono) {
-
+void codecoco(cocono)
+{
if (cocono== -1)
return;
code8(DO_SETCC);
codenl();
}
-dopattern(stackcoerc,kills,allocates,generates,yields,leaving)
-varinfo *kills,*allocates,*generates,*yields,*leaving;
+void dopattern(int stackcoerc, varinfo *kills, varinfo *allocates, varinfo *generates, varinfo *yields, varinfo *leaving)
{
- register i;
+ int i;
int n,nops;
- register struct varinfo *vp,*vivp;
- register instr_p instp;
+ struct varinfo *vp,*vivp;
+ instr_p instp;
int al,deal;
int vil;
int cocono= -1;
code8nl(DO_NEXTEM);
}
-used(resource,use,max) char *resource; {
-
+void used(char *resource, int use, int max)
+{
if (verbose || 4*use > 3*max)
fprintf(stderr,"%s %d(%d)\n",resource,use,max);
}
-statistics() {
+void statistics()
+{
extern char *beg_sbrk,*sbrk();
extern int nnodes, maxempatlen,maxrule;
static char rcsid2[]= "$Id$";
#endif
-char *mystrcpy();
-int myatoi();
+#include "extern.h"
int lineno=1;
extern char *filename;
do {
while (c!='*') {
c = input();
- if (c=='\n') lineno++;
- }
+ if (c=='\n') lineno++;
+ }
c = input();
- if (c=='\n') lineno++;
+ if (c=='\n') lineno++;
} while (c!='/');
}
^\#(line)?[ \t]*[0-9]+[ \t]+\".*\".*$ {
%%
int skipping=0;
-yywrap() {
-
+int yywrap()
+{
if (skipping)
fatal("EOF reached during error recovery");
return(1);
#define yytext_ptr yytext
-skipupto(tok,str) char *str; {
- register i;
+void skipupto(int tok, char *str)
+{
+ int i;
skipping=1;
while (yylex()!=tok)
extern set_t l_sets[];
-setlookup(s) set_t s; {
- register set_p p;
- register i;
+int setlookup(set_t s)
+{
+ set_p p;
+ int i;
int setno;
for(p=l_sets;p<&l_sets[nsets];p++) {
return(setno);
}
-make_std_sets() {
+void make_std_sets()
+{
set_t s;
- register i;
+ int i;
for(i=0;i<SETSIZE;i++)
s.set_val[i]=0;
set_t emptyset;
-set_t ident_to_set(name) char *name; {
- register symbol *sy_p;
- register i;
- register struct propinfo *pp;
+set_t ident_to_set(char *name)
+{
+ symbol *sy_p;
+ int i;
+ struct propinfo *pp;
int bitno;
set_t result;
return(result);
}
-static
-checksize(s)
- register set_p s;
+static void checksize(set_p s)
{
- register int i;
- register int size = -1;
+ int i;
+ int size = -1;
s->set_size = 0;
for (i = 1; i <= nregs; i++) {
if (BIT(s->set_val, i)) {
- register int sz = l_regs[i].ri_size;
+ int sz = l_regs[i].ri_size;
if (size == -1) size = sz;
else if (size != sz) return;
}
for (i = 1; i <= ntokens; i++) {
if (BIT(s->set_val, i+nregs)) {
- register int sz = l_tokens[i]->tk_size;
+ int sz = l_tokens[i]->tk_size;
if (size == -1) size = sz;
else if (size != sz) return;
}
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;
+ int i;
for(i=0;i<SETSIZE;i++)
result.set_val[i] = s1.set_val[i] & s2.set_val[i];
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;
+ int i;
if (s1.set_size == s2.set_size)
result.set_size = s1.set_size;
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;
+ int i;
for(i=0;i<SETSIZE;i++)
result.set_val[i] = s1.set_val[i] & ~ s2.set_val[i];
static char rcsid[]= "$Id$";
#endif
+#include <string.h>
#include "param.h"
+#include "extern.h"
int nstrings=0;
char *l_strings[MAXSTRINGS];
-strlookup(str) char *str; {
- register i;
- extern char *mystrcpy();
+int strlookup(char *str)
+{
+ int i;
for(i=0;i<nstrings;i++)
if (strcmp(str,l_strings[i])==0)
#include <cgg_cg.h>
#include "extern.h"
-n_proc(name) char *name; {
- register symbol *sy_p;
+expr_t ident_expr(char *name);
+
+void n_proc(char *name)
+{
+ symbol *sy_p;
extern int npatbytes;
sy_p = lookup(name,symproc,newsymbol);
sy_p->sy_value.syv_procoff = npatbytes + 1;
}
-struct varinfo *
-make_erase(name) char *name; {
- expr_t e,ident_expr();
+struct varinfo *make_erase(char *name)
+{
+ expr_t e;
struct varinfo *result;
e = ident_expr(name);
return(result);
}
-n_instr(name,asname,oplist,eraselist,cost)
-char *name,*asname;
-operand *oplist;
-struct varinfo *eraselist,*cost;
+void n_instr(char *name, char *asname, operand *oplist, struct varinfo *eraselist, struct varinfo *cost)
{
- register instrno;
- register cc_count;
- register instr_p ip;
+ int instrno;
+ int cc_count;
+ instr_p ip;
instrno = NEXT(ninstr,MAXINSTR,"Instructions");
ip = &l_instr[instrno];
error("No instruction can set condition codes more than once");
}
-n_set(name,number) char *name; {
- register symbol *sy_p;
+void n_set(char *name, int number)
+{
+ symbol *sy_p;
sy_p = lookup(name,symset,newsymbol);
sy_p->sy_value.syv_setno = number;
}
-n_tok(name,atts,size,cost,format)
-char *name;
-struct varinfo *atts,*cost,*format;
+void n_tok(char *name,struct varinfo *atts, int size, struct varinfo *cost, struct varinfo *format)
{
- register symbol *sy_p;
- register token_p tp;
- register struct varinfo *vip;
+ symbol *sy_p;
+ token_p tp;
+ struct varinfo *vip;
int i;
int tokno;
int thistokensize;
tp->tk_format = -1;
}
-checkprintformat(n) {
- register short *s;
- register i;
+void checkprintformat(int n)
+{
+ short *s;
+ int i;
extern set_t l_sets[];
s= l_sets[n].set_val;
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;
+ symbol *sp;
propno = NEXT(nprops,MAXPROPS,"Properties");
sp = lookup(name,symprop,newsymbol);
l_props[propno].pr_size = size;
}
-prophall(n) {
- register i;
+void prophall(int n) {
+ int i;
short hallset[SETSIZE];
if (n < 0) return;
nexthall(hallset);
}
-n_reg(name,printstring,nmemb,member1,member2) char *name,*printstring; {
- register symbol *sy_p;
- register reginfo *ri_p;
+int n_reg(char *name, char *printstring, int nmemb, int member1, int member2)
+{
+ symbol *sy_p;
+ reginfo *ri_p;
int regno;
sy_p = lookup(name,symreg,newsymbol);
return(regno);
}
-make_const() {
-
+void make_const()
+{
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);
}
-n_const(ident,val) char *ident; {
- register symbol *sy_p;
+void n_const(char *ident, int val)
+{
+ symbol *sy_p;
sy_p = lookup(ident,symconst,newsymbol);
sy_p->sy_value.syv_cstval = val;
}
-n_sconst(ident,val) char *ident,*val; {
- register symbol *sy_p;
+void n_sconst(char *ident, char *val)
+{
+ symbol *sy_p;
sy_p = lookup(ident,symsconst,newsymbol);
sy_p->sy_value.syv_stringno = strlookup(val);
}
-regline(rl,pl,rv) varinfo *rl,*pl; {
- register varinfo *rrl,*rpl;
- register short *sp;
- register reginfo *regp;
+void regline(varinfo *rl, varinfo *pl, int rv)
+{
+ varinfo *rrl,*rpl;
+ short *sp;
+ reginfo *regp;
int thissize;
int propno;
if (nregvar[rv]==0)
rvsize[rv] = regp->ri_size;
else if (rvsize[rv]!=regp->ri_size)
- error("All register variables of one type must have the same size");
+ error("All variables of one type must have the same size");
NEXT(nregvar[rv],MAXREGVAR,"Register variable");
rvnumbers[rv][nregvar[rv]-1] = rrl->vi_int[0];
}
regclass++;
}
-setallreg(vi) struct varinfo *vi; {
-
+void setallreg(struct varinfo *vi)
+{
nallreg=0;
for(;vi!=0;vi=vi->vi_next) {
if (vi->vi_int[0]<0)
}
}
-freevi(vip) register struct varinfo *vip; {
- register i;
+void freevi(struct varinfo *vip)
+{
+ int i;
if (vip==0)
return;
free(vip);
}
-int myatoi(s) register char *s; {
- register int base=10;
- register sum=0;
+int myatoi(char *s)
+{
+ int base=10;
+ int sum=0;
if (*s=='0') {
base = 8;
}
}
-char *mystrcpy(s) char *s; {
- register char *p;
- char *myalloc();
+char *mystrcpy(char *s)
+{
+ char *p;
p=myalloc(strlen(s)+1);
strcpy(p,s);
return(p);
}
-char *myalloc(n) register n; {
- register char *p,*result;
+char *myalloc(int n)
+{
+ char *p,*result;
result=p=malloc(n);
if (p== (char *) 0)
return(result);
}
-chkincl(value,lwb,upb) {
-
+int chkincl(int value, int lwb, int upb)
+{
if (value<lwb || value>upb)
error("Number %d should have been between %d and %d",
value,lwb,upb);
return(value);
}
-subset(sp1,sp2,setsize) short *sp1,*sp2; {
- register i;
+int subset(short *sp1, short *sp2, int setsize)
+{
+ int i;
for(i=0;i<setsize;i++)
if ( (sp1[i] | sp2[i]) != sp2[i])
return(1);
}
-vilength(vip) register struct varinfo *vip; {
- register l=0;
+int vilength(struct varinfo *vip)
+{
+ int l=0;
while(vip!=0) {
vip=vip->vi_next;
#include <stdlib.h>
#include <stdio.h>
+#include <unistd.h>
#include "param.h"
#include "types.h"
#include "tes.h"
#ifdef USEMALLOC
-short * myalloc();
+short *myalloc(int size);
#define newcore(size) myalloc(size)
#define oldcore(p,size) free(p)
#define CCHUNK 1024 /* number of shorts asked from system */
-short *newcore(),*freshcore();
-extern char *sbrk();
+short *newcore(int size);
+//short *freshcore();
#ifdef COREDEBUG
int shortsasked=0;
ABASE+sizeof(s_a_con),
};
+void oldline(line_p lnp);
+void oldargb(argb_p abp);
+void oldreg(reg_p rp);
+
/*
* alloc routines:
* Two parts:
* PART 1
*/
-line_p newline(optyp) int optyp; {
- register line_p lnp;
- register kind=optyp;
+line_p newline(int optyp)
+{
+ line_p lnp;
+ int kind=optyp;
if (kind>OPMINI)
kind = OPMINI;
return(lnp);
}
-oldline(lnp) register line_p lnp; {
- register kind=lnp->l_optyp&BMASK;
+void oldline(line_p lnp)
+{
+ int kind=lnp->l_optyp&BMASK;
if (kind>OPMINI)
kind = OPMINI;
oldcore((short *) lnp,lsizetab[kind]);
}
-arg_p newarg(kind) int kind; {
- register arg_p ap;
+arg_p newarg(int kind)
+{
+ arg_p ap;
ap = (arg_p) newcore(asizetab[kind]);
ap->a_typ = kind;
return(ap);
}
-oldargs(ap) register arg_p ap; {
- register arg_p next;
+void ldargs(arg_p ap)
+{
+ arg_p next;
while (ap != (arg_p) 0) {
next = ap->a_next;
}
}
-oldargb(abp) register argb_p abp; {
- register argb_p next;
+void oldargb(argb_p abp)
+{
+ argb_p next;
while (abp != (argb_p) 0) {
next = abp->ab_next;
}
}
-reg_p newreg() {
-
+reg_p newreg()
+{
return((reg_p) newcore(sizeof(reg_t)));
}
-oldreg(rp) reg_p rp; {
-
+void oldreg(reg_p rp)
+{
oldcore((short *) rp,sizeof(reg_t));
}
return((num_p) newcore(sizeof(num_t)));
}
-oldnum(lp) num_p lp; {
-
+void oldnum(num_p lp)
+{
oldcore((short *) lp,sizeof(num_t));
}
-offset *newrom() {
-
+offset *newrom()
+{
return((offset *) newcore(MAXROM*sizeof(offset)));
}
-sym_p newsym(len) int len; {
+sym_p newsym(int len)
+{
/*
* sym_t includes a 2 character s_name at the end
* extend this structure with len-2 characters
return((sym_p) newcore(sizeof(sym_t) - 2 + len));
}
-argb_p newargb() {
-
+argb_p newargb()
+{
return((argb_p) newcore(sizeof(argb_t)));
}
#define SINC (sizeof(core_t)/sizeof(short))
#ifdef COREDEBUG
-coreverbose() {
- register size;
- register short *p;
- register sum;
+void coreverbose()
+{
+ int size;
+ short *p;
+ int sum;
sum = 0;
for(size=1;size<MAXSHORT;size++)
#ifdef SEPID
-compactcore() {
- register core_p corelist=0,tp,cl;
+void compactcore()
+{
+ core_p corelist=0,tp,cl;
int size;
#ifdef COREDEBUG
}
}
-short *grabcore(size) int size; {
- register short *p;
- register trysize;
+short *grabcore(int size)
+{
+ short *p;
+ int trysize;
/*
* Desperate situation, can't get more core from system.
}
#endif /* SEPID */
-short *newcore(size) int size; {
+short *newcore(int size)
+{
register short *p,*q;
size = (size + sizeof(int) - 1) & ~(sizeof(int) - 1);
* you can use these as substitutes
*/
-char *malloc(size) int size; {
-
+char *malloc(int size)
+{
/*
* malloc(III) is called by stdio,
* this routine is a substitute.
return( (char *) newcore(size));
}
-free() {
+void free(void *ptr)
+{
}
#endif
-oldcore(p,size) short *p; int size; {
+void oldcore(short *p, int size)
+{
#ifdef CORECHECK
- register short *cp;
+ short *cp;
#endif
assert(size<2*MAXSHORT);
short *ccur,*cend;
-coreinit(p1,p2) short *p1,*p2; {
-
+void coreinit(short *p1, short *p2)
+{
/*
* coreinit is called with the boundaries of a piece of
* memory that can be used for starters.
cend = p2;
}
-short *freshcore(size) int size; {
- register short *temp;
+short *freshcore(int size)
+{
+ short *temp;
static int cchunk=CCHUNK;
while(&ccur[size/sizeof(short)] >= cend && cchunk>0) {
#else /* USEMALLOC */
-coreinit() {
+void coreinit() {
/*
* Empty function, no initialization needed
*/
}
-short *myalloc(size) register size; {
+short *myalloc(int size)
+{
register short *p,*q;
p = (short *)malloc(size);
if (p == 0)
- error("out of memory");
+ error("out of memory", NULL);
for(q=p;size>0;size -= sizeof(short))
*q++ = 0;
return(p);
extern argb_p newargb();
extern reg_p newreg();
-extern oldline();
-extern oldloc();
-extern oldreg();
+
+
+void oldline(line_p lnp);
+void oldargb(argb_p abp);
+void oldreg(reg_p rp);
#define USEMALLOC /* if defined malloc() and free() are used */
offset rombuf[MAXROM];
int rc;
-extern offset aoff();
-
-backward() {
- register line_p lnp;
+void backward()
+{
+ line_p lnp;
line_p next;
- register arg_p ap;
+ arg_p ap;
line_p i,p;
int n;
- register sym_p sp;
+ sym_p sp;
i = p = (line_p) 0;
curdtyp=0;
*/
-cleanup() {
+void cleanup()
+{
FILE *infile;
- register c;
- register sym_p *spp,sp;
+ int c;
+ sym_p *spp,sp;
for (spp=symhash;spp< &symhash[NSYMHASH];spp++)
for (sp = *spp; sp != (sym_p) 0; sp = sp->s_next)
#define readbyte getchar
-short readshort() {
- register int l_byte, h_byte;
+int inpseudo(short n);
+void tstinpro();
+
+short readshort()
+{
+ int l_byte, h_byte;
l_byte = readbyte();
h_byte = readbyte();
}
#ifdef LONGOFF
-offset readoffset() {
- register long l;
- register int h_byte;
+offset readoffset()
+{
+ long l;
+ int h_byte;
l = readbyte();
l |= ((unsigned) readbyte())*256 ;
}
#endif
-draininput() {
-
+void draininput()
+{
/*
* called when MES ERR is encountered.
* Drain input in case it is a pipe.
;
}
-short getint() {
-
+short getint()
+{
switch(table2()) {
default: error("int expected");
case CSTX1:
}
}
-sym_p getsym(status) int status; {
-
+sym_p getsym(int status)
+{
switch(table2()) {
default:
error("symbol expected");
}
}
-offset getoff() {
-
+offset getoff()
+{
switch (table2()) {
default: error("offset expected");
case CSTX1:
}
}
-make_string(n) int n; {
-
+void make_string(int n)
+{
sprintf(string,".%u",n);
}
-inident() {
- register n;
- register char *p = string;
- register c;
+void inident()
+{
+ int n;
+ char *p = string;
+ int c;
n = getint();
while (n--) {
*p++ = 0;
}
-int table3(n) int n; {
-
+int table3(int n)
+{
switch (n) {
case sp_ilb1: tabval = readbyte(); return(ILBX);
case sp_ilb2: tabval = readshort(); return(ILBX);
}
}
-int table1() {
- register n;
+int table1()
+{
+ int n;
n = readbyte();
if (n == EOF)
return(table3(n));
}
-int table2() {
- register n;
+int table2()
+{
+ int n;
n = readbyte();
if ((n < sp_fcst0 + sp_ncst0) && (n >= sp_fcst0)) {
return(table3(n));
}
-getlines() {
- register line_p lnp;
- register instr;
+void getlines()
+{
+ line_p lnp;
+ int instr;
for(;;) {
linecount++;
}
}
-argstring(length,abp) offset length; register argb_p abp; {
-
+void argstring(offset length, argb_p abp)
+{
while (length--) {
if (abp->ab_index == NARGBYTES)
abp = abp->ab_next = newargb();
}
}
-line_p arglist(n) int n; {
+line_p arglist(int n)
+{
line_p lnp;
- register arg_p ap,*app;
+ arg_p ap,*app;
bool moretocome;
offset length;
-
/*
* creates an arglist with n elements
* if n == 0 the arglist is variable and terminated by sp_cend
return(lnp);
}
-offset aoff(ap,n) register arg_p ap; {
-
+offset aoff(arg_p ap, int n)
+{
while (n>0) {
if (ap != (arg_p) 0)
ap = ap->a_next;
return(ap->a_a.a_offset);
}
-int inpseudo(n) short n; {
+int inpseudo(short n)
+{
register line_p lnp,head,tail;
short n1,n2;
proinf savearea;
return(0);
}
-tstinpro() {
-
+void tstinpro()
+{
if (prodepth==0)
error("This is not allowed outside a procedure");
}
short s_flags;
short s_frag;
offset s_value;
- char s_name[2]; /* to be extended up to IDL */
+ char s_name[2 + IDL]; /* to be extended up to IDL */
};
/* contents of .s_flags */
/*
* Main program for EM optimizer
*/
+void fileinit();
+void flags(char *s);
-main(argc,argv) int argc; char *argv[]; {
+int main(int argc, char *argv[])
+{
int somespace[STACKROOM];
progname = argv[0];
return(0);
}
-flags(s) register char *s; {
-
+void flags(char *s)
+{
for (s++;*s;s++)
switch(*s) {
case 'L': Lflag = TRUE; break;
}
}
-fileinit() {
- char *mktemp();
- short readshort();
-
+void fileinit()
+{
if (readshort() != (short) sp_magic)
error("wrong input file");
if (Lflag) {
- outfile = fopen(mktemp(template),"w");
+ mktemp(template);
+ outfile = fopen(template, "w");
if (outfile == NULL)
error("can't create %s",template);
} else {
* Author: Hans van Staveren
*/
-process() {
-
+void relabel();
+void symknown();
+void cleanlocals();
+void checklocs();
+void symvalue();
+void do_tes();
+
+void process()
+{
if (wordsize == 0 || pointersize == 0)
error("No MES EMX encountered");
backward(); /* reverse and cleanup list */
#endif
}
-relabel() {
- register num_p *npp,np,tp;
- register num_p repl,ttp;
+void relabel()
+{
+ num_p *npp,np,tp;
+ num_p repl,ttp;
/*
* For each label find its final destination after crossjumping.
}
}
-symknown() {
- register sym_p *spp,sp;
+void symknown()
+{
+ sym_p *spp,sp;
for (spp = symhash; spp < &symhash[NSYMHASH]; spp++)
for (sp = *spp; sp != (sym_p) 0; sp = sp->s_next)
sp->s_flags |= SYMKNOWN;
}
-cleanlocals() {
- register num_p *npp,np,tp;
+void cleanlocals()
+{
+ num_p *npp,np,tp;
for (npp = curpro.numhash; npp < &curpro.numhash[NNUMHASH]; npp++) {
np = *npp;
}
}
-checklocs() {
- register num_p *npp,np;
+void checklocs()
+{
+ num_p *npp,np;
for (npp=curpro.numhash; npp < & curpro.numhash[NNUMHASH]; npp++)
for (np = *npp; np != (num_p) 0; np=np->n_next)
(unsigned) np->n_number);
}
-offset align(count,alignment) offset count,alignment; {
-
+offset align(offset count, offset alignment)
+{
assert(alignment==1||alignment==2||alignment==4);
return((count+alignment-1)&~(alignment-1));
}
-symvalue() {
- register line_p lp;
- register sym_p sp;
- register arg_p ap;
- register argb_p abp;
+void symvalue()
+{
+ line_p lp;
+ sym_p sp;
+ arg_p ap;
+ argb_p abp;
short curfrag = 0;
offset count;
}
}
-do_tes()
+void do_tes()
{
- register line_p insptr = instrs, oldlin = NULL, oldlin2 = NULL;
+ line_p insptr = instrs, oldlin = NULL, oldlin2 = NULL;
init_state();
tes_pseudos();
*
* Author: Hans van Staveren
*/
+void putargs(arg_p ap);
+void putstr(argb_p abp);
+void outdef(sym_p sp);
+void outocc(sym_p sp);
+void outinst(int m);
+void outoff(offset off);
+void outint(short i);
+void outshort(short i);
+void numlab(num_p np);
+void outnum(num_p np);
+void outsym(sym_p sp);
#define outbyte(b) putc(b,outfile)
-putlines(lnp) register line_p lnp; {
- register arg_p ap;
+void putlines(line_p lnp)
+{
+ arg_p ap;
line_p temp;
- register instr;
+ int instr;
short curlin= -2;
short thislin;
}
}
-putargs(ap) register arg_p ap; {
-
+void putargs(arg_p ap)
+{
while (ap != (arg_p) 0) {
switch(ap->a_typ) {
default:
}
}
-putstr(abp) register argb_p abp; {
- register argb_p tbp;
- register length;
+void putstr(argb_p abp)
+{
+ argb_p tbp;
+ int length;
length = 0;
tbp = abp;
}
}
-outdef(sp) register sym_p sp; {
-
+void outdef(sym_p sp)
+{
/*
* The surrounding If statement is removed to be friendly
* to Backend writers having to deal with assemblers
*/
}
-outocc(sp) register sym_p sp; {
-
+void outocc(sym_p sp)
+{
if ((sp->s_flags&SYMOUT)==0) {
sp->s_flags |= SYMOUT;
if ((sp->s_flags&SYMGLOBAL)==0) {
}
}
-outpro() {
+void outpro()
+{
outdef(curpro.symbol);
outinst(ps_pro);
outoff(curpro.localbytes);
}
-outend() {
-
+void outend()
+{
outinst(ps_end);
outoff(curpro.localbytes);
}
-outinst(m) {
-
+void outinst(int m)
+{
outbyte( (byte) m );
}
-outoff(off) offset off; {
+void outoff(offset off)
+{
#ifdef LONGOFF
if ((short) off == off)
#endif
}
-outint(i) short i; {
-
+void outint(short i)
+{
if (i>= -sp_zcst0 && i< sp_ncst0-sp_zcst0)
outbyte( (byte) (i+sp_zcst0+sp_fcst0) );
else {
}
}
-outshort(i) short i; {
-
+void outshort(short i)
+{
outbyte( (byte) (i&BMASK) );
outbyte( (byte) (i>>8) );
}
-numlab(np) register num_p np; {
-
+void numlab(num_p np)
+{
if (np->n_number < sp_nilb0)
outbyte( (byte) (np->n_number + sp_filb0) );
else
outnum(np);
}
-outnum(np) register num_p np; {
-
+void outnum(num_p np)
+{
if(np->n_number<256) {
outbyte( (byte) sp_ilb1) ;
outbyte( (byte) (np->n_number) );
}
}
-outsym(sp) register sym_p sp; {
- register byte *p;
- register unsigned num;
-
+void outsym(sym_p sp)
+{
+ byte *p;
+ unsigned int num;
+ warning("May do something nasty... (%s)", __func__);
if (sp->s_name[0] == '.') {
num = atoi(&sp->s_name[1]);
if (num < 256) {
}
} else {
p= sp->s_name;
- while (*p && p < &sp->s_name[IDL])
+ while ( (*p) && p < &sp->s_name[IDL] )
p++;
num = p - sp->s_name;
outbyte( (byte) (sp->s_flags&SYMPRO ? sp_pnam : sp_dnam) );
/* VARARGS1 */
-error(s,a) char *s,*a; {
-
+void error(char *s, char *a)
+{
fprintf(stderr,"%s: error on line %u",progname,linecount);
if (prodepth != 0)
fprintf(stderr,"(%.*s)",IDL,curpro.symbol->s_name);
}
#ifndef NDEBUG
-badassertion(file,line) char *file; unsigned line; {
-
+void badassertion(char *file, unsigned int line)
+{
fprintf(stderr,"assertion failed file %s, line %u\n",file,line);
- error("assertion");
+ error("assertion", NULL);
}
#endif
#ifdef DIAGOPT
-optim(n) {
-
+void optim(int n)
+{
fprintf(stderr,"Made optimization %d",n);
if (prodepth)
fprintf(stderr," (%.*s)",IDL,curpro.symbol->s_name);
public / ack.git / commitdiff