} else {
    	fprintf(fp," va_alist )  va_dcl\n{\n");
	fprintf(fp,"    void Auto_EiC_CallBack(code_t *callback, va_list ap);\n");
	fprintf(fp,"    va_list ap; va_start(ap);\n");
	fprintf(fp,"    Auto_EiC_CallBack(%s%d,ap);\n",callName,callNo[p]);
    } 
	
    fprintf(fp,"\n    EiC_callBack(%s%d);\n",callName,callNo[p]);

    if(EiC_gettype(nextType(t)) != t_void) {
	fputs("    return EiC_ReturnValue( ",fp);
	/*EiC_showdectype(nextType(t),0,fp);*/
	EiC__generateType(nextType(t),"",fp,1);
	fputs(");\n",fp);
    }
    if(var)
	fputs("    va_end(ap);\n",fp);
    
    fputs("}\n\n",fp);

}



static void genArg(type_expr * t, int idx, FILE *fp)
{
    int ob;
   if ((ob = EiC_gettype(t)) == t_void) {
      return;
   }

   if(ob == t_pointer) {
       int k = EiC_gettype((nextType(t)));
       if(EiC_IsFunc(k)) {
	   k = 0;
	   while(k<Ncalls && callpos[k] != idx) k++;
	   fprintf(fp,"%s%d",middleName,callNo[k]+adjustNum);
	   return ;
       }
   }
       
    fputs("arg(",fp);
    fprintf(fp,"%d",idx);
    fputs(",getargs(),",fp);

	switch (ob) {
	  case t_char:  fputs("char)", fp); break;
	  case t_uchar: fputs("char)", fp); break;
	  case t_short: fputs("short)", fp); break;
	  case t_ushort:fputs("short)", fp); break;
	  case t_int:   fputs("int)", fp); break;
	  case t_uint:  fputs("unsigned)", fp); break;
	  case t_long:  fputs("long) ", fp); break;
	  case t_ulong: fputs("unsigned long)", fp); break;
	  case t_float: fputs("float)", fp); break;
	  case t_double:fputs("double)", fp); break;
	  case t_pointer:
	      fputs("ptr_t).p",fp);
	      break; 
	  default: fputs("Uknown identifier", fp); return;
	}
}

static void genAffect(type_expr * t, int expand, FILE *fp)
{
 
	fputs("\t", fp);
	switch (EiC_gettype(t)) {
	  case t_char: 
	  case t_short:
	  case t_int:   fputs("v.ival = ", fp); break;
	  case t_uchar:
	  case t_ushort:
	  case t_uint:  fputs("v.uival = ", fp); break;
	  case t_long:  fputs("v.lval = ", fp); break;
	  case t_ulong: fputs("v.ulval = ", fp); break;
	  case t_float: 
	  case t_double:fputs("v.dval = ", fp); break;

	  case t_pointer: 
	    if(isunsafe(t)) 
	      fputs("v.p.ep = (void*)ULONG_MAX;\n"
		    "\tv.p.sp = v.p.p = ",fp);
	    else if(issafe(t)) 
	      fputs("v.p.ep = v.p.sp = v.p.p = ", fp);
	    break;
	  case t_void:  break;
	  case t_hidden: break;
	    
/*	  case t_array:
	    fprintf(fp,"ARY[%d]",(int) EiC_getInf(t));
	    break;
	  case t_union:
	  case t_struct:
	    S = EiC_getInf(t);
	    if(!S) {
		fputs("Incomplete", fp);
		break;
	    }
	    if (EiC_gettype(t) == t_struct)
		fprintf(fp,"struct: size  %u bytes",S->tsize);
	    else
		fprintf(fp,"union: size  %u bytes",S->tsize);
	    if (expand) {
		level++;
		fputc('\n', fp);
		if (level <= 2) {
		    int j;
		    for (i = 0; i < S->n; i++) {
			for (j = 0; j < level; j++)
			    fputc('\t', fp);
			fputs(S->id[i], fp);
			fputs(" -> ", fp);
			EiC_showdectype(S->type[i], expand,fp);
			fputc('\n', fp);
		    }
		}
		level--;
	    }
	    break;
	  case t_ref: fputs("Reference ",fp);break;
	  case ID: fputs("Identifier ", fp); break;
*/
	  default: fputs("Uknown identifier", fp); return;
	}
}

static void genCall(type_expr *t, char *fname, FILE *fp)
{
    static int level = 0;
    func_t *F;
    int i;

    F = (func_t *) EiC_getInf(t);
    level++;

    fputs("\n", fp);

    if(Ncalls) {
	int k;
	for(k=0;k<Ncalls;++k) 
	    fprintf(fp,"\t%s%d = arg(%d,getargs(),ptr_t).p;\n",
		    callName,callNo[k],callpos[k]);
    }

    if(nextType(t)) {
	t = nextType(t);
	genAffect(t,0,fp);
	if(t)
	    while(nextType(t))
		t = nextType(t);
    }
    
    fputs(fname,fp);
    fputs("(", fp);
    if (F && getFNp(F)) {
	for (i = 0; i < getFNp(F); i++) {
	    genArg(getFPty(F,i), i, fp);
	    if(i < getFNp(F)-1) {
		fputs(",\n", fp);
		fputs("\t\t", fp);
	    }
	}
	fputs(");\n", fp);
    }
    else
	fputs(");\n", fp);

    level--;
}

