static void f_ext_decl(token_t * e1){    switch (EiC_lexan()) {      DECL:	decl(e1, token->Tok);	ff_ext_decl(e1);	break;      case ';':	break;      default:	EiC_error("Declaration error");	EiC_match(';', " ; ");    }}token_t *EiC_genTemporay(type_expr *type, int level){    token_t *e1 = xcalloc(sizeof(token_t),1);    extern symentry_t * EiC_nxtTemp(int obj, int level);    symentry_t * sym;    sym = EiC_nxtTemp(ID,level);    EiC_inittoken(e1);    SetTemp(type);    e1->Type = EiC_copytype(type);    e1->Val.sym =  sym;    e1->Tab = sym->nspace;    new_var(e1);    e1->Val = sym->val;    return e1;    }static void do_Gotos(code_t *c){    if(c->gotos) {	Label_t *go, *lab;	go = c->gotos;	while(go) {	    lab = c->labels;	    while(lab && strcmp(lab->name,go->name) != 0)		lab = lab->nxt;	    if(lab) 		ivalcode(c,go->loc) = lab->loc - go->loc;	    else		EiC_error("Missing label `%s' defined at line %d",go->name,instline(c,go->loc));	    go = go->nxt;	}    }}    static void ff_ext_decl(token_t * e1){    extern void EiC_UpdateEntry(symentry_t * sym);    int t;    switch (EiC_lexan()) {      case '{': /* handle funtion definition */	if (EiC_S_LEVEL > 1) {	  EiC_error("Illegal function definition in %s",EiC_RETURNEXPR->Sym->id);	  break; 	}	new_var(e1);	if((t = EiC_gotMissingNames(EiC_getInf(e1->Type))))            EiC_error("Missing name for Paramater %d",t);		if(EiC_ErrorRecover) /* force recovery */	    EiC_ErrorRecover = 0;		if((t = EiC_gettype(e1->Type)) == t_funcdec || t == t_func) {	    token_t e2;	    code_t *code;	    EiC_inittoken(&e2);	    if(EiC_HasHiddenParm(e1->Type)) 		EiC_addoffsettolevel(stand_tab, EiC_S_LEVEL+1,2);	    else		EiC_addoffsettolevel(stand_tab, EiC_S_LEVEL+1,1);	    retractlexan();	    if (e1->Sym->ass) {		EiC_warningerror("Function Re-definition of %s",e1->Sym->id);		EiC_freeFuncComments(EiC_getInf(e1->Type));       	    }	    /* Update declaration to definition. */	    EiC_exchtype(t_func, e1->Type);	    EiC_INFUNC = 1;	    EiC_RETURNON++;	    EiC_RETURNEXPR = e1;	    EiC_stmt(&e2);	    EiC_RETURNON--;	    EiC_reset_env_pointers(e1, LSP);	    do_Gotos(&e2.Code);	     /* remove reducear,  if present */	    if(e2.Code.nextinst != 0) { 		if (e2.Code.inst[e2.Code.nextinst - 1].opcode ==		    reducear)		    e2.Code.nextinst--;		    addreturn(e1,&e2.Code);	    } else {		EiC_warningerror("Empty function definition");		EiC_generate(&e2.Code, eicreturn, &e2.Val, 0);    	    }	    if(!EiC_ParseError) {		if(e1->Sym->ass)		    EiC_killcode(e1->Sym);		code = (code_t *) xcalloc(1, sizeof(code_t));		e1->Sym->ass = 1;		*code = e2.Code;		EiC_ENV->AR[e1->Sym->val.ival].v.p.p = code;		codeName(code) = CurrentFileName();	    } else {		void EiC_cleancode(code_t *);		EiC_cleancode(&e2.Code);		EiC_freecode(&e2.Code);	    }			    EiC_freetype(e2.Type);	    e1->Type = NULL;	/* hide new type */	    EiC_INFUNC = 0;	} else {	    e1->Type = NULL;	    retractlexan();	}	break;      default:	if (e1->Val.sym) {	   	  if(token->Tok == '@') {   /* watch for reference declaration */	      e1->Type = EiC_revtype(e1->Type);	      e1->Type = EiC_addtype(t_ref,e1->Type);	      EiC_setAsBaseType(e1->Type);	  } 	  new_var(e1);	}	EiC_remlevel(EiC_S_LEVEL + 1);	if(token->Tok == ASS) {	    initialiser(e1);	    EiC_lexan();	} else if(token->Tok == '@') {	  handle_address_operator(e1);	  EiC_lexan();	}	fff_ext_decl(e1);    }}static void fff_ext_decl(token_t * e1){    if (RESET) {	EiC_reset_env_pointers(e1, LSP);	RESET--;    }    setBoundaryLimits(e1);    if(EiC_gettype(e1->Type) == t_array &&       !EiC_get_sizeof(nextType(e1->Type)))	EiC_error("Ilegal size specified for %s", e1->Sym->id);    if (token->Tok == ',') {		init_decl_list(e1);	e1->Type = NULL;	/* hide new type */	EiC_match(';', " ;");    } else {	retractlexan();	semi_colon(e1);    }}static void semi_colon(token_t * e1){    e1->Type = NULL;	/* hide new type */    if(!EiC_match(';', ";"))	retractlexan();}static void decl_spec(token_t * e1){    int sclass = 0;    void specifier(token_t *e1, int,int *sclass);    switch (token->Tok) {      STORECLASS:      TYPEQUAL:      TYPESPEC:	specifier(e1, token->Tok,&sclass);	if ((sclass == c_auto || sclass == c_register)	    && !(EiC_INFUNC || EiC_S_LEVEL > 1))	    EiC_error("Illegal storage class usage");	else if(INPARMLIST && sclass && sclass != c_register)	    EiC_error("Illegal storage class for parameter %s",EiC_LEXEM);	else	    e1->Sclass = sclass;	EiC_setAsBaseType(e1->Type);	/* default:	retractlexan();	*/    }}static void specifier(token_t *e1, int t,int *sclass){    /* This function was modelled from lcc32's     * specifier function     */    int cls, cons, sign, size, type, vol,ty;    cls = ty = vol = cons = sign = size = type=0;    if(sclass == NULL)      cls = c_auto;            while(1){      int *p, tt = t;      switch (t) {      case autosym:     tt = c_auto;     p = &cls; break;        case externsym:   tt = c_extern;   p = &cls; break;        case registersym: tt = c_register; p = &cls; break;        case staticsym:   tt = c_static;   p = &cls; break;        case typedefsym:  tt = c_typedef;  p = &cls; break;        case constsym:   p = &cons;       break;      case volatilesym:p = &vol;        break;      case signedsym:      case unsignedsym:p = &sign;       break;      case longsym:	if(size == longsym) {	  size = 0;	  tt = longsym+longsym;	}      case shortsym:   p = &size;      break;      case voidsym:    ty = t_void;   p = &type;   break;      case charsym:    ty = t_char;   p = &type;   break;      case intsym:     ty = t_int;    p = &type;   break;      case floatsym:   ty = t_float;  p = &type;   break;      case doublesym:  ty = t_double; p = &type;   break;      case enumsym:           case structsym:      case unionsym:   {	token_t e2;	p = &type;	EiC_inittoken(&e2);	if (t == enumsym)	     enum_spec(&e2);	     else	     st_un_spec(&e2, t);	/*	 *  test tag name.	 */	if (e2.Val.sym) {	  e1->Type = EiC_copytype(e2.Type);	  e1->Tab = stand_tab;	  if(INSTUN)	    addst_un_tag(e2.Val.sym);	} else {	  int sclass = e1->Sclass;	  *e1 = e2;	  e1->Sclass = sclass;	  if(t == enumsym)	    cast_t_enum(e1);	}      }      break;      case TYPENAME:	if(type == 0 && p != &sign && p != &size) {	  e1->Type = EiC_copytype(token->Val.sym->type);	  p = &type;	} else { /* allow for masking and redeclarations */#if 1	  if(checklevel(e1,token->Val.sym,EiC_S_LEVEL) || 	        cls == c_typedef) {	    token->Tok = ID;	    retractlexan();	  } else 	    EiC_error("Illegal use of typedef %s",token->Val.sym->id); 	  p = NULL;#else	  token->Tok = ID;	  retractlexan();	  p = NULL;#endif 	}	break;	          default:	retractlexan();	p = NULL;      }      if (p == NULL)	break;      if (*p)	EiC_error("invalid specification");      *p = tt;      t = EiC_lexan();    }    if(sclass)	*sclass = cls;    if(type == 0) {	type = intsym;	ty = t_int;    }    if ((size == shortsym && type != intsym)        ||  (size == longsym  && type != intsym && type != doublesym)        ||  (sign && type != intsym && type != charsym))                EiC_error("invalid type specification");    if (type == charsym && sign)	ty = sign == unsignedsym ? t_uchar : t_char;    else if (size == shortsym)	ty = sign == unsignedsym ? t_ushort : t_short;    else if (size == longsym && type == doublesym)	ty = t_double;    else if (size == longsym+longsym) { #ifndef NO_LONG_LONG      ty = t_llong;#else      ty = sign == unsignedsym ? t_ulong : t_long;#endif    } else if (size == longsym)	ty = sign == unsignedsym ? t_ulong : t_long;    else if (sign == unsignedsym && type == intsym)	ty = t_uint;          if(ty)	e1->Type = EiC_addtype(ty,e1->Type);    if (cons == constsym) {	if(INPARMLIST || EiC_INFUNC)  /* */	    setConstp(e1->Type);	else 	    	    setConst(e1->Type);	/*	if(EiC_INFUNC && !INPARMLIST && sclass) 	*sclass = c_static;	*/    }	    /* ignore volatile for now;       if (vol  == VOLATILE)       ty = qual(VOLATILE, ty);       */}static void init_decl_list(token_t * e1){    token_t e2;    do {	EiC_inittoken(&e2);		switch (EiC_lexan()) {	  DECL:	    e2.Type = EiC_copyBaseType(e1->Type);	    e2.Sclass = e1->Sclass;	    	    init_decl(&e2, token->Tok);	    if (RESET) {		EiC_reset_env_pointers(&e2, LSP);		RESET--;	    }	    EiC_concode(&e1->Code, &e2.Code);	    EiC_remlevel(EiC_S_LEVEL+1);	    setBoundaryLimits(&e2);	    break;	    	  default:	    EiC_error("Init decl list error");	}	if(EiC_gettype(e2.Type) == t_array &&	   !EiC_get_sizeof(nextType(e2.Type)))	    EiC_error("Ilegal size specified for %s", e2.Sym->id);    } while (EiC_lexan() == ',');    retractlexan();}static void init_decl(token_t * e1, int ty){    int t;    decl(e1, ty);#if 1      t = EiC_lexan();      if(t == '@') {   /* watch for reference declaration */       e1->Type = EiC_addtype(t_ref,e1->Type);       EiC_setAsBaseType(e1->Type);     }#endif    new_var(e1); #if 1    if(t == ASS)      initialiser(e1);    else if(t == '@') {       handle_address_operator(e1);    } else       retractlexan();#else   if (EiC_lexan() == ASS) {	initialiser(e1);    } else	retractlexan();#endif}static void initglobal(type_expr * type, void **addr,int lev);static void initstruct(type_expr * type, void **addr,int lev);static void do_struct(type_expr *type, void **addr,int lev);static int initarray(type_expr * type, void ** addr, int size, int lev);static void assign_var(type_expr *type, void *addr,int allow);static int do_array(type_expr *type, void ** addr, int size, int lev, int inc);static void structUnionCode(token_t * e1, token_t *e2){    val_t v;    v = e1->Val;    e1->Val = e1->Sym->val;    EiC_output(e1);    e1->Val = v;    v.ival = 1;    EiC_generate(&e1->Code, bump, &v, 0);    v.ival = EiC_get_sizeof(e2->Type);    EiC_generate(&e2->Code,refmem,&v,0);}static token_t * E1;static void initialiser(token_t * e1){    int t;    int peek = EiC_lexan();    retractlexan();        if(EiC_GI(e1) == 0) {  /* global or static local variable */	E1 = e1;	if ((t =EiC_gettype(e1->Type)) <= t_pointer) { /* get scalars */	    int v = 1;	    if(e1->Sclass & c_static) /* catch statics */		v = 0;	    if(!isconst(e1->Type))  				assign_var(e1->Type,&EiC_ENV->AR[e1->Sym->val.ival].v,v);	    else {		assign_var(e1->Type,&e1->Sym->val,v);		switch(EiC_gettype(e1->Type)) {		case t_char:   e1->Sym->val.ival = e1->Sym->val.cval;break;		case t_uchar:  e1->Sym->val.ival = e1->Sym->val.ucval;break;		case t_short:  e1->Sym->val.ival = e1->Sym->val.sval;break;		case t_ushort: e1->Sym->val.ival = e1->Sym->val.usval;break;		case t_float:   e1->Sym->val.dval = e1->Sym->val.fval;break;		}	    }	} else { 	    if(!isconst(e1->Type))		initglobal(e1->Type,&EiC_ENV->AR[e1->Sym->val.ival].v.p.p,0);	    else {		initglobal(e1->Type,&e1->Sym->val.p.p,0);	    }	}    } else {		if ((t =EiC_gettype(e1->Type)) <= t_pointer /* local scalar types */	    || ((t == t_struct || t==t_union) && peek != '{')  	    ) { 	    if(isconst(e1->Type)) 		assign_var(e1->Type,&e1->Sym->val,0);	    else {		token_t e2;		val_t h; 		EiC_inittoken(&e2);		EiC_assign_expr(&e2);		if (isconst(e2.Type)) {		    EiC_castconst(&e2,e1,0);	    		    h = e1->Val;		    e1->Val = e1->Sym->val;		    EiC_generate(&e1->Code,pushval,&e2.Val,0);		    EiC_do_stooutput(e1);		    e1->Val = h;		    EiC_freetoken(&e2);		} else {		    EiC_output(&e2);		    EiC_castvar(&e2,e1,0);		    if (t == t_struct || t == t_union)			structUnionCode(e1,&e2);		    EiC_concode(&e1->Code,&e2.Code);		    h = e1->Val;		    e1->Val = e1->Sym->val;		    EiC_do_stooutput(e1);		    e1->Val = h;		}		EiC_freetoken(&e2);	    }	} else if(EiC_INFUNC) {	    /* code for initialising automatic aggregate types */	    extern unsigned EiC_ASPOT;	    int s2, s1 = EiC_get_sizeof(e1->Type);	    val_t v;	    E1 = e1;	    	    if(s1)		v.p.p = xcalloc(1,s1);	    else		v.p.p = NULL;	    initglobal(e1->Type,&v.p.p,0);	    if((s2 = EiC_get_sizeof(e1->Type)) > s1)		EiC_ASPOT += s2 - s1;	    EiC_add_func_initialiser(EiC_getInf(EiC_RETURNEXPR->Type),v.p.p);	    EiC_generate(&e1->Code,minit,&v,s2);	} else		    EiC_error("Initialisation not "		  "supported for non scalar local types");	    }}static void initglobal(type_expr * type, void **addr, int lev){    switch(EiC_gettype(type)) {      case t_array:	initarray(type,addr,0,lev); break;      case t_struct:	initstruct(type,addr,lev); break;      case t_union: