Loading files
This file is pinned to the selected release. Download the original to open it in your design tool.
/* $VER: vbcc (declaration.c) V0.8 */
#include <string.h>
#include "vbcc_cpp.h"
#include "vbc.h"
static char FILE_[]=__FILE__;
#define PLAIN_STORAGE_CLASS 7
#define PARAMETER 8
#define OLDSTYLE 16
void dynamic_init(struct Var *v,struct Typ *t,struct const_list *cl,zmax of,int noconst);
int test_assignment(struct Typ *,np);
int return_sc,return_reg,has_return,return_inline;
char *return_vattr;
static int did_return_label;
#ifdef HAVE_TARGET_ATTRIBUTES
unsigned long return_tattr;
#endif
zmax init_dyn_sz,init_const_sz;
int init_dyn_cnt,init_const_cnt;
void init_sl(struct struct_list *sl);
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
extern np gen_libcall(char *,np,struct Typ *,np,struct Typ *);
extern int float_used;
extern void optimize(long,struct Var *);
static void clear_main_ret(void)
{
if(c99&&!strcmp(cur_func,"main")&&return_typ&&ISSCALAR(return_typ->flags)){
/* in c99, main returns 0 if it falls from back */
struct IC *new=new_IC();
new->code=SETRETURN;
new->q1.val.vmax=l2zm(0L);
eval_const(&new->q1.val,MAXINT);
insert_const(&new->q1.val,return_typ->flags&NU);
new->q1.flags=KONST;
new->typf=return_typ->flags;
new->q2.val.vmax=szof(return_typ);
new->q2.flags=new->z.flags=0;
new->z.reg=freturn(return_typ);
add_IC(new);
}
}
static char *get_string(void)
/* Liest Stringkonstante und liefert Wert als String (malloced) */
{
np tree;int l;char *p;
struct const_list *cl;
killsp();
if(ctok->type!=T_STRING) {error(74);return 0;}
tree=string_expression();
if(!tree||tree->flags!=STRING){
error(229);
return 0;
}
cl=tree->cl;l=0;
while(cl){
l++;
cl=cl->next;
}
p=mymalloc(l);
cl=tree->cl;l=0;
while(cl){
p[l]=zm2l(zc2zm(cl->other->val.vchar));
l++;
cl=cl->next;
}
if(tree) free_expression(tree);
killsp();
return p;
}
/* checks whether string is a valid vector type */
/* returns the dimension */
static int check_vect(char *s,char *base)
{
int i=strlen(base),dim;
if(strncmp(s,base,i)) return 0;
dim=s[i];
if(dim=='2'||dim=='3'||dim=='4'||dim=='8'){
if(s[i+1]==0)
return dim-'0';
else
return 0;
}
if(s[i]=='1'&&s[i+1]=='6'&&s[i+2]==0)
return 16;
return 0;
}
int settyp(int typnew, int typold)
/* Unterroutine fuer declaration_specifiers(). */
{
if(DEBUG&2) printf("settyp: new=%d old=%d\n",typnew,typold);
if(typold==LONG&&typnew==FLOAT){ error(203); return DOUBLE;}
if(typold==LONG&&typnew==DOUBLE) return LDOUBLE;
if(c99&&typold==LONG&&typnew==LONG) return LLONG;
if(typold!=0&&typnew!=INT){error(47);return(typnew);}
if(typold==0&&typnew==INT) return(INT);
if(typold==0) return(typnew);
if(typold==SHORT||typold==LONG||typold==LLONG) return(typold);
error(48);
return(typnew);
}
#define dsc if(storage_class) error(49); if(typ||type_qualifiers) error(50)
#define XSIGNED 16384
#ifdef HAVE_MISRA
/* removed */
#endif
struct Typ *declaration_specifiers(void)
/* Erzeugt neuen Typ und gibt Zeiger darauf zurueck, */
/* parst z.B. unsigned int, struct bla etc. */
{
int typ=0,type_qualifiers=0,notdone,storage_class,hard_reg,have_inline;
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
#endif
char *imerk,sident[MAXI],sbuff[MAXI],*attr=0,*vattr=0;
struct Typ *new=new_typ(),*t,*ts;
struct struct_declaration *ssd;
struct struct_list (*sl)[];
size_t slsz;
struct Var *v;
int dim;
#ifdef HAVE_TARGET_ATTRIBUTES
unsigned long tattr=0;
#endif
storage_class=hard_reg=have_inline=0;
do{
killsp();notdone=0;
if(ctok->type==NAME){
if(!strcmp("struct",ctok->name)||!strcmp("union",ctok->name)||(ecpp&&!strcmp("class",ctok->name))){
if(!strcmp("struct",ctok->name)) notdone=STRUCT;
if(!strcmp("union",ctok->name)) {
notdone=UNION;
#ifdef HAVE_MISRA
/* removed */
#endif
}
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
next_token();
killsp();
if(ctok->type!=LBRA){
cpbez(sident,1);
next_token();
killsp();
ssd=find_struct(sident,0);
#ifdef HAVE_MISRA
/* removed */
#endif
if(ssd&&ctok->type==LBRA&&find_struct(sident,nesting)&&ssd->count>0) error(13,sident);
if(!ssd||((ctok->type==LBRA||ctok->type==SEMIC)&&!find_struct(sident,nesting))){
typ=settyp(notdone,typ);
ssd=mymalloc(sizeof(*ssd));
ssd->count=0;
new->exact=ssd=add_sd(ssd,notdone);
if(!ecpp)add_struct_identifier(sident,ssd);
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
#endif
}else{
new->exact=ssd;
typ=settyp(new->flags=notdone,typ);
}
}else{
*sident=0;
typ=settyp(notdone,typ);
ssd=mymalloc(sizeof(*ssd));
ssd->count=0;
new->exact=ssd=add_sd(ssd,notdone);
}
if(ssd->typ!=notdone) error(230,sident);
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
if(ctok->type==LBRA){
int bfoffset,bfsize,flex_array=0,cbfo=0;
zmax off=l2zm(0L);
next_token();
killsp();
slsz=SLSIZE;
imerk=ident;
sl=mymalloc(slsz*sizeof(struct struct_list));
ssd->count=0;
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
ts=declaration_specifiers();
while(ctok->type!=RBRA&&ts){
if(flex_array) error(231);
ident=sbuff;
t=declarator(clone_typ(ts));
killsp();
bfsize=bfoffset=-1;
if(ctok->type==T_COLON){
np tree;
if((ts->flags&NQ)!=INT) {
error(51);
#ifdef HAVE_MISRA
/* removed */
#endif
}
next_token();killsp();tree=assignment_expression();
if(type_expression(tree)){
int tsize;
if(tree->flags!=CEXPR) error(52);
if(!ISINT(tree->ntyp->flags)) error(52);
eval_const(&tree->val,tree->ntyp->flags);
bfsize=(int)zm2l(vmax);
tsize=(int)zm2l(zmmult(sizetab[t->flags&NQ],char_bit));
if(bfsize<0||bfsize>tsize||(bfsize==0&&*ident)){
error(332);bfsize=1;
}
if(bfsize+cbfo>tsize){
bfoffset=cbfo=0;
}else{
bfoffset=cbfo;
}
if(bfsize!=0)
cbfo+=bfsize;
else
cbfo=0;
}
#ifdef HAVE_MISRA
/* removed */
/* removed */
/* removed */
#endif
if(tree) free_expression(tree);
}else{
if(!ecpp&&*ident==0) error(53);
cbfo=0;
}
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
if(type_uncomplete(t)){
if(!c99||notdone!=STRUCT||flex_array||(t->flags&NQ)!=ARRAY||type_uncomplete(t->next)){
error(14,sbuff);
freetyp(t);
break;
}else{
flex_array=1;
}
}
if(ISARRAY(t->flags)&&t->dsize){
error(352,sbuff);
}
if(ISFUNC(t->flags)){
if(!ecpp){
error(15,sbuff);
}
}
if(*ident!=0){
int i=ssd->count;
while(--i>=0)
if(!strcmp((*sl)[i].identifier,ident))
error(16,ident);
}
#ifdef HAVE_MISRA
/* removed */
#endif
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
(*sl)[ssd->count].bfoffset=bfoffset;
(*sl)[ssd->count].bfsize=bfsize;
(*sl)[ssd->count].styp=t;
if(!ecpp) (*sl)[ssd->count].identifier=add_identifier(ident,strlen(ident));
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
#endif
if(pack_align>0&&pack_align<falign(t))
(*sl)[ssd->count].align=pack_align;
else
(*sl)[ssd->count].align=falign(t);
{
zmax m,al=(*sl)[ssd->count].align;
zmax sz=szof(t);
m=off;
if((zmeqto(al,l2zm(0L))||zmeqto(sz,l2zm(0L)))&&!flex_array){
if (!ecpp){
error(316,ident);
}
}else{
off=zmmult(zmdiv(zmadd(off,zmsub(al,l2zm(1L))),al),al);
if(!zmeqto(m,off)) error(306,ident);
if(!flex_array){
m=zmmult(zmdiv(zmadd(off,zmsub(sz,l2zm(1L))),sz),sz);
if(!zmeqto(m,off)) error(307,ident);
off=zmadd(off,sz);
}
}
}
ssd->count++;
if(ssd->count>=slsz-1){
slsz+=SLSIZE;
sl=myrealloc(sl,slsz*sizeof(struct struct_list));
}
killsp();
if(ctok->type==COMMA) {next_token();killsp();continue;}
if(ctok->type!=SEMIC) error(54); else next_token();
killsp();
#ifdef HAVE_ECPP
/* removed */
#endif
if(ctok->type!=RBRA){
if(ts) freetyp(ts);
ts=declaration_specifiers();killsp();
}
}
if(ts) freetyp(ts);
if(ssd->count==0) error(55);
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
ident=imerk;
add_sl(ssd,sl);
free(sl);
if(ctok->type!=RBRA) error(56); else next_token();
new->flags=notdone|type_qualifiers;
}
#ifdef HAVE_ECPP
/* removed */
#endif
notdone=1;
}else if(!strcmp("enum",ctok->name)){
/* enumerations; die Namen werden leider noch ignoriert */
next_token();killsp();notdone=1;
if(ctok->type!=LBRA){cpbez(buff,1);next_token();killsp();}
if(ctok->type==LBRA){
/* mode: 0=start 1=first was not init 2=first was init 3=more init */
zmax val; struct Var *v; struct Typ *t;int mode=0;
val=l2zm(0L);
next_token();killsp();
while(ctok->type!=RBRA){
cpbez(sident,1);next_token();killsp();
if(*sident==0) {error(56);break;}
t=new_typ();
t->flags=CONST|INT;
if(find_var(sident,nesting)) error(17,sident);
v=add_var(sident,t,AUTO,0); /* AUTO hier klug? */
if(ctok->type==ASGN){
if(mode==2) mode=3;
if(mode==0) mode=2;
#ifdef HAVE_MISRA /* MISRA Rule 9.3 checking */
/* removed */
#endif
next_token();killsp();
v->clist=initialization(v->vtyp,0,0,0,0,0);
val=zi2zm(v->clist->val.vint);killsp();
}else{
if(mode==0) mode=1;
#ifdef HAVE_MISRA /* MISRA Rule 9.3 checking */
/* removed */
#endif
v->clist=mymalloc(CLS);
v->clist->val.vint=zm2zi(val);
v->clist->next=v->clist->other=0;
v->clist->tree=0;
}
vmax=l2zm(1L);val=zmadd(val,vmax);
v->vtyp->flags=CONST|ENUM;
if(ctok->type!=RBRA&&ctok->type!=COMMA) {error(56);break;}
if(ctok->type==COMMA) next_token();
killsp();
if(ctok->type==RBRA) {next_token(); break;}
}
}
killsp();
typ=settyp(INT,typ);
}else if(!strcmp("__readsmem",ctok->name)||!strcmp("__writesmem",ctok->name)){
enum {READS,WRITES} op;
char *imerk,tbuf[MAXI];
struct Typ *tmp;
if(!strcmp("__readsmem",ctok->name))
op=READS;
else
op=WRITES;
next_token();killsp();
if(ctok->type==LPAR) next_token(); else error(151);
imerk=ident;ident=tbuf;
tmp=declarator(declaration_specifiers());
ident=imerk;
if(tmp){
if(vattr)
vattr=myrealloc(vattr,strlen(vattr)+25);
else{
vattr=mymalloc(25);
vattr[0]=0;
}
sprintf(vattr+strlen(vattr),";%s(%d)",op==READS?"readmem":"writemem",tmp->flags);
}
killsp();
if(ctok->type==RPAR) next_token(); else error(59);
killsp();
notdone=1;
}else if(!strcmp("void",ctok->name)){
next_token();
typ=settyp(VOID,typ);notdone=1;
}else if(!strcmp("char",ctok->name)){
#ifdef HAVE_MISRA
/* removed */
/* removed */
#endif
next_token();
typ=settyp(CHAR,typ);
notdone=1;
if(default_unsigned&&!(type_qualifiers&XSIGNED))
type_qualifiers|=UNSIGNED;
}else if(!strcmp("short",ctok->name)){
#ifdef HAVE_MISRA
/* removed */
#endif
next_token();
typ=settyp(SHORT,typ);notdone=1;
}else if(!strcmp("int",ctok->name)){
#ifdef HAVE_MISRA
/* removed */
#endif
next_token();
typ=settyp(INT,typ);notdone=1;
}else if(!strcmp("long",ctok->name)){
#ifdef HAVE_MISRA
/* removed */
#endif
next_token();
typ=settyp(LONG,typ);notdone=1;
}else if(!strcmp("float",ctok->name)){
#ifdef HAVE_MISRA
/* removed */
#endif
next_token();
typ=settyp(FLOAT,typ);notdone=1;
}else if(!strcmp("double",ctok->name)){
#ifdef HAVE_MISRA
/* removed */
#endif
next_token();
typ=settyp(DOUBLE,typ);notdone=1;
}else if(!strcmp("const",ctok->name)){
next_token();
if(type_qualifiers&CONST) error(58);
type_qualifiers|=CONST;notdone=1;
}else if(!strcmp("volatile",ctok->name)){
next_token();
if(type_qualifiers&VOLATILE) error(58);
type_qualifiers|=VOLATILE;notdone=1;
}else if(opencl&&(dim=check_vect(ctok->name,"bool"))){
next_token();
typ=settyp(VECBOOL+dim-1,typ);
notdone=1;
}else if(opencl&&(dim=check_vect(ctok->name,"char"))){
next_token();
typ=settyp(VECCHAR+dim-1,typ);
notdone=1;
}else if(opencl&&(dim=check_vect(ctok->name,"uchar"))){
next_token();
typ=settyp((VECCHAR+dim-1)|UNSIGNED,typ);
notdone=1;
}else if(opencl&&(dim=check_vect(ctok->name,"short"))){
next_token();
typ=settyp(VECSHORT+dim-1,typ);
notdone=1;
}else if(opencl&&(dim=check_vect(ctok->name,"ushort"))){
next_token();
typ=settyp((VECSHORT+dim-1)|UNSIGNED,typ);
notdone=1;
}else if(opencl&&(dim=check_vect(ctok->name,"int"))){
next_token();
typ=settyp(VECINT+dim-1,typ);
notdone=1;
}else if(opencl&&(dim=check_vect(ctok->name,"uint"))){
next_token();
typ=settyp((VECINT+dim-1)|UNSIGNED,typ);
notdone=1;
}else if(opencl&&(dim=check_vect(ctok->name,"long"))){
next_token();
typ=settyp(VECLONG+dim-1,typ);
notdone=1;
}else if(opencl&&(dim=check_vect(ctok->name,"ulong"))){
next_token();
typ=settyp((VECLONG+dim-1)|UNSIGNED,typ);
notdone=1;
}else if(opencl&&(dim=check_vect(ctok->name,"float"))){
next_token();
typ=settyp(VECFLOAT+dim-1,typ);
notdone=1;
#if 0
}else if(c99&&!strcmp("restrict",ctok->name)){
next_token();
if(type_qualifiers&RESTRICT) error(58);
type_qualifiers|=RESTRICT;notdone=1;
#endif
}else if(!strcmp("unsigned",ctok->name)){
next_token();
if(type_qualifiers&(XSIGNED|UNSIGNED)) error(58);
notdone=1;type_qualifiers|=UNSIGNED;
}else if(!strcmp("signed",ctok->name)){
next_token();
if(type_qualifiers&(XSIGNED|UNSIGNED)) error(58);
notdone=1;type_qualifiers|=XSIGNED;
}else if(!strcmp("auto",ctok->name)){
next_token();
dsc;storage_class=AUTO;notdone=1;
}else if(!strcmp("register",ctok->name)){
#ifdef HAVE_MISRA
/* removed */
#endif
next_token();
dsc;storage_class=REGISTER;notdone=1;
}else if(!strcmp("static",ctok->name)){
next_token();
dsc;storage_class=STATIC;notdone=1;
#ifdef HAVE_ECPP
/* removed */
#endif
}else if(!strcmp("extern",ctok->name)){
next_token();
dsc;storage_class=EXTERN;notdone=1;
}else if(!strcmp("typedef",ctok->name)){
next_token();
dsc;storage_class=TYPEDEF;notdone=1;
}else if(c99&&!strcmp("inline",ctok->name)){
next_token();
have_inline=1;notdone=1;
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
}else if(/*!(c_flags[7]&USEDFLAG)&&*/!strcmp("__reg",ctok->name)){
char *d;
next_token();killsp();
if(ctok->type==LPAR) next_token(); else error(151);
killsp();
if(d=get_string()){
for(hard_reg=1;hard_reg<=MAXR;hard_reg++){
if(!strcmp(d,regnames[hard_reg])) break;
}
if(hard_reg>MAXR){ hard_reg=0;error(220,d);}
notdone=1;
free(d);
}
killsp();
if(ctok->type==RPAR) next_token(); else error(59);
killsp();
}else if(/*!(c_flags[7]&USEDFLAG)&&*/!strcmp("__attr",ctok->name)){
char *d;
next_token();killsp();
if(ctok->type==LPAR) next_token(); else error(151);
killsp();
if(d=get_string()){
if(!attr){
attr=d;
}else{
attr=myrealloc(attr,strlen(attr)+strlen(d)+2);
strcat(attr,";");
strcat(attr,d);
free(d);
}
notdone=1;
}
killsp();
if(ctok->type==RPAR) next_token(); else error(59);
killsp();
}else if(/*!(c_flags[7]&USEDFLAG)&&*/!strcmp("__vattr",ctok->name)){
char *d;
next_token();killsp();
if(ctok->type==LPAR) next_token(); else error(151);
killsp();
if(d=get_string()){
if(!vattr){
vattr=d;
}else{
vattr=myrealloc(vattr,strlen(vattr)+strlen(d)+2);
strcat(vattr,";");
strcat(vattr,d);
free(d);
}
notdone=1;
}
killsp();
if(ctok->type==RPAR) next_token(); else error(59);
killsp();
}else{
#ifdef HAVE_TARGET_ATTRIBUTES
int i;
for(i=0;g_attr_name[i];i++){
if(!strcmp(g_attr_name[i],ctok->name)){
if(tattr&(1L<<i)) error(227,ctok->name);
tattr|=(1L<<i);
next_token();
notdone=1;break;
}
}
#endif
if(!notdone&&typ==0&&!(type_qualifiers&(XSIGNED|UNSIGNED))){
v=find_var(ctok->name,0);
if(v&&v->storage_class==TYPEDEF){
free(new);
new=clone_typ(v->vtyp);
typ=settyp(new->flags,typ);
notdone=1;
next_token();
}
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
}
}
}
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
if(DEBUG&2) printf("typ:%d\n",typ);
}while(notdone);
killsp();
return_sc=storage_class;
return_reg=hard_reg;
return_vattr=vattr;
return_inline=have_inline;
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
#endif
#ifdef HAVE_TARGET_ATTRIBUTES
return_tattr=tattr;
#endif
if(typ==0){
if(storage_class==0&&type_qualifiers==0&&!hard_reg){
free(new);
return 0;
}
#ifdef HAVE_MISRA
/* removed */
#endif
typ=INT;
}
if(type_qualifiers&(XSIGNED|UNSIGNED))
if(!ISINT(typ))
error(58);
new->flags=typ|type_qualifiers;
new->attr=attr;
return new;
}
struct Typ *declarator(struct Typ *a)
/* Erzeugt einen neuen Typ, auf Basis des Typs a. */
/* a wird hiermit verkettet. */
{
struct Typ *t;
killsp();*ident=0;
t=direct_declarator(pointer(a));
if(!a)
{if(t) freetyp(t);return 0;}
#ifdef HAVE_ECPP
/* removed */
#endif
#ifdef HAVE_EXT_TYPES
conv_typ(t);
#endif
return t;
}
struct Typ *pointer(struct Typ *a)
/* Unterroutine fuer declarator(), behandelt Zeiger auf Typ. */
{
struct Typ *t;char *attr;int notdone;
if(!a) return(0);
killsp();
while(ctok->type==STAR){
next_token();
t=new_typ();
t->flags=POINTER_TYPE(a);
t->next=a;
attr=0;
a=t;
do{
killsp();
notdone=0;
if(ctok->type==NAME&&!strcmp("const",ctok->name)){
a->flags|=CONST;
notdone=1;
next_token();
}else if(ctok->type==NAME&&!strcmp("volatile",ctok->name)){
a->flags|=VOLATILE;
notdone=1;
next_token();
}else if(c99&&ctok->type==NAME&&!strcmp("restrict",ctok->name)){
a->flags|=RESTRICT;
notdone=1;
next_token();
}else if(ctok->type==NAME&&!strcmp("__attr",ctok->name)){
char *d;
next_token();
killsp();
if(ctok->type==LPAR) next_token(); else error(151);
killsp();
if(d=get_string()){
if(!attr){
attr=d;
}else{
attr=myrealloc(attr,strlen(attr)+strlen(d)+2);
strcat(attr,";");
strcat(attr,d);
free(d);
}
notdone=1;
}
killsp();
if(ctok->type==RPAR) next_token(); else error(59);
killsp();
}
}while(notdone);
a->attr=attr;
}
return a;
}
struct Typ *direct_declarator(struct Typ *a)
/* Unterroutine zu declarator() */
/* behandelt [],(funkt),(dekl). */
{
struct Typ *rek=0,*merk,*p,*t=0,*first,*last=0;
struct struct_declaration *fsd;
struct struct_list (*sl)[];
size_t slsz;char *imerk;
char fbuff[MAXI];
killsp();
if(ctok->type!=NAME&&ctok->type!=LPAR&&ctok->type!=LBRK)
return a;
if(ctok->type==NAME){
cpbez(ident,1);
next_token();
if(!a) return(0);
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
}
else if(ctok->type==LPAR&&a){
/* Rekursion */
struct token mtok;
copy_token(&mtok,ctok);
next_token(); killsp();
if(ctok->type!=RPAR&&*ident==0&&!declaration(0)){
merk=a;
rek=declarator(a);
if(ctok->type!=RPAR) error(59); else next_token();
}else
push_token(&mtok);
free(mtok.name);
}
if(!a)return(0);
killsp();
while(ctok->type==LBRK||ctok->type==LPAR){
if(ctok->type==LBRK){
next_token();
killsp();
p=new_typ();
p->flags=ARRAY;
p->next=0;
if(ctok->type==RBRK){
p->size=l2zm(0L);
}else{
np tree;
tree=expression();
if(!type_expression(tree)){
/* error("incorrect constant expression");*/
}else{
if(tree->sidefx&&!c99) error(60);
if(tree->flags!=CEXPR||!ISINT(tree->ntyp->flags)){
if(!c99)
error(19);
else{
struct Typ *st;struct IC *new;
st=new_typ();
st->flags=HAVE_INT_SIZET?(UNSIGNED|INT):(UNSIGNED|LONG);
p->dsize=add_tmp_var(st);
gen_IC(tree,0,0);
convert(tree,st->flags);
new=new_IC();
new->code=ASSIGN;
new->typf=st->flags;
new->q1=tree->o;
new->z.flags=VAR;
new->z.v=p->dsize;
new->z.val.vmax=l2zm(0L);
new->q2.val.vmax=szof(st);
add_IC(new);
}
}else{
eval_constn(tree);
p->size=vmax;
if(zmleq(p->size,l2zm(0L))) {error(61);p->size=l2zm(1L);}
}
}
free_expression(tree);
}
if(ctok->type!=RBRK) error(62); else next_token();
if(last){
last->next=p;
last=p;
}else{
first=last=p;
}
}
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
#endif
if(ctok->type==LPAR){
int komma,firstparm,oldstyle=0;
#ifdef HAVE_REGPARMS
struct reg_handle reg_handle=empty_reg_handle;
struct Typ rpointer={0};
if(!ffreturn(a)&&(a->flags&NQ)!=VOID){
rpointer.flags=POINTER_TYPE(a);
rpointer.next=a;
reg_parm(®_handle,&rpointer,0,0);
}
#endif
#ifdef HAVE_MISRA
/* removed */
/* removed */
#endif
next_token();
killsp();
#ifdef HAVE_MISRA
/* removed */
#endif
fsd=mymalloc(sizeof(*fsd));
slsz=SLSIZE;
sl=mymalloc(sizeof(struct struct_list)*slsz);
fsd->count=0;
imerk=ident;komma=0;
enter_block();
firstparm=1;
while(ctok->type!=RPAR&&ctok->type!=MDOTS){
int hard_reg;
#ifdef HAVE_ECPP
/* removed */
#endif
if(!firstparm&&!komma) error(57);
komma=firstparm=0;
ident=fbuff;*fbuff=0;
t=declaration_specifiers();
hard_reg=return_reg;
t=declarator(t);
if(!t){
oldstyle=1;
if(*ident==0) {error(20);freetyp(t);continue;}
}
if(fsd->count){
if((t&&!(*sl)[fsd->count-1].styp)||
(!t&&(*sl)[fsd->count-1].styp))
error(63);
}
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
if(!return_sc) return_sc=AUTO;
if(return_sc!=AUTO&&return_sc!=REGISTER)
{error(21);return_sc=AUTO;}
(*sl)[fsd->count].styp=t;
(*sl)[fsd->count].storage_class=return_sc;
{
int m=nesting;
nesting=0;
(*sl)[fsd->count].identifier=add_identifier(ident,strlen(ident));
nesting=m;
}
if(t){
if(((*sl)[fsd->count].styp->flags&NQ)==VOID&&fsd->count!=0)
error(22);
/* Arrays in Zeiger umwandeln */
if(ISARRAY((*sl)[fsd->count].styp->flags))
(*sl)[fsd->count].styp->flags=POINTER_TYPE((*sl)[fsd->count].styp->next);
/* Funktionen in Zeiger auf Funktionen umwandeln */
if(ISFUNC((*sl)[fsd->count].styp->flags)){
struct Typ *new;
new=new_typ();
new->next=(*sl)[fsd->count].styp;
new->flags=POINTER_TYPE(new->next);
(*sl)[fsd->count].styp=new;
}
}
if(hard_reg&®ok(hard_reg,t->flags,-1)<=0) error(217,regnames[hard_reg]);
#ifdef HAVE_REGPARMS
if(t) (*sl)[fsd->count].reg=reg_parm(®_handle,t,0,0);
if(hard_reg) (*sl)[fsd->count].reg=hard_reg;
#else
(*sl)[fsd->count].reg=hard_reg;
#endif
fsd->count++;
if(fsd->count>=slsz-2){ /* eins Reserve fuer VOID */
slsz+=SLSIZE;
sl=myrealloc(sl,slsz*sizeof(struct struct_list));
}
killsp(); /* Hier Syntaxpruefung strenger machen */
if(ctok->type==COMMA) {next_token();komma=1; killsp();}
}
ident=imerk;
#ifdef HAVE_MISRA
/* removed */
#endif
if(ctok->type!=MDOTS||!komma){
int ecpp_addvoid=0;
#ifdef HAVE_ECPP
/* removed */
#endif
if(ecpp_addvoid||(!ecpp&&fsd->count>0&&(!(*sl)[fsd->count-1].styp||((*sl)[fsd->count-1].styp->flags&NQ)!=VOID))){
(*sl)[fsd->count].styp=new_typ();
(*sl)[fsd->count].styp->flags=VOID;
(*sl)[fsd->count].styp->next=0;
(*sl)[fsd->count].identifier=empty;
#ifdef HAVE_ECPP
/* removed */
#endif
fsd->count++;
}
if(ecpp&&ctok->type==MDOTS){next_token();killsp();}
}else if(komma){
next_token();komma=0;
if(oldstyle) error(221);
}
p=new_typ();
p->flags=FUNKT;
{
int m=nesting;
nesting=0;
p->exact=add_sd(fsd,FUNKT);
add_sl(fsd,sl);
free(sl);
nesting=m;
}
killsp();
if(komma) error(59);
if(ctok->type!=RPAR) error(59); else next_token();
killsp();
if(ctok->type==COMMA||ctok->type==SEMIC||ctok->type==RPAR||ctok->type==ASGN)
leave_block();
if(last){
last->next=p;
last=p;
}else{
first=last=p;
}
}
killsp();
}
if(last){last->next=a;last=a;a=first;}
if(rek!=0&&rek!=merk){
/* Zweite Liste anhaengen */
p=rek;
while(p->next!=merk) p=p->next;
if(p) p->next=a; else ierror(0);
return rek;
}
return a;
}
int declaration(int offset)
/* Testet, ob eine Typangabe kommt. Wenn offset!=0 ist, */
/* muss s auf '(' zeigen und es wird getestet, ob nach der */
/* Klammer eine Typangabe kommt. */
/* In jedem Fall zeigt s danach wieder auf dieselbe Stelle */
/* im Source. */
{
struct Var *v;struct token mtok;
int fl=0;
if(offset){
copy_token(&mtok,ctok);
next_token();
killsp();
}
if(ctok->type==NAME){
if(!strcmp("auto",ctok->name)) fl=1;
else if(!strcmp("char",ctok->name)) fl=1;
else if(!strcmp("const",ctok->name)) fl=1;
else if(!strcmp("double",ctok->name)) fl=1;
else if(!strcmp("enum",ctok->name)) fl=1;
else if(!strcmp("extern",ctok->name)) fl=1;
else if(!strcmp("float",ctok->name)) fl=1;
else if(!strcmp("int",ctok->name)) fl=1;
else if(!strcmp("long",ctok->name)) fl=1;
else if(!strcmp("register",ctok->name)) fl=1;
else if(c99&&!strcmp("restrict",ctok->name)) fl=1;
else if(!strcmp("short",ctok->name)) fl=1;
else if(!strcmp("signed",ctok->name)) fl=1;
else if(!strcmp("static",ctok->name)) fl=1;
else if(!strcmp("struct",ctok->name)) fl=1;
else if(!strcmp("typedef",ctok->name)) fl=1;
else if(!strcmp("union",ctok->name)) fl=1;
else if(!strcmp("unsigned",ctok->name)) fl=1;
else if(!strcmp("void",ctok->name)) fl=1;
else if(!strcmp("volatile",ctok->name)) fl=1;
else if(/*!(c_flags[7]&USEDFLAG)&&*/!strcmp("__reg",ctok->name)) fl=1;
else if(/*!(c_flags[7]&USEDFLAG)&&*/!strcmp("__attr",ctok->name)) fl=1;
else if(/*!(c_flags[7]&USEDFLAG)&&*/!strcmp("__vattr",ctok->name)) fl=1;
else if(/*!(c_flags[7]&USEDFLAG)&&*/!strcmp("__readsmem",ctok->name)) fl=1;
else if(/*!(c_flags[7]&USEDFLAG)&&*/!strcmp("__writesmem",ctok->name)) fl=1;
else{
v=find_var(ctok->name,0);
if(v&&v->storage_class==TYPEDEF) fl=1;
}
}
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
if(offset){
push_token(&mtok);
free(mtok.name);
}
return fl;
}
void init_sl(struct struct_list *sl){
if(!sl){ierror(0);return;}
sl->identifier=0;
sl->styp=0;
sl->align=0;
sl->bfoffset=-1;
sl->bfsize=-1;
sl->reg=0;
sl->storage_class=0;
#ifdef HAVE_ECPP
/* removed */
#endif
}
void add_sl(struct struct_declaration *sd,struct struct_list (*sl)[])
/* Fuegt ein struct_list-Array in eine struct_declaration ein. */
/* Das Array muss mind. sd->count Elements haben und wird kopiert. */
{
size_t sz=sizeof(struct struct_list)*sd->count;
sd->sl=mymalloc(sz);
memcpy(sd->sl,sl,sz);
}
struct struct_declaration *add_sd(struct struct_declaration *new,int typ)
/* Fuegt eine struct Declaration in Liste ein. */
{
new->next=0;
new->label=0;
new->typ=typ;
new->identifier=0;
new->tunit=last_tunit;
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
if(first_sd[nesting]==0){
first_sd[nesting]=last_sd[nesting]=new;
}else{
last_sd[nesting]->next=new;
last_sd[nesting]=new;
}
return new;
}
void free_sd(struct struct_declaration *p)
/* Gibt eine struct_declaration-List inkl. struct_lists und */
/* allen Typen jeder struct_list frei, nicht aber identifier. */
{
int i;struct struct_declaration *merk;
while(p){
merk=p->next;
if(p->sl){
for(i=0;i<p->count;i++){
if((*p->sl)[i].styp) freetyp((*p->sl)[i].styp);
}
if(p->count>0) free(p->sl);
}
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
#endif
free(p);
p=merk;
}
}
char *add_identifier(char *identifier,int length)
/* Kopiert identifier an sicheren Ort, der spaeter zentral */
/* freigegeben werden kann. */
/* Sollte noch einbauen, dass ueberprueft wird, ob schon */
/* vorhanden und dann nicht zweimal speichern. */
{
struct identifier_list *new;
if((*identifier==0&&length==0)||identifier==empty) return(empty);
new=mymalloc(sizeof(struct identifier_list));
new->identifier=mymalloc(length+1);
memcpy(new->identifier,identifier,length+1);
new->next=0;new->length=length;
if(last_ilist[nesting]){
last_ilist[nesting]->next=new;
last_ilist[nesting]=new;
}else{
last_ilist[nesting]=first_ilist[nesting]=new;
}
return(new->identifier);
}
void free_ilist(struct identifier_list *p)
/* Gibt eine verkettete identifier_liste und saemtliche darin */
/* gespeicherten Identifier frei. */
{
struct identifier_list *merk;
while(p){
merk=p->next;
if(p->identifier) free(p->identifier);
free(p);
p=merk;
}
}
int type_uncomplete(struct Typ *p)
/* Testet, ob Typ unvollstaendig ist. Momentan gelten nur */
/* unvollstaendige Strukturen und Arrays von solchen als */
/* unvollstaendig, aber keine Zeiger oder Funktionen darauf. */
{
struct struct_declaration *sd;
if(!p){ierror(0);return(0);}
if(ISSTRUCT(p->flags)||ISUNION(p->flags))
if(p->exact->count<=0) return 1;
if(ISARRAY(p->flags)){
if(!p->dsize&&zmleq(p->size,l2zm(0L))) return 1;
if(!p->next) ierror(0);
if(type_uncomplete(p->next)) return 1;
}
return 0;
}
void add_struct_identifier(char *identifier,struct struct_declaration *sd)
/* Erzeugt neuen struct_identifier, fuegt ihn in Liste an und */
/* vervollstaendigt unvollstaendige Typen dieser Struktur. */
{
struct struct_identifier *new;
/* struct Typ *t;*/
if(DEBUG&1) printf("add_si %s (nesting=%d)->%p\n",identifier,nesting,(void *)sd);
#ifdef HAVE_MISRA
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
new=mymalloc(sizeof(struct struct_identifier));
new->identifier=add_identifier(identifier,strlen(identifier));
new->sd=sd;
new->next=0;
if(first_si[nesting]==0){
first_si[nesting]=new;last_si[nesting]=new;
}else{
last_si[nesting]->next=new;last_si[nesting]=new;
}
sd->identifier=new->identifier;
}
void free_si(struct struct_identifier *p)
/* Gibt eine struct_identifier-Liste frei, aber nicht die */
/* identifiers und struct_declarations. */
{
struct struct_identifier *merk;
while(p){
merk=p->next;
p->sd->identifier="<prototype-only>";
free(p);
p=merk;
}
}
struct struct_declaration *find_struct(char *identifier,int endnesting)
/* Sucht angegebene Strukturdefinition und liefert */
/* entsprechende struct_declaration. */
{
struct struct_identifier *si; int i,l;
if(misracheck) l=strlen(identifier);
for(i=nesting;i>=endnesting;i--){
si=first_si[i];
while(si){
if(!strcmp(si->identifier,identifier)){
if(DEBUG&1) printf("found struct tag <%s> at nesting %d->%p\n",identifier,i,(void *)si->sd);
return(si->sd);
}
#ifdef HAVE_MISRA
/* removed */
/* removed */
/* removed */
/* removed */
#endif
si=si->next;
}
}
if(DEBUG&1) printf("didn't find struct tag <%s>\n",identifier);
return(0);
}
/* generate code to create a variable-lenght-array */
static void create_allocvl(struct Var *v)
{
np tree,ds;
struct IC *new;struct Var *fv;
/* check if we got a frame-pointer */
if(FPVLA_REG&&!regsa[FPVLA_REG]){
if(regused[FPVLA_REG])
ierror(0);
else
regsa[FPVLA_REG]=regscratch[FPVLA_REG]=regused[FPVLA_REG]=1;
}
/* if this is the first vla in this block, save old sp */
if(!block_vla[nesting]){
/* declare function - may be done by the backend, if necessary */
if(!(fv=find_ext_var("__oldvlasp"))){
struct Typ *t;
static struct Typ voidt={VOID};
struct struct_declaration *sd=mymalloc(sizeof(*sd));
t=new_typ();
t->flags=FUNKT;
t->next=new_typ();
t->next->flags=POINTER_TYPE(&voidt);
t->next->next=clone_typ(&voidt);
sd->count=0;
t->exact=add_sd(sd,FUNKT);
fv=add_var("__oldvlasp",t,EXTERN,0);
fv->fi=new_fi();
fv->fi->flags|=(ALL_USES|ALL_MODS);
fv->fi->inline_asm=mystrdup(OLDSPVLA_INLINEASM);
}
block_vla[nesting]=add_tmp_var(clone_typ(fv->vtyp->next));
tree=gen_libcall("__oldvlasp",0,0,0,0);
new=new_IC();
new->code=ASSIGN;
new->z.flags=VAR;
new->z.v=block_vla[nesting];
new->z.val.vmax=l2zm(0L);
new->q1=tree->o;
new->q2.flags=0;
new->typf=block_vla[nesting]->vtyp->flags;
new->q2.val.vmax=sizetab[new->typf];
add_IC(new);
free_expression(tree);
}
/* make room on the stack */
ds=new_node();
ds->flags=IDENTIFIER;
ds->identifier=empty;
ds->dsize=vlength_szof(v->vtyp);
ds->val.vmax=l2zm(0L);
ds->ntyp=clone_typ(ds->dsize->vtyp);
ds->o.flags=VAR;
ds->o.v=ds->dsize;
ds->o.val.vmax=l2zm(0L);
ds->left=ds->right=0;
if(!find_ext_var("__allocvla")){
/* declare function */
struct struct_declaration *sd=mymalloc(sizeof(*sd));
struct Typ *t=new_typ();
sd->count=1;
sd->sl=mymalloc(sizeof(struct struct_list));
(*sd->sl)[0].storage_class=AUTO;
(*sd->sl)[0].styp=clone_typ(ds->dsize->vtyp);
(*sd->sl)[0].reg=ALLOCVLA_REG;
t->flags=FUNKT;
t->exact=add_sd(sd,FUNKT);
t->next=new_typ();
t->next->flags=POINTER_TYPE(v->vtyp);
t->next->next=new_typ();
t->next->next->flags=v->vtyp->flags;
fv=add_var("__allocvla",t,EXTERN,0);
fv->fi=new_fi();
fv->fi->flags|=(ALL_USES|ALL_MODS);
fv->fi->inline_asm=mystrdup(ALLOCVLA_INLINEASM);
}
if(!type_expression(ds)) ierror(0);
tree=gen_libcall("__allocvla",ds,0,0,0);
new=new_IC();
new->code=ASSIGN;
new->z.flags=VAR;
new->z.v=v;
new->z.val.vmax=l2zm(0L);
new->q1=tree->o;
new->q2.flags=0;
new->typf=POINTER_TYPE(v->vtyp);
new->q2.val.vmax=sizetab[new->typf];
add_IC(new);
free_expression(tree);
vlas=1;
}
/* reset sp to remove variable-length-arrays */
void freevl(void)
{
np tree,ds;
struct Var *fv;
dontdelete=1; /* never remove them, otherwise, fix_vla_jump get confused */
if(!find_ext_var("__resetvlasp")){
struct struct_declaration *sd=mymalloc(sizeof(*sd));
struct Typ *t=new_typ();
sd->count=1;
sd->sl=mymalloc(sizeof(struct struct_list));
(*sd->sl)[0].storage_class=AUTO;
(*sd->sl)[0].styp=clone_typ(block_vla[nesting]->vtyp);
(*sd->sl)[0].reg=FREEVLA_REG;
t->flags=FUNKT;
t->exact=add_sd(sd,FUNKT);
t->next=new_typ();
t->next->flags=VOID;
fv=add_var("__resetvlasp",t,EXTERN,0);
fv->fi=new_fi();
fv->fi->flags|=(ALL_USES|ALL_MODS);
fv->fi->inline_asm=mystrdup(FREEVLA_INLINEASM);
}
if(nesting==1){
clear_main_ret();
gen_label(return_label);
did_return_label=1;
}
ds=new_node();
ds->flags=IDENTIFIER;
ds->identifier=empty;
ds->dsize=block_vla[nesting];
ds->val.vmax=l2zm(0L);
ds->ntyp=clone_typ(ds->dsize->vtyp);
ds->left=ds->right=0;
ds->o.flags=VAR;
ds->o.v=ds->dsize;
ds->o.val.vmax=l2zm(0L);
if(!type_expression(ds)) ierror(0);
tree=gen_libcall("__resetvlasp",ds,0,0,0);
free_expression(tree);
dontdelete=0;
}
void clearvl(void)
{
struct llist *p,*n;
struct vlaadjust_list *vl,*vn;
/* look for stack-adjusts that have to be removed */
vl=vlaadjusts[nesting];
while(vl){
int ln;
struct IC *ic=vl->branch;
if(ic){
ln=ic->typf;
if(ic->code!=BRA) ierror(0);
p=vladeflabels[nesting];
while(p){
if(p->label==ln) break;
p=p->next;
}
if(!p){
ic=ic->prev;
while(ic!=vl->first->prev){
if(!ic) ierror(0);
ic->code=NOP;
ic->q1.flags=ic->q2.flags=ic->z.flags=0;
ic=ic->prev;
}
}
}
vn=vl->next;
free(vl);
vl=vn;
}
freevl();
block_vla[nesting]=0;
p=vladeflabels[nesting];
while(p){
n=p->next;
free(p);
p=n;
}
p=vlajmplabels[nesting];
while(p){
n=p->next;
free(p);
p=n;
}
vladeflabels[nesting]=vlajmplabels[nesting]=0;
vlaadjusts[nesting]=0;
}
/* Handle a stack of stored sp variables when traversing an IC list; */
void vla_nesting(struct IC *p,struct Var **vn,int *nest)
{
if(p->code==CALL&&(p->q1.flags&(VAR|DREFOBJ))==VAR&&!strcmp(p->q1.v->identifier,"__oldvlasp")){
struct IC *p2=p->next;
while(p2&&(p2->code==ALLOCREG||p2->code==FREEREG)) p2=p2->next;
if(!p2||p2->code!=GETRETURN||(p2->z.flags&(VAR|DREFOBJ))!=VAR) ierror(0);
/*printf("found save sp to %p\n",p2->z.v);*/
vn[*nest]=p2->z.v;
(*nest)++;
vn[*nest]=0;
if(*nest>=MAXN) ierror(0);
return;
}
if(p->code==CALL&&(p->q1.flags&(VAR|DREFOBJ))==VAR&&!strcmp(p->q1.v->identifier,"__resetvlasp")){
/*printf("found reset\n");*/
if(*nest<=0) ierror(0);
(*nest)--;
return;
}
}
static int return_vla_nest;
static struct Var *return_last_vlasp;
/* Find the stack pointer that is needed when jumping to label lab */
struct Var *vla_find_sp(int lab)
{
struct IC *p;int nest=0;
static struct Var *vn[MAXN];
for(p=first_ic;p;p=p->next){
if(p->code==LABEL&&p->typf==lab){
return_vla_nest=nest;
return_last_vlasp=vn[nest];
if(nest<=0)
return 0;
else
return vn[nest-1];
}
vla_nesting(p,vn,&nest);
}
ierror(0);
}
void vla_jump_fix(void)
{
struct IC *p;int nest=0;
static struct Var *vn[MAXN],*savedsp;
if(DEBUG&1) printf("searching for vla-jump-fixes\n");
for(p=first_ic;p;p=p->next){
/*pric2(stdout,p);*/
if(p->code>=BEQ&&p->code<=BRA){
/*printf("jump found\n");*/
p->savedsp=0;
if(1/*nest>0*/){
/*printf("is in vla context!\n");*/
savedsp=vla_find_sp(p->typf);
if(return_vla_nest>nest||(nest>0&&return_vla_nest==nest&&savedsp!=vn[nest-1])){
err_ic=p;
error(351);
}else if(nest==0||savedsp==vn[nest-1]){
/*printf("jump within the same context\n");*/
}else{
if(vn[nest]){
if(DEBUG&1) printf("have to set sp to %p\n",return_last_vlasp);
p->savedsp=return_last_vlasp;
}else{
int ndiff=nest-return_vla_nest-1;
struct IC *p2;
/*printf("have to search oldsp ndiff=%d\n",ndiff);*/
for(p2=p->prev;p2;p2=p2->prev){
if(p2->code==CALL&&(p2->q1.flags&(VAR|DREFOBJ))==VAR&&!strcmp(p2->q1.v->identifier,"__oldvlasp")){
if(ndiff==0){
/*printf("found savesp\n");*/
p2=p2->next;
while(p2&&(p2->code==ALLOCREG||p2->code==FREEREG)) p2=p2->next;
if(!p2||p2->code!=GETRETURN) ierror(0);
if((p2->z.flags&(VAR|DREFOBJ))!=VAR) ierror(0);
/*printf("found oldsp %p\n",p2->z.v);*/
p->savedsp=p2->z.v;
break;
}
ndiff--;
}
if(p2->code==CALL&&(p2->q1.flags&(VAR|DREFOBJ))==VAR&&!strcmp(p2->q1.v->identifier,"__resetvlasp")){
ndiff++;
}
}
if(!p2) ierror(0);
}
}
}else{
/*printf("not in vla context\n");*/
}
}
vla_nesting(p,vn,&nest);
}
for(p=first_ic;p;p=p->next){
if(p->code>=BEQ&&p->code<=BRA){
if(p->savedsp){
struct IC *merkfic,*merklic,*newcode,*m,*new,*setr=0;
np ds,tree;
if(DEBUG&1) printf("generating sp-adjust\n");
merkfic=first_ic;merklic=last_ic;
first_ic=0;last_ic=0;
ds=new_node();
ds->flags=IDENTIFIER;
ds->identifier=empty;
ds->dsize=p->savedsp;
ds->val.vmax=l2zm(0L);
ds->ntyp=clone_typ(ds->dsize->vtyp);
ds->left=ds->right=0;
ds->o.flags=VAR;
ds->o.v=ds->dsize;
ds->o.val.vmax=l2zm(0L);
if(!type_expression(ds)) ierror(0);
tree=gen_libcall("__resetvlasp",ds,0,0,0);
free_expression(tree);
newcode=first_ic;
first_ic=merkfic;last_ic=merklic;
if(p->code==BRA){
/* check if the branch was preceded by a SETRETURN */
struct IC *p2=p->prev;
while(p2&&(p2->code==FREEREG||p2->code==ALLOCREG))
p2=p2->prev;
if(p2->code==SETRETURN&&p2->z.reg)
setr=p2;
}else{
new=new_IC();
new->typf=++label;
if(p->code==BEQ) new->code=BRA;
else if(p->code==BNE) new->code=BEQ;
else if(p->code==BLT) new->code=BGE;
else if(p->code==BGT) new->code=BLE;
else if(p->code==BLE) new->code=BGT;
else if(p->code==BGE) new->code=BLT;
insert_IC(p->prev,new);
}
while(newcode){
m=newcode->next;
insert_IC(p->prev,newcode);
newcode=m;
}
if(p->code!=BRA){
p->code=BRA;
new=new_IC();
new->code=LABEL;
new->typf=label;
insert_IC(p,new);
}
if(setr){
/* save the return value to save it from being overwritten */
/* could be optimized further */
struct Var *v;
if(ISSCALAR(setr->typf)){
static struct Typ t={0};
t.flags=setr->typf;
v=add_tmp_var(clone_typ(&t));
}else ierror(0);
new=new_IC();
*new=*setr;
new->q1.flags=VAR;
new->q1.v=v;
new->q1.val.vmax=l2zm(0L);
setr->z=new->q1;
setr->code=ASSIGN;
insert_IC(p->prev,new);
}
}
}
}
}
struct Var *add_tmp_var(struct Typ *t)
{
t->flags&=NU;
return add_var(empty,t,AUTO,0);
}
struct Var *add_var(char *identifier, struct Typ *t, int storage_class,struct const_list *clist)
/* Fuegt eine Variable mit Typ in die var_list ein. */
/* In der storage_class werden die Flags PARAMETER und evtl. */
/* OLDSTYLE und REGPARM erkannt. */
{
struct Var *new;int f;
struct struct_declaration *sd;
static zmax paroffset;
zmax al;
/*if(*identifier==0) return;*/ /* sollte woanders bemaekelt werden */
if(DEBUG&2) printf("add_var(): %s\n",identifier);
#ifdef HAVE_MISRA
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
if(ISFUNC(t->flags&NQ)&&(ISARRAY(t->next->flags)||ISFUNC(t->next->flags)))
error(25);
new=mymalloc(sizeof(struct Var));
if(!*identifier&&identifier!=empty) ierror(0);
new->clist=clist;
new->vtyp=t;
new->storage_class=storage_class&PLAIN_STORAGE_CLASS;
new->reg=0;
new->vattr=0;
new->next=0;
new->flags=0;
new->inr=0;
new->fi=0;
new->nesting=nesting;
new->filename=filename;
new->line=line;
new->dfilename=0;
new->dline=0;
new->description=0;
new->tunit=last_tunit;
#ifdef HAVE_TARGET_ATTRIBUTES
new->tattr=0;
#endif
/* if((storage_class&PLAIN_STORAGE_CLASS)==STATIC||(storage_class&PLAIN_STORAGE_CLASS)==EXTERN) new->flags=USEDASSOURCE|USEDASDEST;*/
if(DEBUG&2) printf("storage_class=%d\n",storage_class);
if(storage_class&PARAMETER) new->flags|=USEDASDEST;
if(storage_class®PARM){
new->flags|=REGPARM;
if(!(storage_class&DBLPUSH)){
if((storage_class&OLDSTYLE)&&(t->flags&NQ)==FLOAT)
new->flags|=CONVPARAMETER;
storage_class&=~PARAMETER;
}
}
if(DEBUG&2) printf("storage_class=%d\n",storage_class);
if(DEBUG&2) printf("max_offset=%ld\n",zm2l(max_offset));
if(is_vlength(t)&&storage_class!=AUTO&&storage_class!=REGISTER)
error(315);
if((storage_class&PLAIN_STORAGE_CLASS)==REGISTER) new->priority=registerpri; else new->priority=0;
if(/*nesting==0&&*/new->storage_class==EXTERN){
int m=nesting;
nesting=0;
new->identifier=add_identifier(identifier,strlen(identifier));
nesting=m;
if(last_ext){
last_ext->next=new;
last_ext=new;
}else{
first_ext=last_ext=new;
vl0=first_ext;
}
}else{
new->identifier=add_identifier(identifier,strlen(identifier));
if(last_var[nesting]){
new->offset=zmadd(last_var[nesting]->offset,szof(last_var[nesting]->vtyp));
last_var[nesting]->next=new;
last_var[nesting]=new;
}else{
new->offset=l2zm(0L);
paroffset=l2zm(0L);;
first_var[nesting]=last_var[nesting]=new;
if(nesting==0) vl1=new;
if(nesting==1) vl2=new;
}
}
f=t->flags&NQ;
if((storage_class&PLAIN_STORAGE_CLASS)==AUTO||(storage_class&PLAIN_STORAGE_CLASS)==REGISTER){
if(DEBUG&2) printf("auto\n");
al=falign(t);
if((c_flags_val[0].l&2)&&nesting==1&&!(storage_class&PARAMETER)){
new->offset=max_offset;
}else{
if(storage_class&PARAMETER){
new->offset=paroffset;
if(align_arguments)
new->offset=zmmult(zmdiv(zmadd(new->offset,zmsub(al,l2zm(1L))),al),al);
}else{
new->offset=local_offset[nesting];
new->offset=zmmult(zmdiv(zmadd(new->offset,zmsub(al,l2zm(1L))),al),al);
}
}
if(storage_class&PARAMETER){
new->offset=zmmult(zmdiv(zmadd(new->offset,zmsub(stackalign,l2zm(1L))),stackalign),stackalign);
if(ISINT(f)&&f<INT&&!short_push){
/* Integer-Erweiterungen fuer alle Funktionsparameter */
paroffset=zmadd(new->offset,sizetab[INT]);
}else{
if(f==FLOAT&&(storage_class&OLDSTYLE)){
/* Bei alten Funktionen werden FLOAT als DOUBLE uebergeben */
new->offset=zmmult(zmdiv(zmadd(new->offset,zmsub(align[DOUBLE],l2zm(1L))),align[DOUBLE]),align[DOUBLE]);
paroffset=zmadd(new->offset,sizetab[DOUBLE]);
}else{
paroffset=zmadd(new->offset,szof(new->vtyp));
}
}
}else{
local_offset[nesting]=zmadd(new->offset,szof(new->vtyp));
}
if(!(storage_class&PARAMETER))
if(zmleq(max_offset,local_offset[nesting])) max_offset=local_offset[nesting];
if(DEBUG&2) printf("max_offset=%ld\n",zm2l(max_offset));
}
if((storage_class&PLAIN_STORAGE_CLASS)==STATIC) new->offset=l2zm((long)++label);
if(storage_class&PARAMETER){
if(DEBUG&2) printf("parameter\n");
if(ISINT(f)&&f<INT&&!zmleq(sizetab[INT],sizetab[f])){
if(BIGENDIAN){
new->offset=zmadd(new->offset,zmsub(sizetab[INT],sizetab[f]));
}else{
if(!LITTLEENDIAN)
ierror(0);
}
}
if((storage_class&OLDSTYLE)&&f==FLOAT){
/* Bei alten Funktionen werden DOUBLE nach FLOAT konvertiert */
if(!(storage_class®PARM)){
#if HAVE_LIBCALLS
static struct Typ dt={DOUBLE},ft={FLOAT};
static struct node n,nn;
struct IC *conv=new_IC();
n.flags=REINTERPRET;
n.left=&nn;
n.ntyp=&dt;
nn.flags=IDENTIFIER;
nn.identifier=identifier;
nn.ntyp=&ft;
nn.o.flags=VAR|DONTREGISTERIZE;
nn.o.v=new;
nn.o.val.vmax=l2zm(0L);
n.o=nn.o;
convert(&n,FLOAT);
conv->code=ASSIGN;
conv->typf=FLOAT;
conv->q1=n.o;
conv->z.v=new;
conv->z.flags=VAR;
conv->z.val.vmax=l2zm(0L);
conv->q2.val.vmax=sizetab[FLOAT];
conv->z.v=new;
add_IC(conv);
#else
struct IC *conv=new_IC();
conv->code=CONVERT;
conv->typf=FLOAT;
conv->typf2=DOUBLE;
conv->q1.flags=VAR|DONTREGISTERIZE;
conv->z.flags=VAR;
conv->q2.flags=0;
conv->q1.v=conv->z.v=new;
conv->q1.val.vmax=conv->z.val.vmax=l2zm(0);
add_IC(conv);
#endif
}
new->flags|=CONVPARAMETER;
}
new->offset=zmsub(l2zm(0L),zmadd(maxalign,new->offset));
}
if((storage_class&PLAIN_STORAGE_CLASS)==EXTERN){
if(!strcmp("fprintf",identifier)) new->flags|=PRINTFLIKE;
if(!strcmp("printf",identifier)) new->flags|=PRINTFLIKE;
if(!strcmp("sprintf",identifier)) new->flags|=PRINTFLIKE;
if(!strcmp("fscanf",identifier)) new->flags|=SCANFLIKE;
if(!strcmp("scanf",identifier)) new->flags|=SCANFLIKE;
if(!strcmp("sscanf",identifier)) new->flags|=SCANFLIKE;
}
if(is_vlength(new->vtyp))
create_allocvl(new);
return(new);
}
void free_var(struct Var *p)
/* Gibt Variablenliste inkl. Typ, aber ohne Identifier frei. */
{
struct Var *merk;
while(p){
if(!*p->identifier&&p->identifier!=empty) ierror(0);
free(p->description);
free(p->vattr);
merk=p->next;
if(!(p->flags&USEDASADR)&&(p->storage_class==AUTO||p->storage_class==REGISTER)){
if(*p->identifier&&!(p->flags&USEDASDEST)&&ISSCALAR(p->vtyp->flags)) error(64,p->identifier);
if(*p->identifier&&!(p->flags&USEDASSOURCE)&&ISSCALAR(p->vtyp->flags)) error(65,p->identifier);
}
if(DEBUG&2) printf("free_var %s, pri=%d\n",p->identifier,p->priority);
if(p->vtyp) freetyp(p->vtyp);
if(p->clist) free_clist(p->clist);
if(p->fi){
if(DEBUG&2) printf("free_fi of function %s\n",p->identifier);
free_fi(p->fi);
if(DEBUG&2) printf("end free_fi of function %s\n",p->identifier);
}
free(p);
p=merk;
}
}
struct Var *find_ext_var(char *identifier)
{
struct Var *v;int l;
if(misracheck) l=strlen(identifier);
for(v=first_ext;v;v=v->next){
if(!strcmp(v->identifier,identifier)) return v;
#ifdef HAVE_MISRA
/* removed */
/* removed */
/* removed */
/* removed */
#endif
}
return 0;
}
struct Var *find_var(char *identifier,int endnesting)
/* Sucht Variable mit Bezeichner und liefert Zeiger zurueck */
/* es werden nur Variablen der Bloecke endnesting-nesting */
/* durchsucht. */
{
int i,l;struct Var *v;
if(identifier==0||*identifier==0) return 0;
if(misracheck) l=strlen(identifier);
for(i=nesting;i>=endnesting;i--){
for(v=first_var[i];v;v=v->next){
if(!strcmp(v->identifier,identifier))
return v;
#ifdef HAVE_MISRA
/* removed */
/* removed */
/* removed */
/* removed */
#endif
}
}
if(endnesting==0){
v=find_ext_var(identifier);
if(v&&!(v->flags&NOTINTU))
return v;
else
return 0;
}else
return 0;
}
#ifdef HAVE_MISRA
/* removed */
/* removed */
#endif
int check_zero_initialisation(struct const_list* cl, int typ)
{
if (cl->next) return 0;
if (cl->tree) return 0;
if (cl->other) {
return check_zero_initialisation(cl->other,typ);
} else {
eval_const(&cl->val,typ);
if ( (zmeqto(vmax,l2zm(0L))) && (zumeqto(vumax,ul2zum(0UL))) && (zldeqto(vldouble,d2zld(0.0))) ) {
return 1;
}
}
return 0;
}
/* decide whether a initialization shall be performed only be generated code
or if a table copy should be used first */
int use_only_dyn_init(zmax sz,zmax dyn_sz,zmax const_sz,int dyn_cnt,int const_cnt)
{
if(zmleq(sz,l2zm(32L)))
return 1;
if(zmeqto(dyn_sz,l2zm(0L)))
return 0;
if(!zmleq(zmdiv(sz,dyn_sz),l2zm(2L)))
return 0;
else
return 1;
}
void init_local_compound(struct Var *v)
{
if(v->storage_class==AUTO||v->storage_class==REGISTER){
struct IC *new;
/* Initialisierung von auto-Variablen */
new=new_IC();
new->code=ASSIGN;
new->typf=v->vtyp->flags;
new->q2.flags=0;
new->q2.val.vmax=szof(v->vtyp);
new->z.flags=VAR;
new->z.v=v;
new->z.val.vmax=l2zm(0L);
if(v->clist->tree){
/* einzelner Ausdruck */
gen_IC(v->clist->tree,0,0);
convert(v->clist->tree,v->vtyp->flags&NU);
new->q1=v->clist->tree->o;
add_IC(new);
/* v->clist=0;*/
}else{
/* Array etc. */
struct Var *nv;
if(!use_only_dyn_init(szof(v->vtyp),init_dyn_sz,init_const_sz,init_dyn_cnt,init_const_cnt)){
nv=add_var(empty,clone_typ(v->vtyp),STATIC,v->clist);
nv->flags|=DEFINED;
nv->dfilename=filename;
nv->dline=line;
nv->vtyp->flags|=CONST;
/* v->clist=0;*/
new->q1.flags=VAR;
new->q1.v=nv;
new->q1.val.vmax=l2zm(0L);
add_IC(new);
dynamic_init(v,v->vtyp,v->clist,0,1);
}else{
dynamic_init(v,v->vtyp,v->clist,0,0);
}
}
}
}
#ifdef HAVE_MISRA
/* removed */
/* removed */
/* removed */
#endif
void var_declaration(void)
/* Bearbeitet eine Variablendeklaration und erzeugt alle */
/* noetigen Strukturen. */
{
struct Typ *ts,*t,*old=0,*om=0;char *imerk,vident[MAXI];
int mdef=0,makeint=0,notdone,storage_class,msc,extern_flag,isfunc,
had_decl,hard_reg,mhr,diffunit=0,inline_flag;
struct Var *v;
char *vattr;
int base_type;
#ifdef HAVE_TARGET_ATTRIBUTES
unsigned long tattr;
#endif
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
#endif
ts=declaration_specifiers();notdone=1;
storage_class=return_sc;hard_reg=return_reg;vattr=return_vattr;
inline_flag=return_inline;
#ifdef HAVE_ECPP
/* removed */
#endif
if(for_decl&&storage_class!=0&&storage_class!=AUTO&&storage_class!=REGISTER){
error(299);
storage_class=AUTO;
}
#ifdef HAVE_TARGET_ATTRIBUTES
tattr=return_tattr;
#endif
if(storage_class==EXTERN) extern_flag=1; else extern_flag=0;
killsp();
if(ctok->type==SEMIC){
if(!ts) error(0);
if(storage_class||(!ISSTRUCT(ts->flags)&&!ISUNION(ts->flags)&&(ts->flags&NQ)!=INT))
error(36);
freetyp(ts);
next_token();killsp();
return;
}
if(nesting==0&&(storage_class==AUTO||storage_class==REGISTER))
{error(66);storage_class=EXTERN;}
if(!ts){
if(nesting<=1){
ts=new_typ();
ts->flags=INT;ts->next=0;
makeint=1;
if(!storage_class) storage_class=EXTERN;
#ifdef HAVE_MISRA
/* removed */
#endif
error(67);
}else{
ierror(0);return;
}
}
if(storage_class==0){
if(nesting==0)
storage_class=EXTERN;
else
storage_class=AUTO;
}
msc=storage_class;mhr=hard_reg;
while(notdone){
int oldnesting=nesting;
imerk=ident;ident=vident;*vident=0; /* merken von ident hier vermutlich */
storage_class=msc;hard_reg=mhr;
if(old) {freetyp(old);old=0;}
t=declarator(clone_typ(ts));
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
#ifdef HAVE_EXT_TYPES
conv_typ(t);
#endif
if(!ISFUNC(t->flags)){
isfunc=0;
if(inline_flag) error(301);
}else{
isfunc=1;
#ifdef HAVE_MISRA
/* removed */
#endif
if(storage_class!=STATIC&&storage_class!=TYPEDEF) storage_class=EXTERN;
}
ident=imerk; /* nicht unbedingt noetig ? */
if(!*vident){
free(ts);free(t);
error(36);return;
}
v=find_var(vident,oldnesting);
if(!v&&/*oldnesting==0&&*/storage_class==EXTERN&&cross_module&&(v=find_ext_var(vident))){
v->flags&=~NOTINTU;
diffunit=1;
/*FIXME: check auf doppelte Def. */
}
#ifdef HAVE_MISRA
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
if(v){
had_decl=1;
if(storage_class==TYPEDEF){
error(226,v->identifier);
}else{
if(nesting>0&&(v->flags&DEFINED)&&!extern_flag&&!isfunc){
error(27,vident);
}else{
if(t&&v->vtyp&&!compatible_types(v->vtyp,t,NU|CONST|VOLATILE)){
if(ISFUNC(t->flags)&&!ISFUNC(v->vtyp->flags))
error(361,vident);
else
error(68,vident);
#ifdef HAVE_MISRA
/* removed */
#endif
}
if((storage_class!=v->storage_class&&!extern_flag)||hard_reg!=v->reg)
error(28,v->identifier);
if(!isfunc&&!extern_flag) v->flags|=TENTATIVE;
}
#ifdef HAVE_TARGET_ATTRIBUTES
{
int i;
for(i=0;g_attr_name[i];i++){
if((v->tattr&(1L<<i))!=(tattr&(1L<<i))) error(228,vident,g_attr_name[i]);
}
v->tattr=tattr;
}
#endif
if(vattr){
if(v->vattr){
v->vattr=myrealloc(v->vattr,strlen(v->vattr)+strlen(vattr)+2);
strcat(v->vattr,";");
strcat(v->vattr,vattr);
}else v->vattr=vattr;
if(ISFUNC(v->vtyp->flags)) fi_from_attr(v);
}
if(!isfunc){
if(!ISARRAY(t->flags)||!zmeqto(t->size,l2zm(0L))){
free(v->vtyp);
v->vtyp=t;
}
}else{
om=v->vtyp;
if(t->exact->count>0){
old=v->vtyp;v->vtyp=t;
}
}
}
}else{
had_decl=0;
#ifdef HAVE_MISRA
/* removed */
#endif
if(isfunc&&ctok->type!=COMMA&&ctok->type!=SEMIC&&ctok->type!=RPAR&&ctok->type!=ASGN&&nesting>0) nesting--;
v=add_var(vident,t,storage_class,0);
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
v->reg=hard_reg;
v->vattr=vattr;
if(ISFUNC(v->vtyp->flags))
fi_from_attr(v);
#ifdef HAVE_TARGET_ATTRIBUTES
v->tattr=tattr;
#endif
if(isfunc&&ctok->type!=COMMA&&ctok->type!=SEMIC&&ctok->type!=RPAR&&ctok->type!=ASGN&&nesting>=0) nesting++;
if(!v) ierror(0);
else{
if(!isfunc&&!extern_flag){
v->flags|=TENTATIVE;
if(nesting>0){
v->flags|=DEFINED;
v->dfilename=filename;
v->dline=line;
}
}
}
om=0;
}
if(isfunc&&inline_flag){
v->flags|=INLINEFUNC;
if(extern_flag) v->flags|=INLINEEXT;
}
#ifdef HAVE_MISRA
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
if(disallow_statics&&v->storage_class==STATIC&&*v->identifier&&!is_const(v->vtyp))
error(302,v->identifier);
killsp();
/* Inline-Assembler-Code in Funktionsdeklarationen */
if(ctok->type==ASGN&&ISFUNC(v->vtyp->flags)&&(header_cnt>0||!(c_flags[7]&USEDFLAG))){
np tree;
next_token();killsp();
if(v->fi){free(v->fi->inline_asm);v->fi->inline_asm=0;}
if(!v->fi) v->fi=new_fi();
v->fi->inline_asm=get_string();
mdef=1;
}else{
/*if(v->fi){free(v->fi->inline_asm);v->fi->inline_asm=0;}*/
}
/* Initialisierung von Variablen bei Deklaration */
if(ctok->type==ASGN){
next_token();killsp();
if(!had_decl&&v->nesting==0&&v->storage_class==EXTERN&&strcmp("main",v->identifier))
error(168,v->identifier);
if(v->flags&DEFINED){
if(nesting==0) error(30,v->identifier);
}else{
v->flags|=DEFINED;
v->dfilename=filename;
v->dline=line;
#ifdef HAVE_MISRA
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
}
if(v->storage_class==TYPEDEF) error(114,v->identifier);
if(extern_flag){
if(nesting==0)
error(118,v->identifier);
else
error(207,v->identifier);
if(v->storage_class!=EXTERN){ error(77);v->storage_class=EXTERN;}
}
#ifdef HAVE_MISRA
/* removed */
/* removed */
#endif
init_dyn_sz=l2zm(0L);
init_dyn_cnt=0;
init_const_sz=l2zm(0L);
init_const_cnt=0;
v->clist=initialization(v->vtyp,v->storage_class==AUTO||v->storage_class==REGISTER,0,0,0,0);
/* MISRA Rule 9.2 violation checking and error reporting */
#ifdef HAVE_MISRA
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
if(v->clist){
if(ISARRAY(v->vtyp->flags)&&zmeqto(v->vtyp->size,l2zm(0L))){
struct const_list *p=v->clist;
while(p){v->vtyp->size=zmadd(p->idx,l2zm(1L));p=p->next;}
if(v->storage_class==AUTO||v->storage_class==REGISTER){
local_offset[nesting]=zmadd(local_offset[nesting],szof(v->vtyp));
if(zmleq(max_offset,local_offset[nesting])) max_offset=local_offset[nesting];
}
}
if(v->storage_class==AUTO||v->storage_class==REGISTER){
init_local_compound(v);
}else if(c_flags[19]&USEDFLAG){
/* Ohne Optimierung gleich erzeugen; das ist noch */
/* etwas von der genauen Implementierung der Liste */
/* der Variablen abhaengig. */
struct Var *merk=v->next;
v->next=0;
gen_vars(v);
v->next=merk;
v->clist=0;
}
}
}else{
if((v->flags&DEFINED)&&type_uncomplete(v->vtyp)) error(202,v->identifier);
if((v->vtyp->flags&CONST)&&(v->storage_class==AUTO||v->storage_class==REGISTER))
error(119,v->identifier);
}
if(ctok->type==COMMA) {next_token();killsp();mdef=1;} else notdone=0;
}
freetyp(ts);
if(ISFUNC(t->flags)&&v->reg)
t->next->reg=v->reg;
if(!mdef&&t&&(t->flags&NQ)==FUNKT&&ctok->type!=SEMIC){
/* Funktionsdefinition*/
int i,oldstyle=0;
#ifdef HAVE_MISRA
/* removed */
/* removed */
#endif
#ifdef HAVE_REGPARMS
struct reg_handle reg_handle;
#endif
if(DEBUG&1) printf("Funktionsdefinition! %s %p\n",v->identifier,(void *)v);
{
int i;
for(i=1;i<=MAXR;i++) {regs[i]=regused[i]=regsa[i];regsbuf[i]=0;}
}
cur_func=v->identifier;
if(only_inline==2) only_inline=0;
if(nesting<1) enter_block();
if(nesting>1) error(32);
if(v->flags&DEFINED){
if(!inline_flag||!cross_module){
error(33,v->identifier);
}else{
if(v->fi->first_ic){
free_IC(v->fi->first_ic);
v->fi->first_ic=0;
}
}
}else{
v->flags|=DEFINED;
v->dfilename=filename;
v->dline=line;
#ifdef HAVE_MISRA
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
}
if(storage_class!=EXTERN&&storage_class!=STATIC) error(34);
if(extern_flag&&!inline_flag) error(120);
if(storage_class==EXTERN&&!strcmp(v->identifier,"main")&&(!t->next||t->next->flags!=INT)) error(121);
if(!had_decl&&v->nesting==0&&v->storage_class==EXTERN&&strcmp("main",v->identifier))
error(168,v->identifier);
while(!ecpp&&ctok->type!=LBRA){
/* alter Stil */
struct Typ *nt=declaration_specifiers();notdone=1;oldstyle=OLDSTYLE;
if(!ts) {error(35);}
while(notdone){
int found=0;
imerk=ident;ident=vident;*vident=0;
ts=declarator(clone_typ(nt));
ident=imerk;
if(!ts) {error(36);}
else{
for(i=0;i<t->exact->count;i++){
if(!strcmp((*t->exact->sl)[i].identifier,vident)){
found=1;
if((*t->exact->sl)[i].styp){
error(69,vident);
freetyp((*t->exact->sl)[i].styp);
}
/* typ[] in *typ */
if(ISARRAY(ts->flags)) ts->flags=POINTER_TYPE(ts);
/* typ() in *typ() */
if(ISFUNC(ts->flags)){
struct Typ *new=new_typ();
new->flags=POINTER_TYPE(ts);
new->next=ts;
ts=new;
}
if(!return_sc) return_sc=AUTO;
if(return_sc!=AUTO&&return_sc!=REGISTER)
{error(122);return_sc=AUTO;}
(*t->exact->sl)[i].storage_class=return_sc;
(*t->exact->sl)[i].reg=return_reg;
if(return_reg) error(219);
(*t->exact->sl)[i].styp=ts;
}
}
}
if(!found) {error(37,vident);}
killsp();
if(ctok->type==COMMA) {next_token();killsp();} else notdone=0;
}
if(nt) freetyp(nt);
if(ctok->type==SEMIC){
next_token();killsp();
}else{
error(54);
while(ctok->type!=LBRA&&ctok->type!=SEMIC){next_token();killsp();}
}
}
if(!ecpp&&t->exact->count==0){
struct struct_list sl[1];
if(DEBUG&1) printf("prototype converted to (void)\n");
t->exact->count=1;
sl[0].identifier=empty;
sl[0].storage_class=AUTO;
sl[0].styp=new_typ();
sl[0].styp->flags=VOID;
sl[0].styp->next=0;
nesting--;
add_sl(t->exact,&sl);
nesting++;
}
if(om&&om->exact&&!compare_sd(om->exact,t->exact)) {
error(123);
#ifdef HAVE_MISRA
/* removed */
#endif
}
nocode=0;currentpri=1;
/* enter_block();*/
local_offset[1]=l2zm(0L);
return_var=0;
if(!v->vtyp) ierror(0);
#ifdef HAVE_REGPARMS
reg_handle=empty_reg_handle;
#endif
if(v->vtyp->next->flags==VOID){
return_typ=0;
}else{
return_typ=v->vtyp->next;
if(!ffreturn(return_typ)&&(return_typ->flags&NQ)!=VOID){
/* Parameter fuer die Rueckgabe von Werten, die nicht in einem */
/* Register sind. */
struct Typ *rt=new_typ();int reg;
rt->flags=POINTER_TYPE(return_typ);rt->next=return_typ;
#ifdef HAVE_REGPARMS
reg=reg_parm(®_handle,rt,0,v->vtyp);
if(!reg){
return_var=add_var(empty,clone_typ(rt),AUTO|PARAMETER|oldstyle,0);
}else{
return_var=add_var(empty,clone_typ(rt),reg<0?(AUTO|PARAMETER|REGPARM|DBLPUSH|oldstyle):(AUTO|PARAMETER|REGPARM|oldstyle),0);
return_var->reg=reg;
}
#else
return_var=add_var(empty,clone_typ(rt),AUTO|PARAMETER|oldstyle,0);
#endif
return_var->flags|=DEFINED;
return_var->dfilename=filename;
return_var->dline=line;
free(rt);
}
}
first_ic=last_ic=0;ic_count=0;max_offset=l2zm(0L);
for(i=0;i<t->exact->count;i++){
#ifdef HAVE_REGPARMS
int didrp=0;
if((*t->exact->sl)[i].styp){
int tr;
tr=reg_parm(®_handle,(*t->exact->sl)[i].styp,0,t);
didrp=1;
if(!(*t->exact->sl)[i].reg) (*t->exact->sl)[i].reg=tr;
}
#endif
if(!(*t->exact->sl)[i].styp&&*(*t->exact->sl)[i].identifier){
struct Typ *nt;
#ifdef HAVE_MISRA
/* removed */
#endif
nt=new_typ();
nt->flags=INT;
(*t->exact->sl)[i].styp=nt;
(*t->exact->sl)[i].storage_class=AUTO;
(*t->exact->sl)[i].reg=0;
error(124);
}
if(*(*t->exact->sl)[i].identifier){
struct Var *tmp;int sc,tr;
sc=((*t->exact->sl)[i].storage_class|PARAMETER|oldstyle);
#ifdef HAVE_REGPARMS
if(!didrp){
if(!t->exact->sl) ierror(0);
if(!(*t->exact->sl)[i].styp) ierror(0);
tr=reg_parm(®_handle,(*t->exact->sl)[i].styp,0,t);
if(!(*t->exact->sl)[i].reg) (*t->exact->sl)[i].reg=tr;
}
#endif
if((*t->exact->sl)[i].reg>0) sc|=REGPARM;
if((*t->exact->sl)[i].reg<0) sc|=(REGPARM|DBLPUSH);
tmp=add_var((*t->exact->sl)[i].identifier,clone_typ((*t->exact->sl)[i].styp),sc,0);
tmp->reg=(*t->exact->sl)[i].reg;
tmp->flags|=DEFINED;
tmp->dfilename=filename;
tmp->dline=line;
if(oldstyle){
#ifdef HAVE_MISRA
/* removed */
#endif
freetyp((*t->exact->sl)[i].styp);
(*t->exact->sl)[i].styp=0; /* Prototype entfernen */
}
}
}
if(oldstyle) t->exact->count=0; /* Prototype entfernen */
/* local_offset[1]=l2zm(0L);*/
return_label=++label;
function_calls=0;float_used=0;has_return=0;goto_used=0;vlas=0;
did_return_label=0;
for(i=1;i<=MAXR;i++) simple_scratch[i]=0;
if(v->storage_class==EXTERN&&(v->flags&INLINEFUNC))
disallow_statics=1;
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
#ifdef HAVE_MISRA
/* removed */
/* removed */
#endif
if(c99){
/* c99 predefined __func__ */
struct Typ *ft=new_typ();
struct Var *fnc;
/* create type */
ft->flags=ARRAY;
ft->size=l2zm((long)strlen(cur_func)+1);
ft->next=new_typ();
ft->next->flags=CONST|CHAR;
/* use string_expression() to create const_list */
fnc=add_var("__func__",ft,STATIC,cl_from_string(cur_func,cur_func+strlen(cur_func)));
fnc->flags|=DEFINED;
}
/* Generate intermediate code for function */
compound_statement();
#ifdef HAVE_MISRA
/* removed */
#endif
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
disallow_statics=0;
if(block_vla[nesting]) clearvl();
if((v->vtyp->next->flags&NQ)!=VOID&&!has_return){
if(strcmp(v->identifier,"main")) error(173,v->identifier);
else error(174,v->identifier);
}
#if 0
{int i;
for(i=1;i<=MAXR;i++) if(regs[i]!=regsa[i]) {printf("Register %s:\n",regnames[i]);ierror(0);}
}
#endif
if(!did_return_label){
clear_main_ret();
gen_label(return_label);
}
/* backpatch code for jumps out of vla-scope if necessary */
if(vlas)
vla_jump_fix();
if(cross_module){
if(!v->fi) v->fi=new_fi();
v->fi->statics=first_var[0];
}else if(first_ic&&errors==0){
if((c_flags[2]&USEDFLAG)&&ic1){fprintf(ic1,"function %s\n",v->identifier); pric(ic1,first_ic);}
vl1=first_var[0];
vl2=first_var[1];
vl3=merk_varf;
optimize(optflags,v);
if((c_flags[3]&USEDFLAG)&&ic2){fprintf(ic2,"function %s\n",v->identifier); pric(ic2,first_ic);}
if(out&&!only_inline&&!(c_flags[5]&USEDFLAG)){
memset(regs_modified,0,RSIZE);
gen_code(out,first_ic,v,max_offset);
static_stack_check(v);
v->flags|=GENERATED;
#ifdef HAVE_REGS_MODIFIED
if(!v->fi) v->fi=new_fi();
if(v->fi->flags&ALL_REGS)
{
int i;
for(i=1;i<=MAXR;i++){
if(reg_pair(i,&rp)){
if(BTST(regs_modified,i)){
BSET(regs_modified,rp.r1);
BSET(regs_modified,rp.r2);
}else{
if(BTST(regs_modified,rp.r1)||BTST(regs_modified,rp.r2))
BSET(regs_modified,i);
}
}
}
memcpy(v->fi->regs_modified,regs_modified,RSIZE);
v->fi->flags|=ALL_REGS;
}
#endif
}
/*if(DEBUG&8192){fprintf(ic2,"function %s, after gen_code\n",v->identifier); pric(ic2,first_ic);}*/
free_IC(first_ic);
first_ic=last_ic=0;
}
if(cross_module){
if(!v->fi) v->fi=new_fi();
v->fi->first_ic=first_ic;
v->fi->last_ic=last_ic;
first_ic=last_ic=0;
}
if(v->fi&&v->fi->first_ic){
struct Var *vp;
if(DEBUG&1) printf("leave block %d (inline-version)\n",nesting);
if(block_vla[nesting]) clearvl();
if(nesting!=1) ierror(0);
if(merk_varl) merk_varl->next=first_var[nesting]; else merk_varf=first_var[nesting];
if(last_var[nesting]) merk_varl=last_var[nesting];
if(merk_sil) merk_sil->next=first_si[nesting]; else merk_sif=first_si[nesting];
if(last_si[nesting]) merk_sil=last_si[nesting];
if(merk_sdl) merk_sdl->next=first_sd[nesting]; else merk_sdf=first_sd[nesting];
if(last_sd[nesting]) merk_sdl=last_sd[nesting];
if(merk_ilistl) merk_ilistl->next=first_ilist[nesting]; else merk_ilistf=first_ilist[nesting];
if(last_ilist[nesting]) merk_ilistl=last_ilist[nesting];
if(merk_varf&&!only_inline&&!cross_module) gen_vars(merk_varf);
if(first_llist) free_llist(first_llist);
first_llist=0;
if(first_clist) free_clist(first_clist);
first_clist=0;
if(merk_sif) free_si(merk_sif);
/* struct-declarations erst ganz am Schluss loeschen. Um zu vermeiden, */
/* dass struct-declarations in Prototypen frei werden und dann eine */
/* spaetere struct, dieselbe Adresse bekommt und dadurch gleich wird. */
/* Nicht sehr schoen - wenn moeglich noch mal aendern. */
/* if(merk_sdf) free_sd(merk_sdf);*/
/* hier noch was ueberlegen */
/* if(merk_ilistf) free_ilist(merk_ilistf);*/
nesting--;
v->fi->vars=merk_varf;
/* v->fi->vars=first_var[1];*/
/* keine echten Parameter=>keine negativen Offsets */
/* vp=first_var[1];*/
if(!cross_module){
vp=merk_varf;
while(vp){
if(vp->storage_class==AUTO||vp->storage_class==REGISTER){
/*if(DEBUG&1024) printf("handling variable %s(%ld)/%p\n",vp->identifier,zm2l(vp->offset),(void*)vp);*/
if(!zmleq(l2zm(0L),vp->offset)){
vp->offset=l2zm(0L);
if(DEBUG&1024) printf("converted parameter <%s>(%ld) for inlining\n",vp->identifier,(long)zm2l(vp->offset));
}else vp->offset=l2zm(4L); /* Dummy, da recalc_offsets? */
}
vp=vp->next;
}
}
}else{
leave_block();
}
if(only_inline==2) only_inline=0;
cur_func="oops, I forgot it";
}else{
if(makeint) error(125);
if(ctok->type==SEMIC) next_token(); else error(54);
if(ISFUNC(t->flags)&&t->exact){
struct struct_declaration *sd=t->exact;int i,f;
for(f=0,i=0;i<sd->count;i++)
if(!(*sd->sl)[i].styp){error(126);f=1;}
if(f){
for(i=0;i<sd->count;i++) if((*sd->sl)[i].styp) freetyp((*sd->sl)[i].styp);
sd->count=0;
}
}
}
if(old) freetyp(old);
}
int compatible_types(struct Typ *a,struct Typ *b,int qual)
/* Vergleicht, ob Typ beider Typen gleich ist, const/volatile */
/* werden laut ANSI nicht beruecksichtigt. */
{
struct struct_declaration *sd;
int af=a->flags&qual,bf=b->flags&qual;
if(af!=bf) return(0);
af&=NQ;bf&=NQ;
if(ISFUNC(af)){
if(a->exact->count&&!compare_sd(a->exact,b->exact)) return(0);
}
if(ISSTRUCT(af)||ISUNION(af)){
if(cross_module&&a->exact->tunit!=b->exact->tunit) return 1;
if(a->exact!=b->exact) return(0);
}
if(ISARRAY(af)){
if(!zmeqto(a->size,l2zm(0L))&&!zmeqto(b->size,l2zm(0L))&&!zmeqto(a->size,b->size)) return(0);
}
if(a->next==0&&b->next!=0) return(0);
if(a->next!=0&&b->next==0) return(0);
if(a->next==0&&b->next==0) return(1);
if(qual!=NQ) qual=(NU|CONST|VOLATILE);
return(compatible_types(a->next,b->next,qual));
}
int compare_sd(struct struct_declaration *a,struct struct_declaration *b)
/* Vergleicht, ob zwei struct_declarations identisch sind */
/* Wird nur nur fuer Prototypen benutzt, leere Liste immer gleich. */
{
int i;
if(!a->count||!b->count) return(1);
if(a->count!=b->count) return(0);
for(i=0;i<a->count;i++){
if((*a->sl)[i].styp&&(*b->sl)[i].styp&&!compatible_types((*a->sl)[i].styp,(*b->sl)[i].styp,NU)) return(0);
#ifdef HAVE_MISRA
/* removed */
/* removed */
#endif
}
return(1);
}
void free_clist(struct const_list *p)
/* Gibt clist frei. */
{
struct const_list *merk;
return;
while(p){
merk=p->next;
if(p->other) free_clist(p->other);
if(p->tree) free_expression(p->tree);
free(p);
p=merk;
}
}
void gen_clist(FILE *,struct Typ *,struct const_list *);
void gen_vars(struct Var *v)
/* Generiert Variablen. */
{
int mode,al;struct Var *p;
if(errors!=0||(c_flags[5]&USEDFLAG)) return;
if(optsize)
al=zm2l(maxalign);
else
al=0;
for(;al>=0;al--){
for(mode=0;mode<3;mode++){
int i,flag;
for(p=v;p;p=p->next){
if(optsize&&zm2l(falign(p->vtyp))!=al)
continue;
if(cross_module&&!(p->flags&REFERENCED)) continue;
if(DEBUG&2) printf("gen_var(): %s\n",p->identifier);
if(p->storage_class==STATIC||p->storage_class==EXTERN){
if(!(p->flags&GENERATED)){
if(p->storage_class==EXTERN&&!(p->flags&(USEDASSOURCE|USEDASDEST))&&!(p->flags&(TENTATIVE|DEFINED))) continue;
if(p->storage_class==STATIC&&p->nesting>0&&!(p->flags&(USEDASSOURCE|USEDASDEST))) continue;
/* erst konstante initialisierte Daten */
if(mode==0){
if(!p->clist) continue;
if(!(p->vtyp->flags&(CONST|STRINGCONST))){
struct Typ *t=p->vtyp;int f=0;
do{
if(t->flags&(CONST|STRINGCONST)) break;
if(!ISARRAY(t->flags)){f=1;break;}
t=t->next;
}while(1);
if(f) continue;
}
}
/* dann initiolisierte */
if(mode==1&&!p->clist) continue;
/* und dann der Rest */
if(mode==2&&p->clist) continue;
if(!(p->flags&(TENTATIVE|DEFINED))){
if(!((p->vtyp->flags&NQ)==FUNKT)||!p->fi||!p->fi->inline_asm)
gen_var_head(out,p);
if(p->storage_class==STATIC&&(!p->fi||!p->fi->inline_asm)) error(127,p->identifier);
continue;
}else{
/*gen_align(out,falign(p->vtyp));*/
}
if(!(p->vtyp->flags&NQ)==FUNKT||!p->fi||!p->fi->inline_asm)
gen_var_head(out,p);
if(!p->clist){
if(type_uncomplete(p->vtyp)) error(202,p->identifier);
gen_ds(out,szof(p->vtyp),p->vtyp);
}else{
gen_clist(out,p->vtyp,p->clist);
}
p->flags|=GENERATED;
}else if(p->flags&INLINEEXT){
/* a function was declared extern inline and defined;
we have to create external linkage */
int m=p->flags;
/* pretend, it was only declared, but not defined and remove
INLINEEXT */
p->flags&=~(DEFINED|INLINEEXT);
gen_var_head(out,p);
p->flags|=DEFINED;
}
}
}
}
}
}
/* creates code that dynamically initializes a variable */
void dynamic_init(struct Var *v,struct Typ *t,struct const_list *cl,zmax of,int noconst)
{
int f=t->flags;
if(ISARRAY(f)){
zmax i;
for(i=l2zm(0L);!zmleq(t->size,i);i=zmadd(i,l2zm(1L))){
if(cl&&zmeqto(cl->idx,i)){
dynamic_init(v,t->next,cl->other,of,noconst);
cl=cl->next;
}else{
dynamic_init(v,t->next,0,of,noconst);
}
of=zmadd(of,szof(t->next));
}
}else if(ISUNION(f)&&(!cl||!cl->tree)){
dynamic_init(v,(*t->exact->sl)[cl?zm2l(cl->idx):0].styp,cl?cl->other:0,of,noconst);
}else if(ISSTRUCT(f)&&(!cl||!cl->tree)){
zmax al;int fl;struct Typ *st;
int bfo,i;
for(i=0;i<t->exact->count&&cl;i++){
if(!cl->other){ierror(0);return;}
st=(*t->exact->sl)[i].styp;
al=(*t->exact->sl)[i].align;
if(!(*t->exact->sl)[i].identifier) ierror(0);
bfo=(*t->exact->sl)[i].bfoffset;
if(!zmeqto(zmmod(of,al),l2zm(0L))){
of=zmadd(of,zmsub(al,zmmod(of,al)));
}
if(bfo>=0){
int bfs=(*t->exact->sl)[i].bfsize;
static struct obj dest = {0};
dest.flags=VAR;
dest.v=v;
dest.val.vmax=of;
if(bfo==0){
/* first clear entire bitfield */
struct IC *new=new_IC();
new->code=ASSIGN;
new->z=dest;
new->typf=st->flags;
new->q2.val.vmax=sizetab[st->flags&NQ];
new->q1.flags=KONST;
new->q1.val.vmax=l2zm(0L);
eval_const(&new->q1.val,MAXINT);
insert_const(&new->q1.val,st->flags&NU);
add_IC(new);
}
/* bitfield */
if(!zmeqto(cl->idx,l2zm(i))||!cl->other){
/* nothing to do, initialized before */
}else if(cl->other->tree){
struct obj dummy;
gen_IC(cl->other->tree,0,0);
convert(cl->other->tree,st->flags);
insert_bitfield(&dest,&cl->other->tree->o,&cl->other->tree->o,bfs,bfo,st->flags,1);
cl=cl->next;
}else{
static struct obj val = {0};
val.flags=KONST;
val.val=cl->other->val;
insert_bitfield(&dest,&val,&val,bfs,bfo,st->flags,1);
cl=cl->next;
}
if(i+1>=t->exact->count||(*t->exact->sl)[i+1].bfoffset<=0||!cl){
of=zmadd(of,szof(st));
}
}else{
if(zmeqto(l2zm((long)i),cl->idx)){
dynamic_init(v,st,cl->other,of,noconst);
cl=cl->next;
}else
dynamic_init(v,st,0,of,noconst);
of=zmadd(of,szof(st));
}
}
for(;i<t->exact->count;i++){
st=(*t->exact->sl)[i].styp;
al=(*t->exact->sl)[i].align;
bfo=(*t->exact->sl)[i].bfoffset;
if(bfo>0) continue;
if(!zmeqto(zmmod(of,al),l2zm(0L))){
of=zmadd(of,zmsub(al,zmmod(of,al)));
}
dynamic_init(v,st,0,of,noconst);
of=zmadd(of,szof(st));
}
}else{
struct IC *new;
if(noconst&&(!cl||!cl->tree))
return;
new=new_IC();
new->code=ASSIGN;
new->z.flags=VAR;
new->z.v=v;
new->z.val.vmax=of;
new->typf=t->flags;
new->q2.val.vmax=szof(t);
if(!cl){
new->q1.flags=KONST;
gval.vmax=l2zm(0L);
eval_const(&gval,MAXINT);
insert_const(&new->q1.val,t->flags&NU);
}else if(cl->tree){
gen_IC(cl->tree,0,0);
if(ISSCALAR(t->flags))
convert(cl->tree,t->flags);
new->q1=cl->tree->o;
}else{
new->q1.flags=KONST;
new->q1.val=cl->val;
}
add_IC(new);
}
}
void gen_clist(FILE *f,struct Typ *t,struct const_list *cl)
/* Generiert dc fuer const_list. */
{
int i,bfo,bfs;zmax sz;zumax bfval=ul2zum(0UL);
if(ISARRAY(t->flags)){
for(sz=l2zm(0L);!zmleq(t->size,sz)&&cl;cl=cl->next){
if(!cl->other){ierror(0);return;}
if(!zmeqto(sz,cl->idx))
gen_ds(f,zmmult(zmsub(cl->idx,sz),szof(t->next)),t->next);
gen_clist(f,t->next,cl->other);
sz=zmadd(cl->idx,l2zm(1L));
}
if(!zmleq(t->size,sz)) gen_ds(f,zmmult(zmsub(t->size,sz),szof(t->next)),t->next);
return;
}
if(ISUNION(t->flags)){
int i=zm2l(cl->idx);
if(cl&&cl->tree){
/* union initialized by another union */
gen_ds(f,szof(t),t);
}else{
gen_clist(f,(*t->exact->sl)[i].styp,cl->other);
sz=zmsub(szof(t),szof((*t->exact->sl)[i].styp));
if(!zmeqto(sz,l2zm(0L))) gen_ds(f,sz,0);
}
return;
}
if(ISSTRUCT(t->flags)){
zmax al;int fl;struct Typ *st;
sz=l2zm(0L);
if(cl&&cl->tree){
/* struct initialized by another struct */
gen_ds(f,szof(t),t);
sz=zmadd(sz,szof(t));
}else{
for(i=0;i<t->exact->count&&cl;i++){
if(!cl->other){ierror(0);return;}
st=(*t->exact->sl)[i].styp;
al=(*t->exact->sl)[i].align;
if(!(*t->exact->sl)[i].identifier) ierror(0);
bfo=(*t->exact->sl)[i].bfoffset;
if(!zmeqto(zmmod(sz,al),l2zm(0L))){
gen_ds(f,zmsub(al,zmmod(sz,al)),0);
sz=zmadd(sz,zmsub(al,zmmod(sz,al)));
}
if(bfo>=0){
/* bitfield */
if((*t->exact->sl)[i].identifier[0]){
bfs=(*t->exact->sl)[i].bfsize;
if(zmeqto(l2zm((long)i),cl->idx)){
eval_const(&cl->other->val,st->flags);
cl=cl->next;
}else{
vumax=ul2zum(0UL);
}
vumax=zumand(vumax,zumsub(zumlshift(ul2zum(1UL),ul2zum((unsigned long)bfs)),ul2zum(1UL)));
bfval=zumor(bfval,zumlshift(vumax,ul2zum((unsigned long)bflayout(bfo,bfs,st->flags))));
}
if(i+1>=t->exact->count||(*t->exact->sl)[i+1].bfoffset<=0||!cl){
/* last bitfield in integer */
struct const_list bfcl;
gval.vumax=bfval;
eval_const(&gval,UNSIGNED|MAXINT);
insert_const(&bfcl.val,st->flags&NU);
bfcl.tree=0;
gen_dc(f,st->flags&NU,&bfcl);
bfval=ul2zum(0L);
sz=zmadd(sz,szof(st));
}
}else{
if(zmeqto(l2zm((long)i),cl->idx)){
gen_clist(f,st,cl->other);
cl=cl->next;
}else
gen_ds(f,szof(st),st);
sz=zmadd(sz,szof(st));
}
}
for(;i<t->exact->count;i++){
st=(*t->exact->sl)[i].styp;
al=(*t->exact->sl)[i].align;
bfo=(*t->exact->sl)[i].bfoffset;
if(bfo>0) continue;
if(!zmeqto(zmmod(sz,al),l2zm(0L))){
gen_ds(f,zmsub(al,zmmod(sz,al)),0);
sz=zmadd(sz,zmsub(al,zmmod(sz,al)));
}
gen_ds(f,szof((*t->exact->sl)[i].styp),(*t->exact->sl)[i].styp);
sz=zmadd(sz,szof(st));
}
}
al=falign(t);
if(!zmeqto(zmmod(sz,al),l2zm(0L)))
gen_ds(f,zmsub(al,zmmod(sz,al)),0);
return;
}
if(cl->tree) cl->tree->o.am=0;
if(zmeqto(cl->idx,l2zm(-1L)))
gen_ds(f,szof(t),t);
else
gen_dc(f,t->flags&NU,cl);
}
/* finds the correct place in a const list to insert new initializer */
struct const_list *insert_cl(struct const_list *old,zmax idx)
{
struct const_list *p,*cl=0;
if(old&&zmleq(old->idx,idx)){
p=old;
do{
if(zmeqto(p->idx,idx)){
/* found existing entry */
cl=p;
break;
}
if(!p->next||!zmleq(p->next->idx,idx))
break;
p=p->next;
}while(p);
}else
p=0;
/* we need a new entry */
if(!cl){
cl=mymalloc(CLS);
cl->tree=0;
cl->other=0;
cl->idx=idx;
if(p){
cl->next=p->next;
p->next=cl;
}else
cl->next=old;
}
return cl;
}
struct const_list *designator(struct Typ *t,struct const_list *cl)
{
int f=t->flags&NQ;
np tree;
if(!c99) return 0;
if(ISARRAY(f)&&ctok->type==LBRK){
next_token();
killsp();
tree=expression();
if(ctok->type!=RBRK)
error(62);
else
{next_token();killsp();}
if(!type_expression(tree)){
/* error("incorrect constant expression");*/
}else{
if(tree->sidefx) error(60);
if(tree->flags!=CEXPR||!ISINT(tree->ntyp->flags)){
error(19);
}else{
/* check index for valid range */
eval_constn(tree);
if(!zmleq(l2zm(0L),vmax)) {error(354);vmax=l2zm(0L);}
if(!zmeqto(t->size,l2zm(0L))&&zmleq(t->size,vmax)) {error(354);vmax=l2zm(0L);}
cl=insert_cl(cl,vmax);
return cl;
}
}
}else if((ISSTRUCT(f)||ISUNION(f))&&ctok->type==DOT){
next_token();
killsp();
if(ctok->type!=NAME){
error(53);
}else{
int i,n=-1;
for(i=0;i<t->exact->count;i++)
if(!strcmp((*t->exact->sl)[i].identifier,ctok->name)) n=i;
if(n<0){
error(23,ctok->name);
return 0;
}
next_token();
killsp();
if(!ISUNION(f)||!cl)
cl=insert_cl(cl,l2zm((long)n));
return cl;
}
}
return 0;
}
/* declare a builtin function with up to two scalar arguments */
struct Var *declare_builtin(char *name,int ztyp,int q1typ,int q1reg,int q2typ,int q2reg,int nosidefx,char *asm)
{
struct struct_declaration *sd;
struct Typ *t;
struct Var *v;
int args;
if(!(v=find_ext_var(name))){
sd=mymalloc(sizeof(*sd));
if(q1typ==0) args=1;
else if(q2typ!=0) args=3;
else args=2;
sd->sl=mymalloc(args*sizeof(struct struct_list));
memset(sd->sl,0,args*sizeof(struct struct_list));
sd->count=args;
if(q1typ){
(*sd->sl)[0].styp=new_typ();
(*sd->sl)[0].styp->flags=q1typ;
(*sd->sl)[0].reg=q1reg;
}
if(q2typ){
(*sd->sl)[1].styp=new_typ();
(*sd->sl)[1].styp->flags=q2typ;
(*sd->sl)[1].reg=q2reg;
}
(*sd->sl)[args-1].styp=new_typ();
(*sd->sl)[args-1].styp->flags=VOID;
t=new_typ();
t->flags=FUNKT;
t->exact=add_sd(sd,FUNKT);
t->next=new_typ();
t->next->flags=ztyp;
v=add_var(name,t,EXTERN,0);
v->flags|=BUILTIN;
if(asm||nosidefx){
v->fi=new_fi();
if(asm) v->fi->inline_asm=asm;
if(nosidefx){
v->fi->call_cnt=v->fi->use_cnt=v->fi->change_cnt=0;
v->fi->flags=ALL_CALLS|ALL_USES|ALL_MODS|ALWAYS_RETURNS|NOSIDEFX;
}
}
}
return v;
}
struct const_list *initialization(struct Typ *t,int noconst,int level,int desi,struct struct_declaration *fstruct,struct const_list *first)
/* Traegt eine Initialisierung in eine const_list ein. */
{
struct const_list *cl,**prev;
np tree,tree2;
int bracket,desi_follows=0;
zmax i;
struct token mtok;
int f=t->flags&NQ;
if(ISFUNC(f)){error(42);return(0);}
if(ctok->type==LBRA){next_token();killsp();bracket=1;} else bracket=0;
if(ISARRAY(f)){
#ifdef HAVE_MISRA
/* removed */
#endif
if(t->dsize){
error(358);
}else if(zmeqto(t->size,l2zm(0L))&&level!=0){
error(359);
}else if(ctok->type==T_STRING&&t->next&&(t->next->flags&NQ)==CHAR){
killsp();
tree=string_expression();
first=tree->cl;
free_expression(tree);
}else{
struct const_list *last=first;
if(level==0&&!bracket) error(157);
for(i=l2zm(0L);desi_follows||((zmeqto(t->size,l2zm(0L))||!zmleq(t->size,i)||ctok->type==LBRK)&&ctok->type!=RBRA);i=zmadd(i,l2zm(1L))){
if(!zmleq(i,0)){
if(ctok->type==COMMA){next_token();killsp();} else break;
if(ctok->type==RBRA) break;
}
/* check for first designated initializer */
cl=designator(t,first);
if(!cl){
/* no designator */
cl=insert_cl(last,i);
cl->other=initialization(t->next,c99?noconst:0,level+1,0,fstruct,cl->other);
if(cl->other&&zmeqto(cl->other->idx,l2zm(-2L))){
first=cl->other;
first->other=0;
break;
}
}else{
/* designator: store current object and handle remaining designators */
i=cl->idx;
if(ctok->type!=ASGN){
if(ctok->type!=LBRK&&ctok->type!=DOT)
error(355);
}else{
cl->other=0;
next_token();killsp();
}
cl->other=initialization(t->next,c99?noconst:0,level+1,1,fstruct,cl->other);
}
if(cl->next==first) first=cl;
last=cl;
killsp();
if(desi&&!bracket)
break;
desi_follows=0;
if(ctok->type==COMMA){
copy_token(&mtok,ctok);
next_token();killsp();
if(ctok->type==LBRK)
desi_follows=1;
push_token(&mtok);
}
}
if(bracket&&zmeqto(i,l2zm(0L))) error(360);
#ifdef HAVE_MISRA
/* removed */
/* removed */
/* removed */
/* removed */
#endif
}
}else if(ISSTRUCT(f)&&(bracket||!noconst||c99)){
if(t->exact->count<=0)
{error(43);return(0);}
#ifdef HAVE_ECPP
/* removed */
#endif
prev=0;
if(level==0&&!bracket&&!c99) error(157);
for(i=l2zm(0L);desi_follows||(!zmleq(t->exact->count,i)&&ctok->type!=RBRA);i=zmadd(i,l2zm(1L))){
if(!desi_follows&&(*t->exact->sl)[zm2l(i)].identifier[0]==0) continue; /* unnamed bitfield */
if(!zmleq(i,0)){
if(ctok->type==COMMA){next_token();killsp();} else break;
if(ctok->type==RBRA) break;
}
cl=designator(t,first);
if(!cl){
cl=insert_cl(first,l2zm((long)i));
cl->other=initialization((*t->exact->sl)[zm2l(i)].styp,c99?noconst:0,level+1,0,!fstruct&&!bracket&&zmeqto(i,l2zm(0L))?t->exact:fstruct,cl->other);
if(cl->other&&zmeqto(cl->other->idx,l2zm(-2L))){
if(fstruct){
first=cl->other;
first->other=0;
}else{
*cl=*cl->other;
cl->idx=l2zm(-1L);
cl->other=0;
first=cl;
}
break;
}
}else{
i=zm2l(cl->idx);
if(ctok->type!=ASGN){
if(ctok->type!=LBRK&&ctok->type!=DOT)
error(355);
}else{
next_token();killsp();
cl->other=0;
}
cl->other=initialization((*t->exact->sl)[zm2l(i)].styp,c99?noconst:0,level+1,1,fstruct,cl->other);
}
if(cl->next==first) first=cl;
if(desi&&!bracket)
break;
desi_follows=0;
if(ctok->type==COMMA){
copy_token(&mtok,ctok);
next_token();killsp();
if(ctok->type==DOT)
desi_follows=1;
push_token(&mtok);
}
}
if(bracket&&zmeqto(i,l2zm(0L))) error(360);
#ifdef HAVE_MISRA
/* removed */
/* removed */
/* removed */
/* removed */
#endif
}else if(ISUNION(f)&&(c99||bracket||!noconst)){
if(t->exact->count<=0)
{error(44);return(0);}
if(level==0&&!bracket&&!c99) error(157);
desi_follows=1;
while(desi_follows){
cl=designator(t,first);
if(!cl){
cl=insert_cl(first,l2zm((long)0));
cl->other=initialization((*t->exact->sl)[0].styp,c99?noconst:0,level+1,0,!fstruct&&!bracket?t->exact:fstruct,cl->other);
if(cl->other&&zmeqto(cl->other->idx,l2zm(-2L))){
if(fstruct){
first=cl->other;
first->other=0;
}else{
*cl=*cl->other;
cl->other=0;
cl->idx=l2zm(-1L);
first=cl;
}
break;
}
}else{
i=zm2l(cl->idx);
if(ctok->type!=ASGN){
if(ctok->type!=LBRK&&ctok->type!=DOT)
error(355);
}else{
next_token();killsp();
cl->other=0;
}
cl->other=initialization((*t->exact->sl)[zm2l(i)].styp,c99?noconst:0,level+1,1,fstruct,cl->other);
}
first=cl;
if(desi&&!bracket)
break;
desi_follows=0;
if(ctok->type==COMMA){
copy_token(&mtok,ctok);
next_token();killsp();
if(ctok->type==DOT)
desi_follows=1;
else
push_token(&mtok);
}
}
}else{
int oldconst=const_expr;
tree2=tree=assignment_expression();
if(!tree){error(45);return(0);}
if(!noconst) const_expr=1;
if(!type_expression(tree)){free_expression(tree); const_expr=oldconst;return 0;}
const_expr=oldconst;
tree=makepointer(tree);
/* check for complete struct assignment in dynamic initialization */
if(noconst&&(ISSTRUCT(tree->ntyp->flags)||ISUNION(tree->ntyp->flags))&&fstruct==tree->ntyp->exact){
first=mymalloc(CLS);
first->tree=tree;
first->next=first->other=0;
first->idx=l2zm(-2L);
return first;
}
if(!test_assignment(t,tree)){free_expression(tree); return 0;}
if(!noconst){
/* nur Konstanten erlaubt (bei Arrays/Strukturen etc. oder static) */
if(tree->flags!=CEXPR){
/*while(tree->flags==CAST) tree=tree->left;*/
if(!tree->sidefx/*tree->flags==ADDRESS||tree->flags==ADDRESSS||tree->flags==ADDRESSA*/){
const_expr=1;
gen_IC(tree,0,0);
const_expr=oldconst;
if(!(tree->o.flags&VARADR)){
/* hier fehlen noch viele Pruefungen */
free_expression(tree);error(46);
return(0);
}
tree->o.v->flags|=USEDASADR;
first=mymalloc(CLS);
first->next=first->other=0;
first->tree=tree;
first->idx=l2zm(0L);
killsp();
}else{
free_expression(tree);error(46);
return(0);
}
}else{
first=mymalloc(CLS);
first->idx=l2zm(0L);
first->next=first->other=0;
first->tree=0;
eval_constn(tree);
tree->ntyp->flags=t->flags;
insert_constn(tree);
first->val=tree->val;
free_expression(tree2);
killsp();
}
}else{
/* auch anderes erlaubt */
first=mymalloc(CLS);
first->next=first->other=0;
first->tree=tree;
killsp();
if(!tree->sidefx){
if(tree->flags==CEXPR){
eval_constn(tree);
tree->ntyp->flags=t->flags;
insert_constn(tree);
first->val=tree->val;
first->tree=0;
first->idx=l2zm(0L);
init_const_sz=zmadd(init_const_sz,szof(tree->ntyp));
init_const_cnt++;
free_expression(tree2);
}else{
first->idx=l2zm(-1L);
init_dyn_sz=zmadd(init_dyn_sz,szof(tree->ntyp));
init_dyn_cnt++;
}
}else{
init_dyn_sz=zmadd(init_dyn_sz,szof(tree->ntyp));
init_dyn_cnt++;
}
}
}
if(bracket){
if(ctok->type==COMMA){next_token();killsp();}
if(ctok->type==RBRA){next_token();killsp();} else error(128);
}
return(first);
}
#ifdef HAVE_ECPP
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
/* removed */
#endif
bb84e3173This file is pinned to the selected release. Download the original to open it in your design tool.