1berry/pawn-compiler
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Redo constvalue list optimisation

Browse Source
This commit is contained in:
Daniel_Cortez 2018-02-22 03:22:21 +07:00
parent 30e1ef9389
commit 9ca1b4a61e
8 changed files with 126 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
source/compiler/sc.h
View File

@ -114,7 +114,7 @@ typedef struct s_constvalue {
} constvalue; } constvalue;
typedef struct s_constvalue_root { typedef struct s_constvalue_root {
constvalue *next,*last; constvalue *first,*last;
} constvalue_root; } constvalue_root;
/* Symbol table format /* Symbol table format
@ -152,13 +152,13 @@ typedef struct s_symbol {
} x; /* 'x' for 'extra' */ } x; /* 'x' for 'extra' */
union { union {
arginfo *arglist; /* types of all parameters for functions */ arginfo *arglist; /* types of all parameters for functions */
constvalue *enumlist;/* list of names for the "root" of an enumeration */ constvalue_root *enumlist;/* list of names for the "root" of an enumeration */
struct { struct {
cell length; /* arrays: length (size) */ cell length; /* arrays: length (size) */
short level; /* number of dimensions below this level */ short level; /* number of dimensions below this level */
} array; } array;
} dim; /* for 'dimension', both functions and arrays */ } dim; /* for 'dimension', both functions and arrays */
constvalue *states; /* list of state function/state variable ids + addresses */ constvalue_root *states;/* list of state function/state variable ids + addresses */
int fnumber; /* static global variables: file number in which the declaration is visible */ int fnumber; /* static global variables: file number in which the declaration is visible */
int lnumber; /* line number (in the current source file) for the declaration */ int lnumber; /* line number (in the current source file) for the declaration */
struct s_symbol **refer; /* referrer list, functions that "use" this symbol */ struct s_symbol **refer; /* referrer list, functions that "use" this symbol */
@ -555,9 +555,9 @@ SC_FUNC symbol *fetchfunc(char *name,int tag);
SC_FUNC char *operator_symname(char *symname,char *opername,int tag1,int tag2,int numtags,int resulttag); SC_FUNC char *operator_symname(char *symname,char *opername,int tag1,int tag2,int numtags,int resulttag);
SC_FUNC char *funcdisplayname(char *dest,char *funcname); SC_FUNC char *funcdisplayname(char *dest,char *funcname);
SC_FUNC int constexpr(cell *val,int *tag,symbol **symptr); SC_FUNC int constexpr(cell *val,int *tag,symbol **symptr);
SC_FUNC constvalue *append_constval(constvalue *table,const char *name,cell val,int index); SC_FUNC constvalue *append_constval(constvalue_root *table,const char *name,cell val,int index);
SC_FUNC constvalue *find_constval(constvalue *table,char *name,int index); SC_FUNC constvalue *find_constval(constvalue_root *table,char *name,int index);
SC_FUNC void delete_consttable(constvalue *table); SC_FUNC void delete_consttable(constvalue_root *table);
SC_FUNC symbol *add_constant(char *name,cell val,int vclass,int tag); SC_FUNC symbol *add_constant(char *name,cell val,int vclass,int tag);
SC_FUNC symbol *add_builtin_constant(char *name,cell val,int vclass,int tag); SC_FUNC symbol *add_builtin_constant(char *name,cell val,int vclass,int tag);
SC_FUNC symbol *add_builtin_string_constant(char *name,const char *val,int vclass); SC_FUNC symbol *add_builtin_string_constant(char *name,const char *val,int vclass);
@ -802,8 +802,8 @@ SC_VDECL symbol *line_sym;
SC_VDECL cell *litq; /* the literal queue */ SC_VDECL cell *litq; /* the literal queue */
SC_VDECL unsigned char pline[]; /* the line read from the input file */ SC_VDECL unsigned char pline[]; /* the line read from the input file */
SC_VDECL const unsigned char *lptr;/* points to the current position in "pline" */ SC_VDECL const unsigned char *lptr;/* points to the current position in "pline" */
SC_VDECL constvalue tagname_tab;/* tagname table */ SC_VDECL constvalue_root tagname_tab;/* tagname table */
SC_VDECL constvalue libname_tab;/* library table (#pragma library "..." syntax) */ SC_VDECL constvalue_root libname_tab;/* library table (#pragma library "..." syntax) */
SC_VDECL constvalue *curlibrary;/* current library */ SC_VDECL constvalue *curlibrary;/* current library */
SC_VDECL int pc_addlibtable; /* is the library table added to the AMX file? */ SC_VDECL int pc_addlibtable; /* is the library table added to the AMX file? */
SC_VDECL symbol *curfunc; /* pointer to current function */ SC_VDECL symbol *curfunc; /* pointer to current function */
@ -860,8 +860,8 @@ SC_VDECL int pc_naked; /* if true mark following function as naked */
SC_VDECL int pc_compat; /* running in compatibility mode? */ SC_VDECL int pc_compat; /* running in compatibility mode? */
SC_VDECL int pc_recursion; /* enable detailed recursion report? */ SC_VDECL int pc_recursion; /* enable detailed recursion report? */
SC_VDECL constvalue sc_automaton_tab; /* automaton table */ SC_VDECL constvalue_root sc_automaton_tab; /* automaton table */
SC_VDECL constvalue sc_state_tab; /* state table */ SC_VDECL constvalue_root sc_state_tab; /* state table */
SC_VDECL FILE *inpf; /* file read from (source or include) */ SC_VDECL FILE *inpf; /* file read from (source or include) */
SC_VDECL FILE *inpf_org; /* main source file */ SC_VDECL FILE *inpf_org; /* main source file */

160
source/compiler/sc1.c
View File