static void genMultiCall(type_expr *t, char *fname, FILE *fp)
{
    static int level = 0;
    func_t *F;
    int i,n;
    type_expr *T;

    F = (func_t *) EiC_getInf(t);
    level++;

    fputs("\tstatic int nb = 0;\n\n",fp);

    fprintf(fp,"\tswitch(nb)\n");
    fprintf(fp,"\t{\n");
    for (n = 0;n < MULTIPLEX;++n)
    {
	adjustNum = n+1-MULTIPLEX;
	fprintf(fp,"\tcase %d :\n",n);

	if(Ncalls) {
	    int k;
	    for(k=0;k<Ncalls;++k) 
		fprintf(fp,"\t%s%d = arg(%d,getargs(),ptr_t).p;\n",
			callName,callNo[k]+adjustNum,callpos[k]);
	}

	if (n == 0)
	{
	    T = t;
	}
	else
	{
	    t = T;
	}

	if(nextType(t)) {
	    t = nextType(t);
	    genAffect(t,0,fp);
	    if(t)
		while(nextType(t))
		    t = nextType(t);
	}

	fputs(fname,fp);
	fputs("(", fp);
	if (F && getFNp(F)) {
	    for (i = 0; i < getFNp(F); i++) {
		genArg(getFPty(F,i), i, fp);
		if(i < getFNp(F)-1) {
		    fputs(",\n", fp);
		    fputs("\t\t", fp);
		}
	    }
	    fputs(");\n", fp);
	}
	else
	    fputs(");\n", fp);

	level--;
	fprintf(fp,"\tbreak;\n");
    }
    fprintf(fp,"\t}\n");
    fprintf(fp,"\t++nb;\n");
    fprintf(fp,"\tnb %%= %d;\n",MULTIPLEX);
    adjustNum = 0;
}


static void genFunctions(int tab, int expand, 
		  token_t * e1, 
		  char *mname, 
		  int allowed(), FILE *fp)
{
    int i, n, t;
    int multiplexed;
    symentry_t *sym;
    
    for (i = 0; i < HSIZE; i++)
	for (sym = EiC_HTAB[i]; sym; sym = sym->next) {
	    if ((t = EiC_gettype(sym->type)) == t_eic || sym->nspace != tab)
		continue;

	    if(e1 && e1->Type && ! EiC_sametypes(e1->Type,sym->type))
		continue;

	    if(mname && strcmp(mname,sym->fname) != 0)
		continue;
	    
	    if(allowed && !allowed(t))
		continue;

	    n = 1;
	    multiplexed = 0;
	    while (n)
	    {
		if(DoCallBackNames(EiC_getInf(sym->type),fp)) {
		    int k = 0;
		    if (!multiplexed)
		    {
			multiplexed = 1;
			n = MULTIPLEX;
		    }
		    while(k<Ncalls) {
			genCallBackFunc(sym->type,k++,fp);
		    }
		}
		--n;
	    }

	    fputs("static val_t eic_",fp);
	    fputs(sym->id, fp);
	    fputs("(void)\n",fp);
	    fputs("{\n",fp);
	    
	    fputs("\tval_t v;\n",fp);
	    /*fputs("\tstatic int nb = 0;\n",fp);*/

	    if (multiplexed)
	    {
		genMultiCall(sym->type, sym->id, fp);
	    }
	    else
	    {
		genCall(sym->type, sym->id, fp);
	    }
	    
	    fputs("\n",fp);
	    fputs("\treturn v;\n",fp);
	    fputs("}\n\n",fp);

	}
}






