GitHub/amxmodx
2
0
Fork 0
mirror of https://github.com/alliedmodders/amxmodx.git synced 2024-12-25 06:15:37 +03:00
Code Issues Projects Releases Wiki Activity

Compiler: Remove commented code in previous commit

Browse Source
This commit is contained in:
Arkshine 2014-09-29 20:36:14 +02:00
parent 199b41af0a
commit 3b3e78d65b
1 changed files with 1 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

127
compiler/libpc300/sc1.c
View File

@ -719,17 +719,14 @@ cleanup:
#if !defined SC_LIGHT
if (errnum==0 && strlen(errfname)==0) {
int recursion;
//long stacksize=max_stacksize(&glbtab,&recursion);
int flag_exceed=0;
if (sc_amxlimit > 0 && (long)(hdrsize+code_idx+glb_declared*sizeof(cell)+sc_stksize*sizeof(cell)) >= sc_amxlimit)
flag_exceed=1;
if ((sc_debug & sSYMBOLIC)!=0 || verbosity>=2 /*|| stacksize+32>=(long)sc_stksize*/ || flag_exceed) {
if ((sc_debug & sSYMBOLIC)!=0 || verbosity>=2 || flag_exceed) {
pc_printf("Header size: %8ld bytes\n", (long)hdrsize);
pc_printf("Code size: %8ld bytes\n", (long)code_idx);
pc_printf("Data size: %8ld bytes\n", (long)glb_declared*sizeof(cell));
pc_printf("Stack/heap size: %8ld bytes\n", (long)sc_stksize*sizeof(cell));
/*if (stacksize>0)
pc_printf("Estimated usage: %8ld bytes\n", stacksize*sizeof(cell));*/
pc_printf("Total requirements:%8ld bytes\n", (long)hdrsize+(long)code_idx+(long)glb_declared*sizeof(cell)+(long)sc_stksize*sizeof(cell));
} /* if */
if (flag_exceed)
@ -4251,128 +4248,6 @@ static void reduce_referrers(symbol *root)
} while (restart>0);
}
#if !defined SC_LIGHT
static long max_stacksize_recurse(symbol **sourcesym,symbol *sym,long basesize,int *pubfuncparams,int *recursion)
{
long size,maxsize;
int i,stkpos;
assert(sourcesym!=NULL);
assert(sym!=NULL);
assert(sym->ident==iFUNCTN);
assert((sym->usage & uNATIVE)==0);
assert(recursion!=NULL);
maxsize=sym->x.stacksize;
for (i=0; i<sym->numrefers; i++) {
if (sym->refer[i]!=NULL) {
assert(sym->refer[i]->ident==iFUNCTN);
assert((sym->refer[i]->usage & uNATIVE)==0); /* a native function cannot refer to a user-function */
for (stkpos=0; sourcesym[stkpos]!=NULL; stkpos++) {
if (sym->refer[i]==sourcesym[stkpos]) { /* recursion detection */
if ((sc_debug & sSYMBOLIC)!=0 || verbosity>=2) {
char symname[2*sNAMEMAX+16];/* allow space for user defined operators */
funcdisplayname(symname,sym->name);
errorset(sSETFILE,sym->fnumber);
errorset(sSETLINE,sym->lnumber);
error(234,symname); /* recursive function */
} /* if */
*recursion=1;
goto break_recursion; /* recursion was detected, quit loop */
} /* if */
} /* for */
/* add this symbol to the stack */
sourcesym[stkpos]=sym;
sourcesym[stkpos+1]=NULL;
/* check size of callee */
size=max_stacksize_recurse(sourcesym,sym->refer[i],sym->x.stacksize,pubfuncparams,recursion);
if (maxsize<size)
maxsize=size;
/* remove this symbol from the stack */
sourcesym[stkpos]=NULL;
} /* if */
} /* for */
break_recursion:
if ((sym->usage & uPUBLIC)!=0) {
/* Find out how many parameters a public function has, then see if this
* is bigger than some maximum
*/
arginfo *arg=sym->dim.arglist;
int count=0;
assert(arg!=0);
while (arg->ident!=0) {
count++;
arg++;
} /* while */
assert(pubfuncparams!=0);
if (count>*pubfuncparams)
*pubfuncparams=count;
} /* if */
errorset(sEXPRRELEASE,0); /* clear error data */
errorset(sRESET,0);
return maxsize+basesize;
}
static long max_stacksize(symbol *root,int *recursion)
{
/* Loop over all non-native functions. For each function, loop
* over all of its referrers, accumulating the stack requirements.
* Detect (indirect) recursion with a "mark-and-sweep" algorithm.
* I (mis-)use the "compound" field of the symbol structure for
* the marker, as this field is unused for functions.
*
* Note that the stack is shared with the heap. A host application
* may "eat" cells from the heap as well, through amx_Allot(). The
* stack requirements are thus only an estimate.
*/
long size,maxsize;
int maxparams,numfunctions;
symbol *sym;
symbol **symstack;
assert(root!=NULL);
assert(recursion!=NULL);
/* count number of functions (for allocating the stack for recursion detection) */
numfunctions=0;
for (sym=root->next; sym!=NULL; sym=sym->next) {
if (sym->ident==iFUNCTN) {
assert(sym->compound==0);
if ((sym->usage & uNATIVE)==0)
numfunctions++;
} /* if */
} /* if */
/* allocate function symbol stack */
symstack=(symbol **)malloc((numfunctions+1)*sizeof(symbol*));
if (symstack==NULL)
error(103); /* insufficient memory (fatal error) */
memset(symstack,0,(numfunctions+1)*sizeof(symbol*));
maxsize=0;
maxparams=0;
*recursion=0; /* assume no recursion */
for (sym=root->next; sym!=NULL; sym=sym->next) {
/* drop out if this is not a user-implemented function */
if (sym->ident!=iFUNCTN || (sym->usage & uNATIVE)!=0)
continue;
/* accumulate stack size for this symbol */
symstack[0]=sym;
assert(symstack[1]==NULL);
size=max_stacksize_recurse(symstack,sym,0L,&maxparams,recursion);
assert(size>=0);
if (maxsize<size)
maxsize=size;
} /* for */
free((void*)symstack);
maxsize++; /* +1 because a zero cell is always pushed on top
* of the stack to catch stack overwrites */
return maxsize+(maxparams+1);/* +1 because # of parameters is always pushed on entry */
}
#endif
/* testsymbols - test for unused local or global variables
*
* "Public" functions are excluded from the check, since these