@ -92,14 +92,14 @@ static void declglb(char *firstname,int firsttag,int fpublic,int fstatic,
static int declloc(int fstatic); static int declloc(int fstatic);
static void decl_const(int table); static void decl_const(int table);
static void decl_enum(int table,int fstatic); static void decl_enum(int table,int fstatic);
static cell needsub(int *tag,constvalue **enumroot); static cell needsub(int *tag,constvalue_root **enumroot);
static void initials(int ident,int tag,cell *size,int dim[],int numdim, static void initials(int ident,int tag,cell *size,int dim[],int numdim,
constvalue *enumroot); constvalue_root *enumroot);
static cell initarray(int ident,int tag,int dim[],int numdim,int cur, static cell initarray(int ident,int tag,int dim[],int numdim,int cur,
int startlit,int counteddim[],constvalue *lastdim, int startlit,int counteddim[],constvalue_root *lastdim,
constvalue *enumroot,int *errorfound); constvalue_root *enumroot,int *errorfound);
static cell initvector(int ident,int tag,cell size,int startlit,int fillzero, static cell initvector(int ident,int tag,cell size,int startlit,int fillzero,
constvalue *enumroot,int *errorfound); constvalue_root *enumroot,int *errorfound);
static cell init(int ident,int *tag,int *errorfound); static cell init(int ident,int *tag,int *errorfound);
static int getstates(const char *funcname); static int getstates(const char *funcname);
static void attachstatelist(symbol *sym, int state_id); static void attachstatelist(symbol *sym, int state_id);
@ -113,7 +113,7 @@ static void reduce_referrers(symbol *root);
static long max_stacksize(symbol *root,int *recursion); static long max_stacksize(symbol *root,int *recursion);
static int testsymbols(symbol *root,int level,int testlabs,int testconst); static int testsymbols(symbol *root,int level,int testlabs,int testconst);
static void destructsymbols(symbol *root,int level); static void destructsymbols(symbol *root,int level);
static constvalue *find_constval_byval(constvalue *table,cell val); static constvalue *find_constval_byval(constvalue_root *table,cell val);
static symbol *fetchlab(char *name); static symbol *fetchlab(char *name);
static void statement(int *lastindent,int allow_decl); static void statement(int *lastindent,int allow_decl);
static void compound(int stmt_sameline,int starttok); static void compound(int stmt_sameline,int starttok);
@ -842,7 +842,7 @@ int pc_addtag(char *name)
assert(strchr(name,':')==NULL); /* colon should already have been stripped */ assert(strchr(name,':')==NULL); /* colon should already have been stripped */
last=0; last=0;
ptr=tagname_tab.next; ptr=tagname_tab.first;
while (ptr!=NULL) { while (ptr!=NULL) {
tag=(int)(ptr->value & TAGMASK); tag=(int)(ptr->value & TAGMASK);
if (strcmp(name,ptr->name)==0) if (strcmp(name,ptr->name)==0)
@ -938,8 +938,8 @@ static void initglobals(void)
glbtab.next=NULL; /* clear global variables/constants table */ glbtab.next=NULL; /* clear global variables/constants table */
loctab.next=NULL; /* " local " / " " */ loctab.next=NULL; /* " local " / " " */
hashtable_init(&symbol_cache_ht, sizeof(symbol *),(16384/3*2),NULL); /* 16384 slots */ hashtable_init(&symbol_cache_ht, sizeof(symbol *),(16384/3*2),NULL); /* 16384 slots */
tagname_tab.next=NULL; /* tagname table */ tagname_tab.first=tagname_tab.last=NULL; /* tagname table */
libname_tab.next=NULL; /* library table (#pragma library "..." syntax) */ libname_tab.first=libname_tab.last=NULL; /* library table (#pragma library "..." syntax) */
pline[0]='\0'; /* the line read from the input file */ pline[0]='\0'; /* the line read from the input file */
lptr=NULL; /* points to the current position in "pline" */ lptr=NULL; /* points to the current position in "pline" */
@ -1983,7 +1983,7 @@ static void declglb(char *firstname,int firsttag,int fpublic,int fstatic,int fst
int numdim; int numdim;
short filenum; short filenum;
symbol *sym; symbol *sym;
constvalue *enumroot; constvalue_root *enumroot;
#if !defined NDEBUG #if !defined NDEBUG
cell glbdecl=0; cell glbdecl=0;
#endif #endif
@ -2054,11 +2054,11 @@ static void declglb(char *firstname,int firsttag,int fpublic,int fstatic,int fst
*/ */
assert(sym==NULL assert(sym==NULL
|| sym->states==NULL && sc_curstates==0 || sym->states==NULL && sc_curstates==0
|| sym->states!=NULL && sym->next!=NULL && sym->states->next->index==sc_curstates); || sym->states!=NULL && sym->next!=NULL && sym->states->first->index==sc_curstates);
/* a state variable may only have a single id in its list (so either this /* a state variable may only have a single id in its list (so either this
* variable has no states, or it has a single list) * variable has no states, or it has a single list)
*/ */
assert(sym==NULL || sym->states==NULL || sym->states->next->next==NULL); assert(sym==NULL || sym->states==NULL || sym->states->first->next==NULL);
/* it is okay for the (global) variable to exist, as long as it belongs to /* it is okay for the (global) variable to exist, as long as it belongs to
* a different automaton * a different automaton
*/ */
@ -2116,7 +2116,7 @@ static void declglb(char *firstname,int firsttag,int fpublic,int fstatic,int fst
continue; /* a function or a constant */ continue; /* a function or a constant */
if ((sweep->usage & uDEFINE)==0) if ((sweep->usage & uDEFINE)==0)
continue; /* undefined variable, ignore */ continue; /* undefined variable, ignore */
if (fsa!=state_getfsa(sweep->states->next->index)) if (fsa!=state_getfsa(sweep->states->first->index))
continue; /* wrong automaton */ continue; /* wrong automaton */
/* when arrived here, this is a global variable, with states and /* when arrived here, this is a global variable, with states and
* belonging to the same automaton as the variable we are declaring * belonging to the same automaton as the variable we are declaring
@ -2138,7 +2138,7 @@ static void declglb(char *firstname,int firsttag,int fpublic,int fstatic,int fst
continue; /* a function or a constant */ continue; /* a function or a constant */
if ((sweep->usage & uDEFINE)==0) if ((sweep->usage & uDEFINE)==0)
continue; /* undefined variable, ignore */ continue; /* undefined variable, ignore */
if (fsa!=state_getfsa(sweep->states->next->index)) if (fsa!=state_getfsa(sweep->states->first->index))
continue; /* wrong automaton */ continue; /* wrong automaton */
/* when arrived here, this is a global variable, with states and /* when arrived here, this is a global variable, with states and
* belonging to the same automaton as the variable we are declaring * belonging to the same automaton as the variable we are declaring
@ -2147,7 +2147,7 @@ static void declglb(char *firstname,int firsttag,int fpublic,int fstatic,int fst
* variable have a non-empty intersection, this is not a suitable * variable have a non-empty intersection, this is not a suitable
* overlap point -> wipe the address range * overlap point -> wipe the address range
*/ */
if (state_conflict_id(sc_curstates,sweep->states->next->index)) { if (state_conflict_id(sc_curstates,sweep->states->first->index)) {
sweepsize=(sweep->ident==iVARIABLE) ? 1 : array_totalsize(sweep); sweepsize=(sweep->ident==iVARIABLE) ? 1 : array_totalsize(sweep);
assert(sweep->addr % sizeof(cell) == 0); assert(sweep->addr % sizeof(cell) == 0);
addr=sweep->addr/sizeof(cell); addr=sweep->addr/sizeof(cell);
@ -2194,7 +2194,7 @@ static void declglb(char *firstname,int firsttag,int fpublic,int fstatic,int fst
attachstatelist(sym,sc_curstates); attachstatelist(sym,sc_curstates);
} else { /* if declared but not yet defined, adjust the variable's address */ } else { /* if declared but not yet defined, adjust the variable's address */
assert(sym->states==NULL && sc_curstates==0 assert(sym->states==NULL && sc_curstates==0
|| sym->states->next!=NULL && sym->states->next->index==sc_curstates && sym->states->next->next==NULL); || sym->states->first!=NULL && sym->states->first->index==sc_curstates && sym->states->first->next==NULL);
sym->addr=address; sym->addr=address;
sym->codeaddr=code_idx; sym->codeaddr=code_idx;
sym->usage|=uDEFINE; sym->usage|=uDEFINE;
@ -2236,7 +2236,7 @@ static int declloc(int fstatic)
int idxtag[sDIMEN_MAX]; int idxtag[sDIMEN_MAX];
char name[sNAMEMAX+1]; char name[sNAMEMAX+1];
symbol *sym; symbol *sym;
constvalue *enumroot; constvalue_root *enumroot;
cell val,size; cell val,size;
char *str; char *str;
value lval = {0}; value lval = {0};
@ -2419,7 +2419,7 @@ static cell calc_arraysize(int dim[],int numdim,int cur)
} }
static void adjust_indirectiontables(int dim[],int numdim,int startlit, static void adjust_indirectiontables(int dim[],int numdim,int startlit,
constvalue *lastdim,int *skipdim) constvalue_root *lastdim,int *skipdim)
{ {
static int base; static int base;
int cur; int cur;
@ -2445,7 +2445,7 @@ static int base;
accum=0; accum=0;
for (i=0; i<size; i++) { for (i=0; i<size; i++) {
/* skip the final dimension sizes for all earlier major dimensions */ /* skip the final dimension sizes for all earlier major dimensions */
for (d=0,ld=lastdim->next; d<*skipdim; d++,ld=ld->next) { for (d=0,ld=lastdim->first; d<*skipdim; d++,ld=ld->next) {
assert(ld!=NULL); assert(ld!=NULL);
} /* for */ } /* for */
for (d=0; d<dim[cur]; d++) { for (d=0; d<dim[cur]; d++) {
@ -2471,7 +2471,7 @@ static int base;
* Global references: litidx (altered) * Global references: litidx (altered)
*/ */
static void initials(int ident,int tag,cell *size,int dim[],int numdim, static void initials(int ident,int tag,cell *size,int dim[],int numdim,
constvalue *enumroot) constvalue_root *enumroot)
{ {
int ctag; int ctag;
cell tablesize; cell tablesize;
@ -2518,7 +2518,7 @@ static void initials(int ident,int tag,cell *size,int dim[],int numdim,
int errorfound=FALSE; int errorfound=FALSE;
int counteddim[sDIMEN_MAX]; int counteddim[sDIMEN_MAX];
int idx; int idx;
constvalue lastdim={NULL,"",0,0}; /* sizes of the final dimension */ constvalue_root lastdim = { NULL, NULL}; /* sizes of the final dimension */
int skipdim=0; int skipdim=0;
/* check if size specified for all dimensions */ /* check if size specified for all dimensions */
@ -2554,7 +2554,7 @@ static void initials(int ident,int tag,cell *size,int dim[],int numdim,
/* also look whether, by any chance, all "counted" final dimensions are /* also look whether, by any chance, all "counted" final dimensions are
* the same value; if so, we can store this * the same value; if so, we can store this
*/ */
constvalue *ld=lastdim.next; constvalue *ld=lastdim.first;
int d,match; int d,match;
for (d=0; d<dim[numdim-2]; d++) { for (d=0; d<dim[numdim-2]; d++) {
assert(ld!=NULL); assert(ld!=NULL);
@ -2582,8 +2582,8 @@ static void initials(int ident,int tag,cell *size,int dim[],int numdim,
} }
static cell initarray(int ident,int tag,int dim[],int numdim,int cur, static cell initarray(int ident,int tag,int dim[],int numdim,int cur,
int startlit,int counteddim[],constvalue *lastdim, int startlit,int counteddim[],constvalue_root *lastdim,
constvalue *enumroot,int *errorfound) constvalue_root *enumroot,int *errorfound)
{ {
cell dsize,totalsize; cell dsize,totalsize;
int idx,idx_ellips,vidx,do_insert; int idx,idx_ellips,vidx,do_insert;
@ -2672,7 +2672,7 @@ static cell initarray(int ident,int tag,int dim[],int numdim,int cur,
* Initialize a single dimensional array * Initialize a single dimensional array
*/ */
static cell initvector(int ident,int tag,cell size,int startlit,int fillzero, static cell initvector(int ident,int tag,cell size,int startlit,int fillzero,
constvalue *enumroot,int *errorfound) constvalue_root *enumroot,int *errorfound)
{ {
cell prev1=0,prev2=0; cell prev1=0,prev2=0;
int ellips=FALSE; int ellips=FALSE;
@ -2680,7 +2680,7 @@ static cell initvector(int ident,int tag,cell size,int startlit,int fillzero,
assert(ident==iARRAY || ident==iREFARRAY); assert(ident==iARRAY || ident==iREFARRAY);
if (matchtoken('{')) { if (matchtoken('{')) {
constvalue *enumfield=(enumroot!=NULL) ? enumroot->next : NULL; constvalue *enumfield=(enumroot!=NULL) ? enumroot->first : NULL;
do { do {
int fieldlit=litidx; int fieldlit=litidx;
int matchbrace,i; int matchbrace,i;
@ -2800,7 +2800,7 @@ static cell init(int ident,int *tag,int *errorfound)
* *
* Get required array size * Get required array size
*/ */
static cell needsub(int *tag,constvalue **enumroot) static cell needsub(int *tag,constvalue_root **enumroot)
{ {
cell val; cell val;
symbol *sym; symbol *sym;
@ -2877,7 +2877,7 @@ static void decl_enum(int vclass,int fstatic)
char *str; char *str;
int tag,explicittag; int tag,explicittag;
cell increment,multiplier; cell increment,multiplier;
constvalue *enumroot; constvalue_root *enumroot;
symbol *enumsym; symbol *enumsym;
short filenum; short filenum;
@ -2931,9 +2931,9 @@ static void decl_enum(int vclass,int fstatic)
enumsym->fnumber=filenum; enumsym->fnumber=filenum;
} }
/* start a new list for the element names */ /* start a new list for the element names */
if ((enumroot=(constvalue*)malloc(sizeof(constvalue)))==NULL) if ((enumroot=(constvalue_root*)malloc(sizeof(constvalue_root)))==NULL)
error(103); /* insufficient memory (fatal error) */ error(103); /* insufficient memory (fatal error) */
memset(enumroot,0,sizeof(constvalue)); memset(enumroot,0,sizeof(constvalue_root));
} else { } else {
enumsym=NULL; enumsym=NULL;
enumroot=NULL; enumroot=NULL;
@ -3085,15 +3085,15 @@ static void attachstatelist(symbol *sym, int state_id)
/* add the state list id */ /* add the state list id */
constvalue *stateptr; constvalue *stateptr;
if (sym->states==NULL) { if (sym->states==NULL) {
if ((sym->states=(constvalue*)malloc(sizeof(constvalue)))==NULL) if ((sym->states=(constvalue_root*)malloc(sizeof(constvalue_root)))==NULL)
error(103); /* insufficient memory (fatal error) */ error(103); /* insufficient memory (fatal error) */
memset(sym->states,0,sizeof(constvalue)); memset(sym->states,0,sizeof(constvalue_root));
} /* if */ } /* if */
/* see whether the id already exists (add new state only if it does not /* see whether the id already exists (add new state only if it does not
* yet exist * yet exist
*/ */
assert(sym->states!=NULL); assert(sym->states!=NULL);
for (stateptr=sym->states->next; stateptr!=NULL && stateptr->index!=state_id; stateptr=stateptr->next) for (stateptr=sym->states->first; stateptr!=NULL && stateptr->index!=state_id; stateptr=stateptr->next)
/* nothing */; /* nothing */;
assert(state_id<=SHRT_MAX); assert(state_id<=SHRT_MAX);
if (stateptr==NULL) if (stateptr==NULL)
@ -3108,7 +3108,7 @@ static void attachstatelist(symbol *sym, int state_id)
if (state_id==-1 && sc_status!=statFIRST) { if (state_id==-1 && sc_status!=statFIRST) {
/* in the second round, all states should have been accumulated */ /* in the second round, all states should have been accumulated */
assert(sym->states!=NULL); assert(sym->states!=NULL);
for (stateptr=sym->states->next; stateptr!=NULL && stateptr->index==-1; stateptr=stateptr->next) for (stateptr=sym->states->first; stateptr!=NULL && stateptr->index==-1; stateptr=stateptr->next)
/* nothing */; /* nothing */;
if (stateptr==NULL) if (stateptr==NULL)
error(85,sym->name); /* no states are defined for this function */ error(85,sym->name); /* no states are defined for this function */
@ -3703,7 +3703,7 @@ static int newfunc(char *firstname,int firsttag,int fpublic,int fstatic,int stoc
sym->usage &= ~uDEFINE; sym->usage &= ~uDEFINE;
/* if the function has states, dump the label to the start of the function */ /* if the function has states, dump the label to the start of the function */
if (state_id!=0) { if (state_id!=0) {
constvalue *ptr=sym->states->next; constvalue *ptr=sym->states->first;
while (ptr!=NULL) { while (ptr!=NULL) {
assert(sc_status!=statWRITE || strlen(ptr->name)>0); assert(sc_status!=statWRITE || strlen(ptr->name)>0);
if (ptr->index==state_id) { if (ptr->index==state_id) {
@ -4027,7 +4027,7 @@ static void doarg(char *name,int ident,int offset,int tags[],int numtags,
int fpublic,int fconst,int chkshadow,arginfo *arg) int fpublic,int fconst,int chkshadow,arginfo *arg)
{ {
symbol *argsym; symbol *argsym;
constvalue *enumroot; constvalue_root *enumroot;
cell size; cell size;
strcpy(arg->name,name); strcpy(arg->name,name);
@ -4291,7 +4291,7 @@ static void make_report(symbol *root,FILE *log,char *sourcefile)
int i,arg; int i,arg;
symbol *sym,*ref; symbol *sym,*ref;
constvalue *tagsym; constvalue *tagsym;
constvalue *enumroot; constvalue_root *enumroot;
char *ptr; char *ptr;
/* adapt the installation directory */ /* adapt the installation directory */
@ -4345,11 +4345,11 @@ static void make_report(symbol *root,FILE *log,char *sourcefile)
} /* if */ } /* if */
/* browse through all fields */ /* browse through all fields */
if ((enumroot=sym->dim.enumlist)!=NULL) { if ((enumroot=sym->dim.enumlist)!=NULL) {
enumroot=enumroot->next; /* skip root */ constvalue *cur=enumroot->first; /* skip root */
while (enumroot!=NULL) { while (cur!=NULL) {
fprintf(log,"\t\t\t<member name=\"C:%s\" value=\"%"PRIdC"\">\n",funcdisplayname(symname,enumroot->name),enumroot->value); fprintf(log,"\t\t\t<member name=\"C:%s\" value=\"%"PRIdC"\">\n",funcdisplayname(symname,cur->name),cur->value);
/* find the constant with this name and get the tag */ /* find the constant with this name and get the tag */
ref=findglb(enumroot->name,sGLOBAL); ref=findglb(cur->name,sGLOBAL);
if (ref!=NULL) { if (ref!=NULL) {
if (ref->x.tags.index!=0) { if (ref->x.tags.index!=0) {
tagsym=find_tag_byval(ref->x.tags.index); tagsym=find_tag_byval(ref->x.tags.index);
@ -4360,7 +4360,7 @@ static void make_report(symbol *root,FILE *log,char *sourcefile)
fprintf(log,"\t\t\t\t<size value=\"%ld\"/>\n",(long)ref->dim.array.length); fprintf(log,"\t\t\t\t<size value=\"%ld\"/>\n",(long)ref->dim.array.length);
} /* if */ } /* if */
fprintf(log,"\t\t\t</member>\n"); fprintf(log,"\t\t\t</member>\n");
enumroot=enumroot->next; cur=cur->next;
} /* while */ } /* while */
} /* if */ } /* if */
assert(sym->refer!=NULL); assert(sym->refer!=NULL);
@ -4474,7 +4474,7 @@ static void make_report(symbol *root,FILE *log,char *sourcefile)
if ((sym->usage & uNATIVE)==0) if ((sym->usage & uNATIVE)==0)
fprintf(log,"\t\t\t<stacksize value=\"%ld\"/>\n",(long)sym->x.stacksize); fprintf(log,"\t\t\t<stacksize value=\"%ld\"/>\n",(long)sym->x.stacksize);
if (sym->states!=NULL) { if (sym->states!=NULL) {
constvalue *stlist=sym->states->next; constvalue *stlist=sym->states->first;
assert(stlist!=NULL); /* there should be at least one state item */ assert(stlist!=NULL); /* there should be at least one state item */
while (stlist!=NULL && stlist->index==-1) while (stlist!=NULL && stlist->index==-1)
stlist=stlist->next; stlist=stlist->next;
@ -4921,23 +4921,29 @@ static constvalue *insert_constval(constvalue *prev,constvalue *next,
cur->value=val; cur->value=val;
cur->index=index; cur->index=index;
cur->next=next; cur->next=next;
prev->next=cur; if (prev!=NULL)
prev->next=cur;
return cur; return cur;
} }
SC_FUNC constvalue *append_constval(constvalue *table,const char *name,cell val,int index) SC_FUNC constvalue *append_constval(constvalue_root *table,const char *name,
cell val,int index)
{ {
constvalue_root *root=(constvalue_root *)table;
constvalue *newvalue; constvalue *newvalue;
newvalue=insert_constval(((root->last!=NULL) ? root->last : table),NULL,name,val,index); if (table->last!=NULL) {
root->last=newvalue; newvalue=insert_constval(table->last,NULL,name,val,index);
} else {
newvalue=insert_constval(NULL,NULL,name,val,index);
table->first=newvalue;
} /* if */
table->last=newvalue;
return newvalue; return newvalue;
} }
SC_FUNC constvalue *find_constval(constvalue *table,char *name,int index) SC_FUNC constvalue *find_constval(constvalue_root *table,char *name,int index)
{ {
constvalue *ptr = table->next; constvalue *ptr = table->first;
while (ptr!=NULL) { while (ptr!=NULL) {
if (strcmp(name,ptr->name)==0 && ptr->index==index) if (strcmp(name,ptr->name)==0 && ptr->index==index)
@ -4947,9 +4953,9 @@ SC_FUNC constvalue *find_constval(constvalue *table,char *name,int index)
return NULL; return NULL;
} }
static constvalue *find_constval_byval(constvalue *table,cell val) static constvalue *find_constval_byval(constvalue_root *table,cell val)
{ {
constvalue *ptr = table->next; constvalue *ptr = table->first;
while (ptr!=NULL) { while (ptr!=NULL) {
if (ptr->value==val) if (ptr->value==val)
@ -4960,17 +4966,19 @@ static constvalue *find_constval_byval(constvalue *table,cell val)
} }
#if 0 /* never used */ #if 0 /* never used */
static int delete_constval(constvalue *table,char *name) static int delete_constval(constvalue_root *table,char *name)
{ {
constvalue *prev=table; constvalue *prev=NULL;
constvalue *cur=prev->next; constvalue *cur=table->first;
constvalue_root *root=(constvalue_root *)table;
while (cur!=NULL) { while (cur!=NULL) {
if (strcmp(name,cur->name)==0) { if (strcmp(name,cur->name)==0) {
prev->next=cur->next; if (prev!=NULL)
if (root->last==cur) prev->next=cur->next;
root->last=prev; else
table->first=cur->next;
if (table->last==cur)
table->last=prev;
free(cur); free(cur);
return TRUE; return TRUE;
} /* if */ } /* if */
@ -4981,16 +4989,16 @@ static int delete_constval(constvalue *table,char *name)
} }
#endif #endif
SC_FUNC void delete_consttable(constvalue *table) SC_FUNC void delete_consttable(constvalue_root *table)
{ {
constvalue *cur=table->next, *next; constvalue *cur=table->first, *next;
while (cur!=NULL) { while (cur!=NULL) {
next=cur->next; next=cur->next;
free(cur); free(cur);
cur=next; cur=next;
} /* while */ } /* while */
memset(table,0,sizeof(constvalue)); memset(table,0,sizeof(constvalue_root));
} }
/* add_constant /* add_constant
@ -5665,8 +5673,8 @@ static void doswitch(void)
int tok,endtok; int tok,endtok;
cell val; cell val;
char *str; char *str;
constvalue caselist = { NULL, "", 0, 0}; /* case list starts empty */ constvalue_root caselist = { NULL, NULL}; /* case list starts empty */
constvalue *cse,*csp; constvalue *cse,*csp,*newval;
char labelname[sNAMEMAX+1]; char labelname[sNAMEMAX+1];
endtok= matchtoken('(') ? ')' : tDO; endtok= matchtoken('(') ? ')' : tDO;
@ -5714,7 +5722,7 @@ static void doswitch(void)
* that advanced abstract machines can sift the case table with a * that advanced abstract machines can sift the case table with a
* binary search). Check for duplicate case values at the same time. * binary search). Check for duplicate case values at the same time.
*/ */
for (csp=&caselist, cse=caselist.next; for (csp=NULL, cse=caselist.first;
cse!=NULL && cse->value<val; cse!=NULL && cse->value<val;
csp=cse, cse=cse->next) csp=cse, cse=cse->next)
/* nothing */; /* nothing */;
@ -5727,9 +5735,10 @@ static void doswitch(void)
#if sNAMEMAX < 8 #if sNAMEMAX < 8
#error Length of identifier (sNAMEMAX) too small. #error Length of identifier (sNAMEMAX) too small.
#endif #endif
assert(csp!=NULL); assert(csp==NULL || csp->next==cse);
assert(csp->next==cse); newval=insert_constval(csp,cse,itoh(lbl_case),val,0);
insert_constval(csp,cse,itoh(lbl_case),val,0); if (csp==NULL)
caselist.first=newval;
if (matchtoken(tDBLDOT)) { if (matchtoken(tDBLDOT)) {
cell end; cell end;
constexpr(&end,NULL,NULL); constexpr(&end,NULL,NULL);
@ -5738,14 +5747,13 @@ static void doswitch(void)
while (++val<=end) { while (++val<=end) {
casecount++; casecount++;
/* find the new insertion point */ /* find the new insertion point */
for (csp=&caselist, cse=caselist.next; for (csp=NULL, cse=caselist.first;
cse!=NULL && cse->value<val; cse!=NULL && cse->value<val;
csp=cse, cse=cse->next) csp=cse, cse=cse->next)
/* nothing */; /* nothing */;
if (cse!=NULL && cse->value==val) if (cse!=NULL && cse->value==val)
error(40,val); /* duplicate "case" label */ error(40,val); /* duplicate "case" label */
assert(csp!=NULL); assert(csp==NULL || csp->next==cse);
assert(csp->next==cse);
insert_constval(csp,cse,itoh(lbl_case),val,0); insert_constval(csp,cse,itoh(lbl_case),val,0);
} /* if */ } /* if */
} /* if */ } /* if */
@ -5783,7 +5791,7 @@ static void doswitch(void)
/* verify that the case table is sorted (unfortunatly, duplicates can /* verify that the case table is sorted (unfortunatly, duplicates can
* occur; there really shouldn't be duplicate cases, but the compiler * occur; there really shouldn't be duplicate cases, but the compiler
* may not crash or drop into an assertion for a user error). */ * may not crash or drop into an assertion for a user error). */
for (cse=caselist.next; cse!=NULL && cse->next!=NULL; cse=cse->next) for (cse=caselist.first; cse!=NULL && cse->next!=NULL; cse=cse->next)
assert(cse->value <= cse->next->value); assert(cse->value <= cse->next->value);
#endif #endif
/* generate the table here, before lbl_exit (general jump target) */ /* generate the table here, before lbl_exit (general jump target) */
@ -5798,7 +5806,7 @@ static void doswitch(void)
} /* if */ } /* if */
ffcase(casecount,labelname,TRUE); ffcase(casecount,labelname,TRUE);
/* generate the rest of the table */ /* generate the rest of the table */
for (cse=caselist.next; cse!=NULL; cse=cse->next) for (cse=caselist.first; cse!=NULL; cse=cse->next)
ffcase(cse->value,cse->name,FALSE); ffcase(cse->value,cse->name,FALSE);
setlabel(lbl_exit); setlabel(lbl_exit);
@ -6922,7 +6930,7 @@ SC_FUNC void exporttag(int tag)
*/ */
if (tag!=0 && (tag & PUBLICTAG)==0) { if (tag!=0 && (tag & PUBLICTAG)==0) {
constvalue *ptr; constvalue *ptr;
for (ptr=tagname_tab.next; ptr!=NULL && tag!=(int)(ptr->value & TAGMASK); ptr=ptr->next) for (ptr=tagname_tab.first; ptr!=NULL && tag!=(int)(ptr->value & TAGMASK); ptr=ptr->next)
/* nothing */; /* nothing */;
if (ptr!=NULL) if (ptr!=NULL)
ptr->value |= PUBLICTAG; ptr->value |= PUBLICTAG;
@ -7002,7 +7010,7 @@ static void dostate(void)
/* find the optional entry() function for the state */ /* find the optional entry() function for the state */
sym=findglb(uENTRYFUNC,sGLOBAL); sym=findglb(uENTRYFUNC,sGLOBAL);
if (sc_status==statWRITE && sym!=NULL && sym->ident==iFUNCTN && sym->states!=NULL) { if (sc_status==statWRITE && sym!=NULL && sym->ident==iFUNCTN && sym->states!=NULL) {
for (stlist=sym->states->next; stlist!=NULL; stlist=stlist->next) { for (stlist=sym->states->first; stlist!=NULL; stlist=stlist->next) {
assert(strlen(stlist->name)!=0); assert(strlen(stlist->name)!=0);
if (state_getfsa(stlist->index)==automaton->index && state_inlist(stlist->index,(int)state->value)) if (state_getfsa(stlist->index)==automaton->index && state_inlist(stlist->index,(int)state->value))
break; /* found! */ break; /* found! */
@ -7024,7 +7032,7 @@ static void dostate(void)
/* get the last list id attached to the function, this contains the source states */ /* get the last list id attached to the function, this contains the source states */
assert(curfunc!=NULL); assert(curfunc!=NULL);
if (curfunc->states!=NULL) { if (curfunc->states!=NULL) {
stlist=curfunc->states->next; stlist=curfunc->states->first;
assert(stlist!=NULL); assert(stlist!=NULL);
while (stlist->next!=NULL) while (stlist->next!=NULL)
stlist=stlist->next; stlist=stlist->next;

10
source/compiler/sc2.c
View File

@ -2949,7 +2949,7 @@ SC_FUNC void delete_symbols(symbol *root,int level,int delete_labels,int delete_
sym->usage &= ~uDEFINE; /* clear "defined" flag */ sym->usage &= ~uDEFINE; /* clear "defined" flag */
/* set all states as "undefined" too */ /* set all states as "undefined" too */
if (sym->states!=NULL) if (sym->states!=NULL)
for (stateptr=sym->states->next; stateptr!=NULL; stateptr=stateptr->next) for (stateptr=sym->states->first; stateptr!=NULL; stateptr=stateptr->next)
stateptr->value=0; stateptr->value=0;
/* for user defined operators, also remove the "prototyped" flag, as /* for user defined operators, also remove the "prototyped" flag, as
* user-defined operators *must* be declared before use * user-defined operators *must* be declared before use
@ -2989,10 +2989,10 @@ static symbol *find_symbol(const symbol *root,const char *name,int fnumber,int a
&& (sym->parent==NULL || sym->ident==iCONSTEXPR) /* sub-types (hierarchical types) are skipped, except for enum fields */ && (sym->parent==NULL || sym->ident==iCONSTEXPR) /* sub-types (hierarchical types) are skipped, except for enum fields */
&& (sym->fnumber<0 || sym->fnumber==fnumber)) /* check file number for scope */ && (sym->fnumber<0 || sym->fnumber==fnumber)) /* check file number for scope */
{ {
assert(sym->states==NULL || sym->states->next!=NULL); /* first element of the state list is the "root" */ assert(sym->states==NULL || sym->states->first!=NULL); /* first element of the state list is the "root" */
if (sym->ident==iFUNCTN if (sym->ident==iFUNCTN
|| (automaton<0 && sym->states==NULL) || (automaton<0 && sym->states==NULL)
|| (automaton>=0 && sym->states!=NULL && state_getfsa(sym->states->next->index)==automaton)) || (automaton>=0 && sym->states!=NULL && state_getfsa(sym->states->first->index)==automaton))
{ {
if (cmptag==NULL && sym->fnumber==fnumber) if (cmptag==NULL && sym->fnumber==fnumber)
return sym; /* return first match */ return sym; /* return first match */
@ -3110,8 +3110,8 @@ SC_FUNC symbol *findglb(const char *name,int filter)
* also verify whether there is an intersection between the symbol's * also verify whether there is an intersection between the symbol's
* state list and the current state list * state list and the current state list
*/ */
assert(sym->states!=NULL && sym->states->next!=NULL); assert(sym->states!=NULL && sym->states->first!=NULL);
if (!state_conflict_id(sc_curstates,sym->states->next->index)) if (!state_conflict_id(sc_curstates,sym->states->first->index))
sym=NULL; sym=NULL;
} /* if */ } /* if */
} /* if */ } /* if */

4
source/compiler/sc3.c
View File

@ -1985,8 +1985,8 @@ static int nesting=0;
value lval = {0}; value lval = {0};
arginfo *arg; arginfo *arg;
char arglist[sMAXARGS]; char arglist[sMAXARGS];
constvalue arrayszlst = { NULL, "", 0, 0};/* array size list starts empty */ constvalue_root arrayszlst = { NULL, NULL};/* array size list starts empty */
constvalue taglst = { NULL, "", 0, 0}; /* tag list starts empty */ constvalue_root taglst = { NULL, NULL}; /* tag list starts empty */
symbol *symret; symbol *symret;
cell lexval; cell lexval;
char *lexstr; char *lexstr;

12
source/compiler/sc4.c
View File

@ -75,7 +75,7 @@ SC_FUNC void writeleader(symbol *root)
*/ */
assert(glb_declared==0); assert(glb_declared==0);
begdseg(); begdseg();
for (fsa=sc_automaton_tab.next; fsa!=NULL; fsa=fsa->next) { for (fsa=sc_automaton_tab.first; fsa!=NULL; fsa=fsa->next) {
defstorage(); defstorage();
stgwrite("0\t; automaton "); stgwrite("0\t; automaton ");
if (strlen(fsa->name)==0) if (strlen(fsa->name)==0)
@ -91,7 +91,7 @@ SC_FUNC void writeleader(symbol *root)
begcseg(); begcseg();
for (sym=root->next; sym!=NULL; sym=sym->next) { for (sym=root->next; sym!=NULL; sym=sym->next) {
if (sym->ident==iFUNCTN && (sym->usage & (uPUBLIC | uREAD))!=0 && sym->states!=NULL) { if (sym->ident==iFUNCTN && (sym->usage & (uPUBLIC | uREAD))!=0 && sym->states!=NULL) {
stlist=sym->states->next; stlist=sym->states->first;
assert(stlist!=NULL); /* there should be at least one state item */ assert(stlist!=NULL); /* there should be at least one state item */
listid=stlist->index; listid=stlist->index;
assert(listid==-1 || listid>0); assert(listid==-1 || listid>0);
@ -109,7 +109,7 @@ SC_FUNC void writeleader(symbol *root)
continue; continue;
} /* if */ } /* if */
/* generate label numbers for all statelist ids */ /* generate label numbers for all statelist ids */
for (stlist=sym->states->next; stlist!=NULL; stlist=stlist->next) { for (stlist=sym->states->first; stlist!=NULL; stlist=stlist->next) {
assert(strlen(stlist->name)==0); assert(strlen(stlist->name)==0);
strcpy(stlist->name,itoh(getlabel())); strcpy(stlist->name,itoh(getlabel()));
} /* for */ } /* for */
@ -126,7 +126,7 @@ SC_FUNC void writeleader(symbol *root)
*/ */
statecount=0; statecount=0;
strcpy(lbl_default,itoh(lbl_nostate)); strcpy(lbl_default,itoh(lbl_nostate));
for (stlist=sym->states->next; stlist!=NULL; stlist=stlist->next) { for (stlist=sym->states->first; stlist!=NULL; stlist=stlist->next) {
if (stlist->index==-1) { if (stlist->index==-1) {
assert(strlen(stlist->name)<sizeof lbl_default); assert(strlen(stlist->name)<sizeof lbl_default);
strcpy(lbl_default,stlist->name); strcpy(lbl_default,stlist->name);
@ -146,10 +146,10 @@ SC_FUNC void writeleader(symbol *root)
/* generate the jump table */ /* generate the jump table */
setlabel(lbl_table); setlabel(lbl_table);
ffcase(statecount,lbl_default,TRUE); ffcase(statecount,lbl_default,TRUE);
for (state=sc_state_tab.next; state!=NULL; state=state->next) { for (state=sc_state_tab.first; state!=NULL; state=state->next) {
if (state->index==fsa_id) { if (state->index==fsa_id) {
/* find the label for this list id */ /* find the label for this list id */
for (stlist=sym->states->next; stlist!=NULL; stlist=stlist->next) { for (stlist=sym->states->first; stlist!=NULL; stlist=stlist->next) {
if (stlist->index!=-1 && state_inlist(stlist->index,(int)state->value)) { if (stlist->index!=-1 && state_inlist(stlist->index,(int)state->value)) {
ffcase(state->value,stlist->name,FALSE); ffcase(state->value,stlist->name,FALSE);
break; break;

20
source/compiler/sc6.c
View File

@ -813,7 +813,7 @@ SC_FUNC int assemble(FILE *fout,FILE *fin)
/* count number of libraries */ /* count number of libraries */
numlibraries=0; numlibraries=0;
if (pc_addlibtable) { if (pc_addlibtable) {
for (constptr=libname_tab.next; constptr!=NULL; constptr=constptr->next) { for (constptr=libname_tab.first; constptr!=NULL; constptr=constptr->next) {
if (constptr->value>0) { if (constptr->value>0) {
assert(strlen(constptr->name)>0); assert(strlen(constptr->name)>0);
numlibraries++; numlibraries++;
@ -824,7 +824,7 @@ SC_FUNC int assemble(FILE *fout,FILE *fin)
/* count number of public tags */ /* count number of public tags */
numtags=0; numtags=0;
for (constptr=tagname_tab.next; constptr!=NULL; constptr=constptr->next) { for (constptr=tagname_tab.first; constptr!=NULL; constptr=constptr->next) {
if ((constptr->value & PUBLICTAG)!=0) { if ((constptr->value & PUBLICTAG)!=0) {
assert(strlen(constptr->name)>0); assert(strlen(constptr->name)>0);
numtags++; numtags++;
@ -950,7 +950,7 @@ SC_FUNC int assemble(FILE *fout,FILE *fin)
/* write the libraries table */ /* write the libraries table */
if (pc_addlibtable) { if (pc_addlibtable) {
count=0; count=0;
for (constptr=libname_tab.next; constptr!=NULL; constptr=constptr->next) { for (constptr=libname_tab.first; constptr!=NULL; constptr=constptr->next) {
if (constptr->value>0) { if (constptr->value>0) {
assert(strlen(constptr->name)>0); assert(strlen(constptr->name)>0);
func.address=0; func.address=0;
@ -994,7 +994,7 @@ SC_FUNC int assemble(FILE *fout,FILE *fin)
/* write the public tagnames table */ /* write the public tagnames table */
count=0; count=0;
for (constptr=tagname_tab.next; constptr!=NULL; constptr=constptr->next) { for (constptr=tagname_tab.first; constptr!=NULL; constptr=constptr->next) {
if ((constptr->value & PUBLICTAG)!=0) { if ((constptr->value & PUBLICTAG)!=0) {
assert(strlen(constptr->name)>0); assert(strlen(constptr->name)>0);
func.address=constptr->value & TAGMASK; func.address=constptr->value & TAGMASK;
@ -1214,21 +1214,21 @@ static void append_dbginfo(FILE *fout)
} /* for */ } /* for */
/* tag table */ /* tag table */
for (constptr=tagname_tab.next; constptr!=NULL; constptr=constptr->next) { for (constptr=tagname_tab.first; constptr!=NULL; constptr=constptr->next) {
assert(strlen(constptr->name)>0); assert(strlen(constptr->name)>0);
dbghdr.tags++; dbghdr.tags++;
dbghdr.size+=sizeof(AMX_DBG_TAG)+strlen(constptr->name); dbghdr.size+=sizeof(AMX_DBG_TAG)+strlen(constptr->name);
} /* for */ } /* for */
/* automaton table */ /* automaton table */
for (constptr=sc_automaton_tab.next; constptr!=NULL; constptr=constptr->next) { for (constptr=sc_automaton_tab.first; constptr!=NULL; constptr=constptr->next) {
assert(constptr->index==0 && strlen(constptr->name)==0 || strlen(constptr->name)>0); assert(constptr->index==0 && strlen(constptr->name)==0 || strlen(constptr->name)>0);
dbghdr.automatons++; dbghdr.automatons++;
dbghdr.size+=sizeof(AMX_DBG_MACHINE)+strlen(constptr->name); dbghdr.size+=sizeof(AMX_DBG_MACHINE)+strlen(constptr->name);
} /* for */ } /* for */
/* state table */ /* state table */
for (constptr=sc_state_tab.next; constptr!=NULL; constptr=constptr->next) { for (constptr=sc_state_tab.first; constptr!=NULL; constptr=constptr->next) {
assert(strlen(constptr->name)>0); assert(strlen(constptr->name)>0);
dbghdr.states++; dbghdr.states++;
dbghdr.size+=sizeof(AMX_DBG_STATE)+strlen(constptr->name); dbghdr.size+=sizeof(AMX_DBG_STATE)+strlen(constptr->name);
@ -1347,7 +1347,7 @@ static void append_dbginfo(FILE *fout)
} /* for */ } /* for */
/* tag table */ /* tag table */
for (constptr=tagname_tab.next; constptr!=NULL; constptr=constptr->next) { for (constptr=tagname_tab.first; constptr!=NULL; constptr=constptr->next) {
assert(strlen(constptr->name)>0); assert(strlen(constptr->name)>0);
id1=(int16_t)(constptr->value & TAGMASK); id1=(int16_t)(constptr->value & TAGMASK);
#if BYTE_ORDER==BIG_ENDIAN #if BYTE_ORDER==BIG_ENDIAN
@ -1358,7 +1358,7 @@ static void append_dbginfo(FILE *fout)
} /* for */ } /* for */
/* automaton table */ /* automaton table */
for (constptr=sc_automaton_tab.next; constptr!=NULL; constptr=constptr->next) { for (constptr=sc_automaton_tab.first; constptr!=NULL; constptr=constptr->next) {
assert(constptr->index==0 && strlen(constptr->name)==0 || strlen(constptr->name)>0); assert(constptr->index==0 && strlen(constptr->name)==0 || strlen(constptr->name)>0);
id1=(int16_t)constptr->index; id1=(int16_t)constptr->index;
address=(ucell)constptr->value; address=(ucell)constptr->value;
@ -1372,7 +1372,7 @@ static void append_dbginfo(FILE *fout)
} /* for */ } /* for */
/* state table */ /* state table */
for (constptr=sc_state_tab.next; constptr!=NULL; constptr=constptr->next) { for (constptr=sc_state_tab.first; constptr!=NULL; constptr=constptr->next) {
assert(strlen(constptr->name)>0); assert(strlen(constptr->name)>0);
id1=(int16_t)constptr->value; id1=(int16_t)constptr->value;
id2=(int16_t)constptr->index; id2=(int16_t)constptr->index;

10
source/compiler/scstate.c
View File

@ -76,7 +76,7 @@ static constvalue *find_automaton(const char *name,int *last)
assert(last!=NULL); assert(last!=NULL);
*last=0; *last=0;
ptr=sc_automaton_tab.next; ptr=sc_automaton_tab.first;
while (ptr!=NULL) { while (ptr!=NULL) {
if (strcmp(name,ptr->name)==0) if (strcmp(name,ptr->name)==0)
return ptr; return ptr;
@ -110,7 +110,7 @@ SC_FUNC constvalue *automaton_find(const char *name)
SC_FUNC constvalue *automaton_findid(int id) SC_FUNC constvalue *automaton_findid(int id)
{ {
constvalue *ptr; constvalue *ptr;
for (ptr=sc_automaton_tab.next; ptr!=NULL && ptr->index!=id; ptr=ptr->next) for (ptr=sc_automaton_tab.first; ptr!=NULL && ptr->index!=id; ptr=ptr->next)
/* nothing */; /* nothing */;
return ptr; return ptr;
} }
@ -122,7 +122,7 @@ static constvalue *find_state(const char *name,int fsa,int *last)
assert(last!=NULL); assert(last!=NULL);
*last=0; *last=0;
ptr=sc_state_tab.next; ptr=sc_state_tab.first;
while (ptr!=NULL) { while (ptr!=NULL) {
if (ptr->index==fsa) { if (ptr->index==fsa) {
if (strcmp(name,ptr->name)==0) if (strcmp(name,ptr->name)==0)
@ -158,7 +158,7 @@ SC_FUNC constvalue *state_find(const char *name,int fsa_id)
SC_FUNC constvalue *state_findid(int id) SC_FUNC constvalue *state_findid(int id)
{ {
constvalue *ptr; constvalue *ptr;
for (ptr=sc_state_tab.next; ptr!=NULL && ptr->value!=id; ptr=ptr->next) for (ptr=sc_state_tab.first; ptr!=NULL && ptr->value!=id; ptr=ptr->next)
/* nothing */; /* nothing */;
return ptr; return ptr;
} }
@ -341,7 +341,7 @@ SC_FUNC void state_conflict(symbol *root)
continue; /* hierarchical data type or no function */ continue; /* hierarchical data type or no function */
if (sym->states==NULL) if (sym->states==NULL)
continue; /* this function has no states */ continue; /* this function has no states */
for (srcptr=sym->states->next; srcptr!=NULL; srcptr=srcptr->next) { for (srcptr=sym->states->first; srcptr!=NULL; srcptr=srcptr->next) {
if (srcptr->index==-1) if (srcptr->index==-1)
continue; /* state list id -1 is a special case */ continue; /* state list id -1 is a special case */
psrc=state_getlist_ptr(srcptr->index); psrc=state_getlist_ptr(srcptr->index);

8
source/compiler/scvars.c
View File

@ -37,8 +37,8 @@ SC_VDEFINE struct hashtable_t symbol_cache_ht;
SC_VDEFINE cell *litq; /* the literal queue */ SC_VDEFINE cell *litq; /* the literal queue */
SC_VDEFINE unsigned char pline[sLINEMAX+1]; /* the line read from the input file */ SC_VDEFINE unsigned char pline[sLINEMAX+1]; /* the line read from the input file */
SC_VDEFINE const unsigned char *lptr; /* points to the current position in "pline" */ SC_VDEFINE const unsigned char *lptr; /* points to the current position in "pline" */
SC_VDEFINE constvalue tagname_tab={ NULL, "", 0, 0}; /* tagname table */ SC_VDEFINE constvalue_root tagname_tab={ NULL, NULL}; /* tagname table */
SC_VDEFINE constvalue libname_tab={ NULL, "", 0, 0}; /* library table (#pragma library "..." syntax) */ SC_VDEFINE constvalue_root libname_tab={ NULL, NULL}; /* library table (#pragma library "..." syntax) */
SC_VDEFINE constvalue *curlibrary=NULL; /* current library */ SC_VDEFINE constvalue *curlibrary=NULL; /* current library */
SC_VDEFINE int pc_addlibtable=TRUE; /* is the library table added to the AMX file? */ SC_VDEFINE int pc_addlibtable=TRUE; /* is the library table added to the AMX file? */
SC_VDEFINE symbol *curfunc; /* pointer to current function */ SC_VDEFINE symbol *curfunc; /* pointer to current function */
@ -96,8 +96,8 @@ SC_VDEFINE int pc_naked=FALSE; /* if true mark following function a
SC_VDEFINE int pc_compat=FALSE; /* running in compatibility mode? */ SC_VDEFINE int pc_compat=FALSE; /* running in compatibility mode? */
SC_VDEFINE int pc_recursion=FALSE; /* enable detailed recursion report? */ SC_VDEFINE int pc_recursion=FALSE; /* enable detailed recursion report? */
SC_VDEFINE constvalue sc_automaton_tab = { NULL, "", 0, 0}; /* automaton table */ SC_VDEFINE constvalue_root sc_automaton_tab = { NULL, NULL}; /* automaton table */
SC_VDEFINE constvalue sc_state_tab = { NULL, "", 0, 0}; /* state table */ SC_VDEFINE constvalue_root sc_state_tab = { NULL, NULL}; /* state table */
SC_VDEFINE FILE *inpf = NULL; /* file read from (source or include) */ SC_VDEFINE FILE *inpf = NULL; /* file read from (source or include) */
SC_VDEFINE FILE *inpf_org= NULL; /* main source file */ SC_VDEFINE FILE *inpf_org= NULL; /* main source file */