static void genInterface(int tab, 
		  int expand, 
		  token_t * e1, 
		  char *mname, 
		  FILE *fp)
{
    char *pt;
    int i, t;
    symentry_t *sym;
    char iname[255]; 
  
    strcpy(iname,mname);
    pt = strrchr(iname,'.');
    if (pt)
    {
    	*pt = '\0';
    }
    pt = strrchr(iname,'/');
    if (pt)
    {
    	++pt;
    }
    else
    {
    	pt = iname;
    }

    fputs("/**********************************/\n\n",fp);

    fprintf(fp,"void module_%s()\n",pt);
    fputs("{\n",fp);


    for (i = 0; i < HSIZE; i++)
	for (sym = EiC_HTAB[i]; sym; sym = sym->next) {

	    if ((t = EiC_gettype(sym->type)) == t_eic || sym->nspace != tab)
		continue;

	    if(e1 && e1->Type && ! EiC_sametypes(e1->Type,sym->type))
		continue;

	    if(mname && strcmp(mname,sym->fname) != 0)
		continue;
	    
	    if(EiC_IsFunc(t) || sym->sclass == c_typedef || sym->sclass == c_enum)
		continue;

            fprintf(fp,"\tEiC_parseString(\"");
	    EiC__generateType(sym->type,sym->id,fp,1);
	    fprintf(fp," @ %%ld;\", (long)&%s);\n",sym->id);
	}



    for (i = 0; i < HSIZE; i++)
	for (sym = EiC_HTAB[i]; sym; sym = sym->next) {

	    if ((t = EiC_gettype(sym->type)) == t_eic || sym->nspace != tab)
		continue;

	    if(e1 && e1->Type && ! EiC_sametypes(e1->Type,sym->type))
		continue;

	    if(mname && strcmp(mname,sym->fname) != 0)
		continue;
	    
	    if(!EiC_IsFunc(t))
		continue;

            fprintf(fp,"\tEiC_add_builtinfunc(\"%s\",eic_%s);\n",sym->id,sym->id);
	}

    fputs("}\n\n",fp);
    fputs("/**********************************/\n\n",fp);
}

static void genHeader(char *mname, FILE *fp)
{
    fputs("#include <stdlib.h>\n"
	  "#include <varargs.h>\n"
	  "#include <limits.h>\n"
	  "#include \"eic.h\"\n",fp);
    fprintf(fp,"#include \"%s\"\n",mname);
    fputs("\n\n",fp);
}

static void genModule(int tab, int expand, token_t * e1, char *mname)
{
  FILE *fp = stdout;

  if(EiC_lexan() == INT)
      MULTIPLEX = token->Val.ival;
  else
      retractlexan();

  if(EiC_lexan() == STR) {
    fp = fopen(token->Val.p.p,"w");
    EiC_formatMessage("redirecting to [%s]\n",(char*)token->Val.p.p);
    if(!fp) {
      EiC_warningerror("Failed to open file %s\n", token->Val.p.p);
      fp = stdout;
    }
  } else
    retractlexan();

  genHeader(mname,fp);
  genFunctions(tab, expand, e1, mname, EiC_IsFunc,fp);
  genInterface(tab, expand, e1, mname,fp);


  if(fp != stdout)
    fclose(fp);
}

/*
 *
 *	NEW EiC COMMAND !
 *	By Jean-Bruno Richard
 *
 */
static int genCommand(void)
{
    char EiC_nextchar(void);
    int EiC_IsIncluded(char *fname);
    char *buf;
    
    callBack=0;
    buf = getNextInput();
    if(buf[0]) {
	if(!EiC_IsIncluded(buf))
	     EiC_warningerror("Failed to find %s",buf); 
	else {
	    genModule(stand_tab,0,NULL,buf);
	}
    } else 
	     EiC_warningerror("Need a included file name for generating module"); 
    return 1;
}
#endif



static void establish_ARs(void)
{
    EiC_ENV->LARsize = 4000;
    EiC_ENV->ARsize =  3000;
    EiC_ENV->LAR =(AR_t*)xmalloc(sizeof(AR_t)*EiC_ENV->LARsize);
    EiC_ENV->AR = (AR_t*)xmalloc(sizeof(AR_t)*EiC_ENV->ARsize);
}

void EiC_init_EiC(void)
{
    EiC_ENV = (environ_t *) xcalloc(1, sizeof(environ_t));
    EiC_ENV->CODE.Filename = "::EiC::";

    establish_ARs();
    EiC_initpp();
    EiC_work_tab = stand_tab;
    /*init_hashtab(31);*/
    /* add EiC command line functions */
    add_eicfunc("listcode", toggle_listcode);
    add_eicfunc("interpreter", toggle_interp);
    add_eicfunc("variables", showhashtab);
    add_eicfunc("exit", EiC_exit_EiC);
    add_eicfunc("quit", EiC_exit_EiC);
    add_eicfunc("timer", toggle_timer);
    add_eicfunc("showline", toggle_showline);
    add_eicfunc("show", show);
    add_eicfunc("memdump", toggle_memdump);
    add_eicfunc("memtrace", toggle_memtrace);
    add_eicfunc("rm", rm);
    add_eicfunc("trace",toggle_trace);
    add_eicfunc("verbose",toggle_verbose);
    add_eicfunc("interface",toggle_interface);

#ifndef NO_HISTORY
    add_eicfunc("history",showhistory);
#endif
    add_eicfunc("help", showHelp);
    add_eicfunc("status",EiCstatus);
    add_eicfunc("includes",toggle_includes);
    add_eicfunc("files",filesCommand);
    add_eicfunc("clear",clearCommand);
#ifndef NO_AUTOGEN
    add_eicfunc("gen",genCommand);
    add_eicfunc("reset",ResetEiC);
    /* Remenber to modify help message too... */
#endif
}