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

Merge remote-tracking branch 'remotes/Daniel-Cortez/misc-fixes' into dev

Browse Source
This commit is contained in:
Y_Less 2021-05-02 17:45:11 +01:00
commit e97a67a226
12 changed files with 126 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
source/compiler/memfile.c
View File

@ -32,6 +32,11 @@ memfile_t *memfile_creat(const char *name, size_t init)
mf.offs = 0;
pmf = (memfile_t *)malloc(sizeof(memfile_t));
if (!pmf)
{
free(mf.base);
return NULL;
}
memcpy(pmf, &mf, sizeof(memfile_t));
pmf->name = strdup(name);

8
source/compiler/sc.h
View File

@ -97,7 +97,7 @@ typedef struct s_constvalue {
char name[sNAMEMAX+1];
cell value;
int index; /* index level, for constants referring to array sizes/tags
* automaton id. for states and automatons
* automaton id, for states and automatons
* tag for enumeration lists */
} constvalue;
@ -203,7 +203,6 @@ typedef struct s_symbol {
* bits: 0 (uDEFINE) the symbol is defined in the source file
* 1 (uREAD) the constant is "read" (accessed) in the source file
* 2 (uWRITTEN) redundant, but may be set for constants passed by reference
* 3 (uPREDEF) the constant is pre-defined and should be kept between passes
* 5 (uENUMROOT) the constant is the "root" of an enumeration
* 6 (uENUMFIELD) the constant is a field in a named enumeration
*/
@ -213,7 +212,6 @@ typedef struct s_symbol {
#define uRETVALUE 0x004 /* function returns (or should return) a value */
#define uCONST 0x008
#define uPROTOTYPED 0x008
#define uPREDEF 0x008 /* constant is pre-defined */
#define uPUBLIC 0x010
#define uNATIVE 0x020
#define uENUMROOT 0x020
@ -741,7 +739,6 @@ SC_FUNC void rename_symbol(symbol *sym,const char *newname);
SC_FUNC symbol *findglb(const char *name,int filter);
SC_FUNC symbol *findloc(const char *name);
SC_FUNC symbol *findconst(const char *name,int *cmptag);
SC_FUNC symbol *finddepend(const symbol *parent);
SC_FUNC symbol *addsym(const char *name,cell addr,int ident,int vclass,int tag,
int usage);
SC_FUNC symbol *addvariable(const char *name,cell addr,int ident,int vclass,int tag,
@ -1011,6 +1008,9 @@ SC_VDECL int pc_retexpr; /* true if the current expression is a part of a "
SC_VDECL int pc_retheap; /* heap space (in bytes) to be manually freed when returning an array returned by another function */
SC_VDECL int pc_nestlevel; /* number of active (open) compound statements */
SC_VDECL unsigned int pc_attributes;/* currently set attribute flags (for the "__pragma" operator) */
SC_VDECL int pc_ispackedstr; /* true if the last tokenized string is packed */
SC_VDECL char *sc_tokens[];
SC_VDECL constvalue_root sc_automaton_tab; /* automaton table */
SC_VDECL constvalue_root sc_state_tab; /* state table */

118
source/compiler/sc1.c
View File

@ -2812,7 +2812,7 @@ static cell initvector(int ident,int tag,cell size,int startlit,int fillzero,
if (!matchtoken(',')) {
needtoken('}');
break;
} /* for */
} /* if */
} /* for */
/* if this array is based on an enumeration, fill the "field" up with
* zeros, and toggle the tag
@ -2972,7 +2972,6 @@ static void decl_const(int vclass)
*/
static void decl_enum(int vclass,int fstatic)
{
extern const char *sc_tokens[];
char enumname[sNAMEMAX+1],constname[sNAMEMAX+1];
cell val,value,size;
char *str;
@ -3089,7 +3088,8 @@ static void decl_enum(int vclass,int fstatic)
/* don't reset "warn_overflow" yet, we'll need to use it later */
} /* if */
if (warn_noeffect) {
const char *str=sc_tokens[inctok-tFIRST],*name=noeffect_sym->name;
const char *name=noeffect_sym->name;
str=sc_tokens[inctok-tFIRST];
errorset(sSETPOS,noeffect_sym->lnumber);
error(245,str,increment,name); /* enum increment has no effect on zero value */
errorset(sSETPOS,-1);
@ -4058,14 +4058,12 @@ static int newfunc(char *firstname,int firsttag,int fpublic,int fstatic,int stoc
&& (lvar=findloc(sym->dim.arglist[i].name))!=NULL) {
if ((sym->dim.arglist[i].usage & uWRITTEN)==0) {
/* check if the argument was written in this definition */
depend=lvar;
while (depend!=NULL) {
for (depend=lvar; depend!=NULL; depend=depend->child) {
if ((depend->usage & uWRITTEN)!=0) {
sym->dim.arglist[i].usage|=depend->usage & uWRITTEN;
break;
}
depend=finddepend(depend);
} /* while */
} /* if */
} /* for */
} /* if */
/* mark argument as written if it was written in another definition */
lvar->usage|=sym->dim.arglist[i].usage & uWRITTEN;
@ -4139,7 +4137,6 @@ static int argcompare(arginfo *a1,arginfo *a2)
static int declargs(symbol *sym,int chkshadow)
{
#define MAXTAGS 16
extern char* sc_tokens[];
char *ptr;
int argcnt,oldargcnt,tok,tags[MAXTAGS],numtags;
cell val;
@ -4205,7 +4202,7 @@ static int declargs(symbol *sym,int chkshadow)
if (matchtoken('}'))
break;
needtoken(',');
} /* for */
} /* while */
needtoken(':');
tok=tLABEL; /* for outer loop: flag that we have seen a tagname */
break;
@ -5036,7 +5033,7 @@ static long max_stacksize(symbol *root,int *recursion)
if ((sym->usage & uNATIVE)==0)
numfunctions++;
} /* if */
} /* if */
} /* for */
/* allocate function symbol stack */
symstack=(symbol **)malloc((numfunctions+1)*sizeof(symbol*));
rsymstack=(symbol **)malloc((numfunctions+1)*sizeof(symbol*));
@ -5047,7 +5044,7 @@ static long max_stacksize(symbol *root,int *recursion)
maxsize=0;
maxparams=0;
*recursion=0; /* assume no recursion */
*recursion=FALSE; /* assume no recursion */
for (sym=root->next; sym!=NULL; sym=sym->next) {
int recursion_detected;
/* drop out if this is not a user-implemented function */
@ -5150,14 +5147,13 @@ static int testsymbols(symbol *root,int level,int testlabs,int testconst)
errorset(sSETPOS,-1);
} else if ((sym->usage & (uWRITTEN | uPUBLIC | uCONST))==0 && sym->ident==iREFARRAY) {
int warn = TRUE;
symbol* depend = finddepend(sym);
while (depend != NULL) {
if ((depend->usage & (uWRITTEN | uPUBLIC | uCONST)) != 0) {
warn = FALSE;
symbol *depend;
for (depend=sym->child; depend!=NULL; depend=depend->child) {
if ((depend->usage & (uWRITTEN | uPUBLIC | uCONST))!=0) {
warn=FALSE;
break;
}
depend = finddepend(depend);
} /* while */
} /* if */
} /* for */
if (warn) {
errorset(sSETPOS, sym->lnumber);
error(214, sym->name); /* make array argument "const" */
@ -5167,7 +5163,7 @@ static int testsymbols(symbol *root,int level,int testlabs,int testconst)
/* also mark the variable (local or global) to the debug information */
if ((sym->usage & (uWRITTEN | uREAD))!=0 && (sym->usage & uNATIVE)==0)
insert_dbgsymbol(sym);
} /* if */
} /* switch */
sym=sym->next;
} /* while */
@ -5182,7 +5178,7 @@ static cell calc_array_datasize(symbol *sym, cell *offset)
assert(sym->ident==iARRAY || sym->ident==iREFARRAY);
length=sym->dim.array.length;
if (sym->dim.array.level > 0) {
cell sublength=calc_array_datasize(finddepend(sym),offset);
cell sublength=calc_array_datasize(sym->child,offset);
if (offset!=NULL)
*offset=length*(*offset+sizeof(cell));
if (sublength>0)
@ -5615,7 +5611,6 @@ static void statement(int *lastindent,int allow_decl)
pragma_apply(curfunc);
break;
case t__EMIT: {
extern char *sc_tokens[];
const unsigned char *bck_lptr=lptr-strlen(sc_tokens[tok-tFIRST]);
if (matchtoken('{')) {
emit_flags |= efBLOCK;
@ -5679,7 +5674,7 @@ static void compound(int stmt_sameline,int starttok)
error(30,block_start); /* compound block not closed at end of file */
break;
} else {
if (count_stmt>0 && isterminal(lastst))
if (count_stmt>0 && isterminal(lastst)) {
if (matchtoken(tLABEL)) {
cell val;
char *name;
@ -5689,12 +5684,13 @@ static void compound(int stmt_sameline,int starttok)
sym=findloc(name);
/* before issuing a warning, check if the label was previously used (via 'goto') */
if (sym!=NULL && sym->ident==iLABEL && (sym->usage & uREAD)==0)
error(225); /* unreachable code */
error(225); /* unreachable code */
} else if (lastst==tTERMSWITCH && matchtoken(tRETURN)) {
lexpush(); /* push the token so it can be analyzed later */
} else {
error(225); /* unreachable code */
} /* if */
} /* if */
statement(&indent,TRUE); /* do a statement */
count_stmt++;
} /* if */
@ -6210,7 +6206,7 @@ static int doswitch(void)
error(40,val); /* duplicate "case" label */
assert(csp==NULL || csp->next==cse);
insert_constval(csp,cse,itoh(lbl_case),val,0);
} /* if */
} /* while */
} /* if */
} while (matchtoken(','));
needtoken(':'); /* ':' ends the case */
@ -6250,26 +6246,25 @@ static int doswitch(void)
if (enumsym!=NULL && swdefault==FALSE && enumsym->x.tags.unique-enumsymcount<=2) {
constvalue_root *enumlist=enumsym->dim.enumlist;
constvalue *val,*prev=NULL,*save_next=NULL;
for (val=enumlist->first; val!=NULL; prev=val,val=val->next) {
constvalue *cur,*found,*prev=NULL,*save_next=NULL;
for (cur=enumlist->first; cur!=NULL; prev=cur,cur=cur->next) {
/* if multiple enum elements share the same value, we only want to count the first one */
if (prev!=NULL) {
/* see if there's another constvalue before the current one that has the same value */
constvalue *save_next=prev->next;
constvalue *found;
save_next=prev->next;
prev->next=NULL;
found=find_constval_byval(enumlist,val->value);
found=find_constval_byval(enumlist,cur->value);
prev->next=save_next;
if (found!=NULL)
continue;
} /* if */
/* check if the value of this constant is handled in switch, if so - continue */
if (find_constval_byval(&caselist,val->value)!=NULL)
if (find_constval_byval(&caselist,cur->value)!=NULL)
continue;
errorset(sSETPOS,save_fline);
error(244,val->name); /* enum element not handled in switch */
error(244,cur->name); /* enum element not handled in switch */
errorset(sSETPOS,-1);
} /* while */
} /* for */
} /* if */
#if !defined NDEBUG
@ -6429,7 +6424,6 @@ static symbol *fetchlab(char *name)
static void SC_FASTCALL emit_invalid_token(int expected_token,int found_token)
{
extern char *sc_tokens[];
char s[2];
assert(expected_token>=tFIRST);
@ -6797,7 +6791,6 @@ fetchtok:
negate=TRUE;
goto fetchtok;
} else {
extern char *sc_tokens[];
char ival[sNAMEMAX+2];
invalid_token_neg:
if (tok<tFIRST)
@ -6851,7 +6844,6 @@ static void SC_FASTCALL emit_param_nonneg(emit_outval *p)
if (!emit_param_any_internal(p,teNONNEG,FALSE,TRUE))
return;
if ((cell)p->value.ucell<(cell)0) {
extern char *sc_tokens[];
#if PAWN_CELL_SIZE==16
char ival[7];
#elif PAWN_CELL_SIZE==32
@ -6983,7 +6975,6 @@ fetchtok:
negate=TRUE;
goto fetchtok;
} else {
extern char *sc_tokens[];
char ival[sNAMEMAX+2];
invalid_token_neg:
if (tok<tFIRST)
@ -7828,7 +7819,6 @@ static int emit_findopcode(const char *instr)
SC_FUNC void emit_parse_line(void)
{
extern char *sc_tokens[];
cell val;
char* st;
int tok,len,i;
@ -7950,7 +7940,7 @@ static void doreturn(void)
error(225); /* unreachable code */
/* see if this function already has a sub type (an array attached) */
assert(curfunc!=NULL);
sub=finddepend(curfunc);
sub=curfunc->child;
assert(sub==NULL || sub->ident==iREFARRAY);
if ((rettype & uRETVALUE)!=0) {
int retarray=(ident==iARRAY || ident==iREFARRAY);
@ -7982,8 +7972,8 @@ static void doreturn(void)
if (sym->dim.array.length!=dim[numdim])
error(47); /* array sizes must match */
if (numdim<level) {
sym=finddepend(sym);
sub=finddepend(sub);
sym=sym->child;
sub=sub->child;
assert(sym!=NULL && sub!=NULL);
/* ^^^ both arrays have the same dimensions (this was checked
* earlier) so the dependend should always be found
@ -8004,7 +7994,7 @@ static void doreturn(void)
dim[numdim]=(int)sub->dim.array.length;
idxtag[numdim]=sub->x.tags.index;
if (numdim<level) {
sub=finddepend(sub);
sub=sub->child;
assert(sub!=NULL);
} /* if */
/* check that all dimensions are known */
@ -8296,7 +8286,6 @@ static int *readwhile(void)
static void dopragma(void)
{
extern char *sc_tokens[];
int tok;
int bck_litidx,bck_packstr;
int i;
@ -8320,45 +8309,46 @@ static void dopragma(void)
do {
/* read the option string */
tok=lex(&val,&str);
if (tok!=tSTRING) {
if (tok!=tSTRING || !pc_ispackedstr) {
/* either not a string, or the user prepended "!" to the option string */
char tokstr[2];
if (tok==tSTRING)
tok='!';
if (tok<tFIRST) {
sprintf(tokstr,"%c",tok);
str=tokstr;
} else {
str=sc_tokens[tok-tBEGIN];
str=sc_tokens[tok-tFIRST];
} /* if */
error(1,sc_tokens[tSTRING-tFIRST],str);
goto next;
} /* if */
assert(litidx>bck_litidx);
/* the user shouldn't prepend "!" to the option string */
if (litq[val]<=UNPACKEDMAX && litq[val]!=0) {
error(1,sc_tokens[tSTRING-tFIRST],"!");
goto next;
} /* if */
/* swap the cell bytes if we're on a Little Endian platform */
#if BYTE_ORDER==LITTLE_ENDIAN
{ /* local */
char *bytes;
i=0;
i=(int)val;
do {
char t;
bytes=(char *)&litq[val+i];
i++;
#if PAWN_CELL_SIZE>=16
t=bytes[0], bytes[0]=bytes[sizeof(cell)-1], bytes[sizeof(cell)-1]=t;
#if PAWN_CELL_SIZE>=32
bytes=(char *)&litq[i++];
t=bytes[0], bytes[0]=bytes[sizeof(cell)-1], bytes[sizeof(cell)-1]=t;
#if PAWN_CELL_SIZE>=32
t=bytes[1], bytes[1]=bytes[sizeof(cell)-2], bytes[sizeof(cell)-2]=t;
#if PAWN_CELL_SIZE==64
#if PAWN_CELL_SIZE==64
t=bytes[2], bytes[2]=bytes[sizeof(cell)-3], bytes[sizeof(cell)-3]=t;
t=bytes[3], bytes[3]=bytes[sizeof(cell)-4], bytes[sizeof(cell)-4]=t;
#endif // PAWN_CELL_SIZE==64
#endif // PAWN_CELL_SIZE==32
#endif // PAWN_CELL_SIZE==16
} while (bytes[0]!='\0' && bytes[1]!='\0' && bytes[2]!='\0' && bytes[3]!='\0');
#endif // PAWN_CELL_SIZE==64
#endif // PAWN_CELL_SIZE>=32
} while (bytes[0]!='\0' && bytes[1]!='\0'
#if PAWN_CELL_SIZE>=32
&& bytes[2]!='\0' && bytes[3]!='\0'
#if PAWN_CELL_SIZE==64
&& bytes[4]!='\0' && bytes[5]!='\0' && bytes[6]!='\0' && bytes[7]!='\0'
#endif // PAWN_CELL_SIZE==64
#endif // PAWN_CELL_SIZE>=32
); /* do */
} /* local */
#endif
@ -8376,7 +8366,7 @@ static void dopragma(void)
* and parse the argument(s), if needed */
if (!strcmp(str,"deprecated")) {
free(pc_deprecate);
pc_deprecate=strdup(&str[i]);
pc_deprecate=duplicatestring(&str[i]);
if (pc_deprecate==NULL)
error(103); /* insufficient memory */
pc_attributes |= (1U << attrDEPRECATED);
@ -8406,7 +8396,7 @@ static void dopragma(void)
/* nothing */;
} /* if */
if (strcmp(str,"enable")==0 || strcmp(str,"disable")==0) {
int len=number(&val,&str[i]);
int len=number(&val,(unsigned char *)&str[i]);
if (len==0)
goto unknown_pragma;
pc_enablewarning((int)val,(str[0]=='e') ? warnENABLE : warnDISABLE);

74
source/compiler/sc2.c
View File

@ -250,7 +250,7 @@ SC_FUNC int plungefile(char *name,int try_currentpath,int try_includepaths)
strlcpy(path,ptr,arraysize(path));
strlcat(path,name,arraysize(path));
result=plungequalifiedfile(path);
} /* while */
} /* for */
} /* if */
return result;
}
@ -404,7 +404,7 @@ static void readline(unsigned char *line)
} else {
/* check whether to erase leading spaces */
if (cont) {
unsigned char *ptr=line;
ptr=line;
while (*ptr<=' ' && *ptr!='\0')
ptr++;
if (ptr!=line)
@ -457,7 +457,7 @@ static void readline(unsigned char *line)
* ends with the same multiline string, so that this won't trigger commands:
*
* new x[] = "Hello
*
*
* #define X 0
* ";
*
@ -608,9 +608,9 @@ static int stripcomment(unsigned char *line)
} else {
if (incommand==2 && *line>' ') {
/* line starting a command, may need raw strings */
if (strncmp(line, "#error", 6)==0 ||
strncmp(line, "#warning", 8)==0 ||
strncmp(line, "#pragma", 7)==0) {
if (strncmp((char*)line,"#error",6)==0 ||
strncmp((char*)line,"#warning",8)==0 ||
strncmp((char*)line,"#pragma",7)==0) {
/* is one of the pre-processor commands with pure raw strings */
incommand=1;
} else {
@ -992,7 +992,7 @@ static const unsigned char *getstring(unsigned char *dest,int max,const unsigned
if (len<max-1)
dest[len++]=*line;
line++;
} /* if */
} /* while */
dest[len]='\0';
if (*line=='"')
line++; /* skip closing " */
@ -1010,7 +1010,7 @@ static const unsigned char *getstring(unsigned char *dest,int max,const unsigned
*/
static char* strdupwithouta(const char* sourcestring)
{
char* result=strdup(sourcestring);
char* result=duplicatestring(sourcestring);
char* a=result;
if (result==NULL) {
return NULL;
@ -1220,7 +1220,6 @@ static int command(void)
if (!cp_set(name))
error(108); /* codepage mapping file not found */
} else if (strcmp(str,"compress")==0) {
cell val;
preproc_expr(&val,NULL);
sc_compress=(int)val; /* switch code packing on/off */
} else if (strcmp(str,"ctrlchar")==0) {
@ -1272,7 +1271,6 @@ static int command(void)
curlibrary=append_constval(&libname_tab,name,0,0);
} /* if */
} else if (strcmp(str,"pack")==0) {
cell val;
preproc_expr(&val,NULL); /* default = packed/unpacked */
sc_packstr=(int)val;
} else if (strcmp(str,"rational")==0) {
@ -1307,11 +1305,9 @@ static int command(void)
error(69); /* rational number format already set, can only be set once */
} /* if */
} else if (strcmp(str,"semicolon")==0) {
cell val;
preproc_expr(&val,NULL);
sc_needsemicolon=(int)val;
} else if (strcmp(str,"tabsize")==0) {
cell val;
preproc_expr(&val,NULL);
if (val>0)
sc_tabsize=(int)val;
@ -1379,7 +1375,6 @@ static int command(void)
int ok=lex(&val,&str)==tSYMBOL;
if (ok) {
if (strcmp(str,"enable")==0 || strcmp(str,"disable")==0) {
cell val;
enum s_warnmode enable=(str[0]=='e') ? warnENABLE : warnDISABLE;
do {
preproc_expr(&val,NULL);
@ -1397,7 +1392,6 @@ static int command(void)
error(207); /* unknown #pragma */
} /* if */
} else if (strcmp(str,"compat")==0) {
cell val;
symbol *sym;
preproc_expr(&val,NULL);
pc_compat=(int)val; /* switch compatibility mode on/off */
@ -1495,7 +1489,6 @@ static int command(void)
} /* if */
break;
default: {
extern char *sc_tokens[];/* forward declaration */
char s2[33]="-";
if ((char)tok=='-') {
int current_token=lex(&val,&str);
@ -2298,24 +2291,6 @@ SC_FUNC void lexinit(void)
_lexnewline=FALSE;
}
char *sc_tokens[] = {
"*=", "/=", "%=", "+=", "-=", "<<=", ">>>=", ">>=", "&=", "^=", "|=",
"||", "&&", "==", "!=", "<=", ">=", "<<", ">>>", ">>", "++", "--",
"...", "..",
"__addressof", "assert", "*begin", "break", "case", "char", "const", "continue",
"default", "defined", "do", "else", "__emit", "*end", "enum", "exit", "for",
"forward", "goto", "if", "__nameof", "native", "new", "operator", "__pragma",
"public", "return", "sizeof", "sleep", "state", "static", "stock", "switch",
"tagof", "*then", "while",
"#assert", "#define", "#else", "#elseif", "#emit", "#endif", "#endinput",
"#endscript", "#error", "#file", "#if", "#include", "#line", "#pragma",
"#tryinclude", "#undef", "#warning",
";", ";", "-integer value-", "-rational value-", "-identifier-",
"-label-", "-string-",
"-any value-", "-numeric value-", "-data offset-", "-local variable-",
"-reference-", "-function-", "-native function-", "-nonnegative integer-"
};
SC_FUNC int lex(cell *lexvalue,char **lexsym)
{
int i,toolong,newline,stringflags;
@ -2430,7 +2405,7 @@ SC_FUNC int lex(cell *lexvalue,char **lexsym)
error(220);
} /* if */
} /* if */
} else if (*lptr=='\"' || *lptr=='#' || (*lptr==sc_ctrlchar && (*(lptr+1)=='\"' || *(lptr+1)=='#')))
} else if (*lptr=='\"' || *lptr=='#' || (*lptr==sc_ctrlchar && (*(lptr+1)=='\"' || *(lptr+1)=='#')))
{ /* unpacked string literal */
_lextok=tSTRING;
stringflags=(*lptr==sc_ctrlchar) ? RAWMODE : 0;
@ -2440,6 +2415,7 @@ SC_FUNC int lex(cell *lexvalue,char **lexsym)
if ((stringflags & RAWMODE)!=0)
lptr+=1; /* skip "escape" character too */
lptr=sc_packstr ? packedstring(lptr,&stringflags) : unpackedstring(lptr,&stringflags);
pc_ispackedstr=sc_packstr;
if (*lptr=='\"')
lptr+=1; /* skip final quote */
else if (!(stringflags & STRINGIZE))
@ -2466,6 +2442,7 @@ SC_FUNC int lex(cell *lexvalue,char **lexsym)
if ((stringflags & RAWMODE)!=0)
lptr+=1; /* skip "escape" character too */
lptr=sc_packstr ? unpackedstring(lptr,&stringflags) : packedstring(lptr,&stringflags);
pc_ispackedstr=!sc_packstr;
if (*lptr=='\"')
lptr+=1; /* skip final quote */
else if (!(stringflags & STRINGIZE))
@ -3023,10 +3000,8 @@ static symbol *add_symbol(symbol *root,symbol *entry,int sort)
while (root->next!=NULL && strcmp(entry->name,root->next->name)>0)
root=root->next;
if ((newsym=(symbol *)malloc(sizeof(symbol)))==NULL) {
if ((newsym=(symbol *)malloc(sizeof(symbol)))==NULL)
error(103);
return NULL;
} /* if */
memcpy(newsym,entry,sizeof(symbol));
newsym->next=root->next;
root->next=newsym;
@ -3145,8 +3120,8 @@ SC_FUNC void delete_symbols(symbol *root,int level,int delete_labels,int delete_
mustdelete=TRUE;
break;
case iCONSTEXPR:
/* delete constants, except predefined constants */
mustdelete=delete_functions || (sym->usage & uPREDEF)==0;
/* delete constants (predefined constants are checked later) */
mustdelete=TRUE;
break;
case iFUNCTN:
/* optionally preserve globals (variables & functions), but
@ -3247,13 +3222,6 @@ static symbol *find_symbol(const symbol *root,const char *name,int fnumber,int a
return firstmatch;
}
static symbol *find_symbol_child(const symbol *root,const symbol *sym)
{
if (sym->child && sym->child->parent==sym)
return sym->child;
return NULL;
}
/* Adds "bywhom" to the list of referrers of "entry". Typically,
* bywhom will be the function that uses a variable or that calls
* the function.
@ -3470,16 +3438,6 @@ SC_FUNC symbol *findconst(const char *name,int *cmptag)
return sym;
}
SC_FUNC symbol *finddepend(const symbol *parent)
{
symbol *sym;
sym=find_symbol_child(&loctab,parent); /* try local symbols first */
if (sym==NULL) /* not found */
sym=find_symbol_child(&glbtab,parent);
return sym;
}
/* addsym
*
* Adds a symbol to the symbol table (either global or local variables,
@ -3493,10 +3451,8 @@ SC_FUNC symbol *addsym(const char *name,cell addr,int ident,int vclass,int tag,i
assert(ident!=iLABEL || findloc(name)==NULL);
/* create an empty referrer list */
if ((refer=(symbol**)malloc(sizeof(symbol*)))==NULL) {
if ((refer=(symbol**)malloc(sizeof(symbol*)))==NULL)
error(103); /* insufficient memory */
return NULL;
} /* if */
*refer=NULL;
/* first fill in the entry */

40
source/compiler/sc3.c
View File

@ -146,7 +146,7 @@ static void (*unopers[])(void) = { lneg, neg, user_inc, user_dec };
if (lval!=NULL && (lval->ident==iARRAYCELL || lval->ident==iARRAYCHAR))
savealt=TRUE;
} else {
assert( arraysize(binoperstr) == arraysize(op1) );
assert_static( arraysize(binoperstr) == arraysize(op1) );
for (i=0; i<arraysize(op1); i++) {
if (oper==op1[i]) {
strcpy(opername,binoperstr[i]);
@ -159,7 +159,7 @@ static void (*unopers[])(void) = { lneg, neg, user_inc, user_dec };
assert(oper!=NULL);
assert(numparam==1);
/* try a select group of unary operators */
assert( arraysize(unoperstr) == arraysize(unopers) );
assert_static( arraysize(unoperstr) == arraysize(unopers) );
if (opername[0]=='\0') {
for (i=0; i<arraysize(unopers); i++) {
if (oper==unopers[i]) {
@ -419,7 +419,7 @@ static int skim(int *opstr,void (*testfunc)(int),int dropval,int endval,
break; /* none of the operators in "opstr" were found */
} /* if */
} /* while */
} /* for */
lval_stgidx=org_index;
lval_cidx=org_cidx;
@ -587,7 +587,7 @@ static void plnge2(void (*oper)(void),
rvalue(lval2);
if (lval2->ident==iCONSTEXPR) { /* constant on right side */
if (commutative(oper)) { /* test for commutative operators */
value lvaltmp = {0};
value lvaltmp;
stgdel(lval_stgidx,lval_cidx); /* scratch pushreg() and constant fetch (then
* fetch the constant again */
ldconst(lval2->constval<<dbltest(oper,lval1,lval2),sALT);
@ -817,7 +817,7 @@ SC_FUNC cell array_totalsize(symbol *sym)
assert(sym->ident==iARRAY || sym->ident==iREFARRAY);
length=sym->dim.array.length;
if (sym->dim.array.level > 0) {
cell sublength=array_totalsize(finddepend(sym));
cell sublength=array_totalsize(sym->child);
if (sublength>0)
length=length+length*sublength;
else
@ -832,9 +832,9 @@ static cell array_levelsize(symbol *sym,int level)
assert(sym->ident==iARRAY || sym->ident==iREFARRAY);
assert(level <= sym->dim.array.level);
while (level-- > 0) {
sym=finddepend(sym);
sym=sym->child;
assert(sym!=NULL);
} /* if */
} /* while */
return sym->dim.array.length;
}
@ -1055,7 +1055,6 @@ static int hier14(value *lval1)
/* check the sizes of all sublevels too */
symbol *sym1 = lval3.sym;
symbol *sym2 = lval2.sym;
int i;
assert(sym1!=NULL && sym2!=NULL);
/* ^^^ sym2 must be valid, because only variables can be
* multi-dimensional (there are no multi-dimensional literals),
@ -1063,8 +1062,8 @@ static int hier14(value *lval1)
*/
assert(exactmatch);
for (i=0; i<level; i++) {
sym1=finddepend(sym1);
sym2=finddepend(sym2);
sym1=sym1->child;
sym2=sym2->child;
assert(sym1!=NULL && sym2!=NULL);
/* ^^^ both arrays have the same dimensions (this was checked
* earlier) so the dependend should always be found
@ -1362,7 +1361,6 @@ static int hier2(value *lval)
lval->tag=tag;
return lvalue;
case t__ADDRESSOF: {
extern char *sc_tokens[];
static const char allowed_sym_types[]="-variable, array, array cell, label or function-";
paranthese=0;
while (matchtoken('('))
@ -1430,7 +1428,7 @@ static int hier2(value *lval)
numoffsets+=offsmul;
offsmul*=subsym->dim.array.length;
arrayidx=(arrayidx*subsym->dim.array.length)+val;
subsym=finddepend(subsym);
subsym=subsym->child;
}
needtoken(']');
} /* for */
@ -1440,8 +1438,8 @@ static int hier2(value *lval)
numoffsets+=offsmul;
offsmul*=subsym->dim.array.length;
arrayidx*=arrayidx*subsym->dim.array.length;
subsym=finddepend(subsym);
} /* if */
subsym=subsym->child;
} /* while */
lval->constval+=(numoffsets-1+arrayidx)*(cell)sizeof(cell);
ldconst(lval->constval,sPRI);
} /* if */
@ -1543,7 +1541,7 @@ static int hier2(value *lval)
} /* if */
needtoken(']');
if (subsym!=NULL)
subsym=finddepend(subsym);
subsym=subsym->child;
} /* for */
if (level>sym->dim.array.level+1)
error(28,sym->name); /* invalid subscript */
@ -1595,7 +1593,7 @@ static int hier2(value *lval)
} /* if */
needtoken(']');
if (subsym!=NULL)
subsym=finddepend(subsym);
subsym=subsym->child;
} /* for */
if (level>sym->dim.array.level+1)
error(28,sym->name); /* invalid subscript */
@ -1790,7 +1788,7 @@ restart:
/* parse the next index if this is not the lowest array dimension */
if (sym!=NULL && (sym->ident==iARRAY || sym->ident==iREFARRAY) && sym->dim.array.level>0) {
lval1->ident=iREFARRAY;
lval1->sym=finddepend(sym);
lval1->sym=sym->child;
assert(lval1->sym!=NULL);
assert(lval1->sym->dim.array.level==sym->dim.array.level-1);
cursym=lval1->sym;
@ -1877,7 +1875,7 @@ restart:
ob_add();
/* adjust the "value" structure and find the referenced array */
lval1->ident=iREFARRAY;
lval1->sym=finddepend(sym);
lval1->sym=sym->child;
assert(lval1->sym!=NULL);
assert(lval1->sym->dim.array.level==sym->dim.array.level-1);
cursym=lval1->sym;
@ -2081,7 +2079,7 @@ static int primary(value *lval)
return FALSE; /* return 0 for function (not an lvalue) */
} /* if */
lexpush(); /* push the token, it is analyzed by constant() */
if (constant(lval)==0) {
if (!constant(lval)) {
error(29); /* expression error, assumed 0 */
ldconst(0,sPRI); /* load 0 */
} /* if */
@ -2197,7 +2195,7 @@ static int nesting=0;
return;
}
/* check whether this is a function that returns an array */
symret=finddepend(sym);
symret=sym->child;
assert(symret==NULL || symret->ident==iREFARRAY);
if (symret!=NULL) {
int retsize;
@ -2453,7 +2451,7 @@ static int nesting=0;
else
check_index_tagmismatch(sym->name,arg[argidx].idxtag[level],sym->x.tags.index,TRUE,0);
append_constval(&arrayszlst,arg[argidx].name,sym->dim.array.length,level);
sym=finddepend(sym);
sym=sym->child;
assert(sym!=NULL);
level++;
} /* if */

1
source/compiler/sc5.c
View File

@ -700,7 +700,6 @@ SC_FUNC int error_suggest(int number,const char *name,const char *name2,int type
} /* if */
} else if (type==estNONSYMBOL) {
if (tMIDDLE<subtype && subtype<=tLAST) {
extern char *sc_tokens[];
name=sc_tokens[subtype-tFIRST];
subtype=esfVARCONST;
goto find_symbol;

4
source/compiler/sc7.c
View File

@ -1699,10 +1699,8 @@ static char *replacesequence(char *pattern,char symbols[MAX_OPT_VARS][MAX_ALIAS+
} /* while */
/* allocate a buffer to replace the sequence in */
if ((buffer=(char*)malloc(*repl_length))==NULL) {
if ((buffer=(char*)malloc(*repl_length))==NULL)
error(103);
return NULL;
} /* if */
/* replace the pattern into this temporary buffer */
lptr=buffer;

5
source/compiler/sclist.c
View File

@ -44,7 +44,8 @@
SC_FUNC char* duplicatestring(const char* sourcestring)
{
char* result=(char*)malloc(strlen(sourcestring)+1);
strcpy(result,sourcestring);
if (result!=NULL)
strcpy(result,sourcestring);
return result;
}
@ -482,7 +483,7 @@ SC_FUNC stringlist *insert_dbgsymbol(symbol *sym)
#endif
symbol *sub;
strcat(string," [ ");
for (sub=sym; sub!=NULL; sub=finddepend(sub)) {
for (sub=sym; sub!=NULL; sub=sub->child) {
assert(sub->dim.array.level==count--);
sprintf(string+strlen(string),"%x:%x ",sub->x.tags.index,sub->dim.array.length);
} /* for */

19
source/compiler/scvars.c
View File

@ -102,6 +102,25 @@ SC_VDEFINE int pc_retexpr=FALSE; /* true if the current expression is
SC_VDEFINE int pc_retheap=0; /* heap space (in bytes) to be manually freed when returning an array returned by another function */
SC_VDEFINE int pc_nestlevel=0; /* number of active (open) compound statements */
SC_VDEFINE unsigned int pc_attributes=0; /* currently set attribute flags (for the "__pragma" operator) */
SC_VDEFINE int pc_ispackedstr=FALSE; /* true if the last tokenized string is packed */
SC_VDEFINE char *sc_tokens[] = {
"*=", "/=", "%=", "+=", "-=", "<<=", ">>>=", ">>=", "&=", "^=", "|=",
"||", "&&", "==", "!=", "<=", ">=", "<<", ">>>", ">>", "++", "--",
"...", "..",
"__addressof", "assert", "*begin", "break", "case", "char", "const", "continue",
"default", "defined", "do", "else", "__emit", "*end", "enum", "exit", "for",
"forward", "goto", "if", "__nameof", "native", "new", "operator", "__pragma",
"public", "return", "sizeof", "sleep", "state", "static", "stock", "switch",
"tagof", "*then", "while",
"#assert", "#define", "#else", "#elseif", "#emit", "#endif", "#endinput",
"#endscript", "#error", "#file", "#if", "#include", "#line", "#pragma",
"#tryinclude", "#undef", "#warning",
";", ";", "-integer value-", "-rational value-", "-identifier-",
"-label-", "-string-",
"-any value-", "-numeric value-", "-data offset-", "-local variable-",
"-reference-", "-function-", "-native function-", "-nonnegative integer-"
};
SC_VDEFINE constvalue_root sc_automaton_tab = { NULL, NULL}; /* automaton table */
SC_VDEFINE constvalue_root sc_state_tab = { NULL, NULL}; /* state table */

6
source/compiler/tests/error_047.meta Normal file
View File

@ -0,0 +1,6 @@
{
'test_type': 'output_check',
'errors': """
error_047.pwn(8) : error 047: array sizes do not match, or destination array is too small
"""
}

0
source/compiler/tests/warning_047.pwn → source/compiler/tests/error_047.pwn
View File

6
source/compiler/tests/warning_047.meta
View File

@ -1,6 +0,0 @@
{
'test_type': 'output_check',
'errors': """
warning_047.pwn(8) : error 047: array sizes do not match, or destination array is too small
"""
}