// C Source File TIGCC 0.94 SP4
// Created 07/11/2003; 18:26:20

#define USE_TI89              // Compile for TI-89
#define USE_TI92PLUS          // Compile for TI-92 Plus
#define USE_V200              // Compile for V200

#define CHARVAR_TAG 0xEA
#define INTVAR_TAG 0xEB
#define LONGVAR_TAG 0xEC
#define PTRVAR_TAG 0xED
// #define OPTIMIZE_ROM_CALLS // Use ROM Call Optimization

#define MIN_AMS 101           // Compile for AMS 1.01 or higher

#define SAVE_SCREEN           // Save/Restore LCD Contents

#include <tigcclib.h>         // Include All Header Files
//#include "pile.h"
//#include "preproc.h"

unsigned char *lbl_str[100],*goto_str[100],*ptr,*srcptr,*lineptr,*dataptr,*elineptr,*tempptr/*,*startblocklist[10],*endblocklist[10],ptrvars[50]*/;		//srcptr = pointe au premier char ; line_ptr = pointe la ligne ; tempptr pointe un caractere dans la ligne
unsigned char varnum,srcname[20]/*,outputfile[20],commandstr[80],leftstr[40],rightstr[40],nameblocklist[17*10],v[10],charstrlist[9*50],intstrlist[9*50],longstrlist[9*50],ptrstrlist[9*50],charvars[50]*/;
char *fposlbl[100],*fposgoto[100]/*,*whilefpos[20],*endwhilefpos[20]*/,current_func_str[10];
unsigned int dim_list,numlbl,lblnum,numgoto,gotonum,foncnum,foncnum2,srcsize,numline,line,numblock/*,lineblocklist[10]*/,nc,ni,nl,np/*,intvars[50]*/,nfonc,size,nsvar,ndvar,sizevarlist,posnum;
unsigned long /*longvars[50],*/nbelemm,dim_nilist;

//IF ELSE ENDIF
unsigned char alif[257],aif,aeif;
//WHILE ENDWHILE
unsigned char alw[257],aw,aew;
/*
//FOR ENDFOR
unsigned char alf[257],af,aef;
//LOOP ENDLOOP
unsigned char all[257],al,ael;		//attention ! LOOP ENDLOOP a ne pas utiliser
*/

//tampon pour les string de var de a à z
char str_az[]={'k','z','y','w','a',0};


char is_ok;	//ok pour END_TAG

//unsigned int else_num_init[257];
//unsigned int numwhile,numfor,numif,iflevel,ne,ni,nf,ifi,nj;
ESI tmp_esi;
ESI file_pos;
ESI file_ori;
ESI esi_end_nilist;
ESI esi_start_nilist;
char *nilist_size_array_ptr;

fpos_t pos1;
fpos_t pos2;

//numlbl=nombre de labels
//lblnum=num du lbl
//nfonc=nombre de fonctions
//foncnum=num de la fonction
//varnum=numero de la var si deja defini
unsigned char *special_var[]={"start","end","svar","enddef"}; //correspond aux variable non utilisable dim=nsvar
unsigned char *def_var[256]; //correspond aux variables definies dim=ndvar et labels
//unsigned char *fonc[]={"init","clrscr","keywait","enddef"};
							//0				1					2					3					4					5					6					7					8					9


unsigned char
 *fonc[]={		""		,"GUCHAR"	,	"GSLVAR","adress"	,		"FLBL",	"FGOTO"	,"keywait",		"isz"	,		"dsz"	,		"iff"	, //0
						"freeh"	,	"endh"	,	"exech"	,		""		,	"INDIR"	,"printf1","printf2",	""			,"prints",	"elsee"	, //1
					"svscroff","fedwhil",	"finish",	"ifs"		,"strlen"	,	"printc","sprintf",	"chars"	,	"strcat",	  ""    , //2
							""		,"GUINT"	,		""		,		""		,		""		,"printld","printxy",		""		,"GULONG"	,	"inter"	, //3
						"dline"	,"dmline"	,	"gmode"	,"sprt8"	,"sprt16"	,		""		,	"code"	,"interoff","interon",		""		, //4
						"setlcd",	"dpix"	,"gpix"		,"sprt32","fillrect","clrlcd"	,"keytest","int1off","int1on" ,"ifthen"	, //5
						"getlcd",	"fwhile",		""		,		""		,"scrrect",		""		,		""		,"int5off","int5on" ,	"elsee"	, //6
					"grayon"	,"grayoff","light"	,	"dark"	,		""		,"drawstr","setfont","freet"	,"settimer",	"endiff", //7
					"gotopos"	,	"pos"		,		"jsr" ,	"rts"		,		"fonc",		""		,		""		,"timerexp","timerval",		""		, //8
					"lscroll"	,"rscroll","uscroll","bscroll",		"lrol",	"rrol"	,		""		,  "idle" ,	"memcpy",		""		, //9
						"clrscr","frandom",	"gsprt"	,"lscroll2","rscroll2","uscroll2","bscroll2",""		,"memmove",		""		, //10
						"fopen"	,	"fclose",	"fputc"	,	"fgets"	,	"fgetc"	,	"fputs"	,	"fseek"	,	"gets"	,		""		,		""		, //11
							"nott",		""		,		"neg"	,		""		,		""		,		""		,	"ftell"	,		""		,		"sto"	,		""		, //12
							"xorr",		"orr"	,		"andd",		"inf"	,	"infeq"	,		"eq"	,	"supeq"	,	"sup"		,	"noteq"	,		"add", //13
							""		,		"sub"	,		""		,		"mul"	,		""		,		"div"	,		""		,		""		,		"up"	,	"second", //14
							"def"	,	"enddef",		""		,		"fc"	,		"arg"	,		"rtn"	,	"group"	,		""		,		"down",	"shiftt", //15
						"repeat",		""		,"savescr","loadscr",		""		,		"lb"	,		"lw"	,		"ll"	,	"leftt"	,"diamond", //16
							""		,	"os"		,		"toos",	"newstr",		""		,		"wb"	,		"ww"	,		"wl"	,	"rightt",	"alpha"	, //17
						"strcmp","strcpy"	,	"gkey","keydelay"	,"keyspeed",	""		,		""		,		""		,		""		,		""		, //18
					"pokeb"		,	"pokew"	,	"pokel"	,		""		,		""		,		""		,		""		,		""		,		""		,		""		, //19
					"peekb"		,	"peekw"	,	"peekl"	,		""		,"loadasm",		""		,		""		,		""		,		""		,		""		, //20
					"newstr"	,		""		,		""		,		""		,"execasm",		""		,"nilist"	,	"mklist",		""		,		""		, //21
							"map"	,	"multi"	,		"two"	,		""		,"closeasm",	""		,		""		,		""		,		""		,"ENDTAG"	, //22
							""		,		""		,		""		,	"finish",	"seqb"	,	"ctup"	,	"ctdown",		""		,		""		,		""		, //23
					"debugon"	,"debugoff",		""		,	""		,	"seqw"	,		""		,		""		,		""		,"execbas",		""		, //24
							"nop"	,	"malloc",		"free","memset"	,	"seql" 	,"asmcall",		""		,		""		,		""		,	"enddef"}; //25


unsigned char narglist[]={0,      0   ,0         ,   0};




struct cellule
{
	struct cellule* pt;		//pointeur de la prochaine cellule
	ESI pos;							//valeur du bookmark
};
typedef struct cellule CELLULE;
struct BKM
{
	CELLULE *p1;
	CELLULE *p2;
	CELLULE *p3;
	int n1,n2,n3;
} bkm;
FILE *fout;
ESI argptr;
//0x01 = CHAR_TAG
//IM_TAG (TAG deja defini)
long mabs(long n);


//LES FONCTIONS CI DESSOUS SONT UNE COPIE DU HEADER PREPROC.h
void AppendCharToFile2 (HANDLE h, unsigned char c)
{
  char *base = HeapDeref(h);
  unsigned short len = *(unsigned short*)base;
  if (len > HeapSize(h) - 10) return;
  *(unsigned short*)base = len + 1;
  base[len+2] = c;
}
void AppendBlockToFile2 (HANDLE h, void *addr, unsigned short len)
{
  unsigned short i;
  for (i = len; i; i--) AppendCharToFile2 (h, *((char*)addr)++);
}
void CloseCreatedFile_type (HANDLE h,int type)
{
  if(type==STR_TAG) AppendCharToFile2 (h,0);
  AppendCharToFile2 (h,type);
  HeapUnlock (h);
  HeapRealloc (h, *(unsigned short*)HeapDeref(h) + 3);
}
void AppendStrToFile1 (HANDLE handle, void *str)
{
	AppendBlockToFile2 (handle, str, strlen(str));
}
HANDLE CreateFile2 (const char *FileName)
// Returns a handle, H_NULL in case of error
{
  HANDLE h;
  SYM_ENTRY *sym_entry;
  char str[30], *sptr = str;
  *sptr = 0; while ((*++sptr = *FileName++));
  if (!(h = HeapAlloc (HeapMax ()))) return H_NULL;
  if (!(sym_entry = DerefSym (SymAdd (sptr))))
    {
      HeapFree (h);
      return H_NULL;
    }
  *(long*) HeapDeref (sym_entry->handle = h) = 0x00010000;	//Je pense que ça inscrit la taille (1 + 3 = 4 octets) du fichier et le type (ici type =0x00)
  return h;
}


long dim_tios_list(ESI listptr)
{
	long d;
	ESI argdeb;
	d=0;
	if(*listptr!=LIST_TAG) exit2("dim_tios_list : error");
	listptr--;
	while(*listptr!=END_TAG) { d++;listptr=next_expression_index (listptr);}
	if(*listptr!=END_TAG) exit2("\nEND_TAG expected");
	esi_end_nilist=listptr;
	//printf("\ndim list=%d",(int)d);
	return d;
}
HANDLE CreateFile (const char *FileName)
// Returns a handle, H_NULL in case of error
{
  HANDLE h;
  SYM_ENTRY *sym_entry;
  char str[30], *sptr = str;
  *sptr = 0; while ((*++sptr = *FileName++));
  if (!(h = HeapAlloc (/*HeapMax ()*/1000))) return H_NULL;
  if (!(sym_entry = DerefSym (SymAdd (sptr))))
    {
      HeapFree (h);
      return H_NULL;
    }
  *(long*) HeapDeref (sym_entry->handle = h) = 0x00010000;
  return h;
}

void AppendCharToFile (HANDLE h, unsigned char c)
{
  char *base = HeapDeref(h);
  unsigned short len = *(unsigned short*)base;
  if (len > HeapSize(h) - 10) return;
  *(unsigned short*)base = len + 1;
  base[len+2] = c;
}

void AppendBlockToFile (HANDLE h, void *addr, unsigned short len)
{
  unsigned short i;
  for (i = len; i; i--) AppendCharToFile (h, *((char*)addr)++);
}

void CloseFile (HANDLE h)
{
  AppendCharToFile (h,0); AppendCharToFile (h,0x2D);
  HeapUnlock (h);
  HeapRealloc (h, *(unsigned short*)HeapDeref(h) + 3);
}

void mem_to_file(const char* ptrr,unsigned int size_buffer,const char* filenamee)
{
  HANDLE h;
  h = CreateFile (filenamee);
  if(h==H_NULL) exit2("Mem error");
  AppendBlockToFile (h, ptrr, size_buffer);
  CloseFile (h);
}

void fputc2(short c, FILE *stream)
{
	file_pos++;
	fputc(c,stream);
}
void init_bkm(void)
{
	bkm.n1=0; bkm.n2=0; bkm.n3=0;
	if(	(bkm.p1=(CELLULE*)malloc(sizeof(CELLULE)))==NULL || (bkm.p2=(CELLULE*)malloc(sizeof(CELLULE)))==NULL || (bkm.p3=(CELLULE*)malloc(sizeof(CELLULE)))==NULL)
	{
		exit2("memory alloc error");
	}
	(bkm.p1)->pt=NULL; (bkm.p2)->pt=NULL; (bkm.p3)->pt=NULL;
	(bkm.p1)->pos=NULL; (bkm.p2)->pos=NULL; (bkm.p3)->pos=NULL;
}


CELLULE* get_ptr_cellule(char type, int elem)
{
	int i;
	CELLULE* pcel;
	switch(type)
	{
		case 1:
		pcel=bkm.p1;
		break;
		case 2:
		pcel=bkm.p2;
		break;
		case 3:
		pcel=bkm.p3;
		break;
		exit2("erreur de stockage de bookmark2");
	}
	if(elem==0) { return pcel;}
	pcel=pcel->pt;	//pointe sur la premiere cellule de donnée(meme si =NULL)
	for(i=1;i<elem;i++)
	{
		pcel=pcel->pt;
		if(pcel==NULL) exit2("erreur dans la pile, NULL unexpect");
	}
	return pcel;
}
void add_bkm(ESI val, char type)
{
	CELLULE *pcel,*r;
	int elem;
	if(val==NULL) exit2("BOOKMARK==NULL");
	switch(type)
	{
		case 1:
		elem=++bkm.n1;
		break;
		case 2:
		elem=++bkm.n2;
		break;
		case 3:
		elem=++bkm.n3;
		break;
		exit2("erreur de stockage de bookmark");
	}
	r=get_ptr_cellule(type,elem-1);
	if((r->pt=(CELLULE*)malloc(sizeof(CELLULE)))==NULL) exit2("mem alloc err.");
	(r->pt)->pt=NULL;
	(r->pt)->pos=val;
	}

ESI depiler_bkm(int type)
{
	CELLULE *pcel,*c,*cb;
	ESI r;
	int elem;
	switch(type)
	{
		case 1:
		elem=bkm.n1--;
		break;
		case 2:
		elem=bkm.n2--;
		break;
		case 3:
		elem=bkm.n3--;
		break;
	}
	cb=get_ptr_cellule(type,elem-1);
  r=cb->pt->pos;
  free(cb->pt);
  cb->pt=NULL;
  if(r==NULL) exit2("ERROR:dépilage=NULL");
	return r;
}
void del_bkm(void)
{
	int i;
	for(i=1;i<=bkm.n1;i++) depiler_bkm(1);
	for(i=1;i<=bkm.n2;i++) depiler_bkm(2);
	for(i=1;i<=bkm.n3;i++) depiler_bkm(3);
	free(bkm.p1);
	free(bkm.p2);
	free(bkm.p3);
}

void exec_cmd(unsigned char *cmd)
{
	//int ans;
	HANDLE handle;
	push_parse_text (cmd);
	handle = HS_popEStack ();
  NG_execute (handle, FALSE);
	HeapFree (handle);
	//ans = GetIntArg (top_estack);
}

void exit2(unsigned char *str_error) //Execute this function if there is a compilation error.
{
	HANDLE houtput;
	if(strcmp("\nSource string expected.\n",str_error)==0) 
	{
		clrscr(); printf("\n%s",str_error); ngetchx();
	}
	else 
	{
	printf("\nERROR DURING COMPILATION\n%s",str_error);
	printf("\nLast function used : ",current_func_str);
	printf("\nLast var name used : ",ptr);
	printf("\n%s",lineptr);
	ngetchx();

	//Creation of the error output string 
	houtput=CreateFile2 ("npout");								//name of the error output file
	AppendStrToFile1 (houtput, "NewProg ERROR REPORT");
	AppendStrToFile1 (houtput, str_error);
	AppendStrToFile1 (houtput, "\nLast function used : ");
	AppendStrToFile1 (houtput, current_func_str);
	AppendStrToFile1 (houtput, "\nLast var name used : ");
	AppendStrToFile1 (houtput, ptr);
	CloseCreatedFile_type (houtput,STR_TAG);
	}
	
	fclose (fout);

	exit(4);
}

char get_foncnum(void)
{
	unsigned char *ptr;
	char error_strr[50];
	foncnum2=0;
	ptr=GetStrnArg(argptr);

	strcpy (current_func_str, ptr);	//For error indication purpose (in exit2).
	//printf("\n nfonc=%d",nfonc); ngetchx();
	//printf("\n%s",ptr); ngetchx();
	for(foncnum2=0;foncnum2</*nfonc*/255;foncnum2++)
	{
		//if(foncnum2==172) {printf("\nstr:%s num:%d",fonc[foncnum2],foncnum2); ngetchx();}
		if(strcmp(ptr,fonc[foncnum2])==0) 
		{
			return 1;
		}
	}
	//printf("\npassé par la");
	sprintf(error_strr,"\nUnknown function : %s",ptr);
	exit2(error_strr);
	//printf("\nfonction inco:%s\n",ptr);
	return 0;
}

long mabs(long n)
{
	if(n<0) return -n;
	return n;
}
unsigned long muabs(unsigned long n)
{
	if(n<0) return -n;
	return n;
}
void push_posint_value(long v,char *ffpos)
{
	char *fpos_save;
	unsigned char *ptr;
	ptr=&v;
	//fpos_save=fout->fpos;
	//fout->fpos=ffpos;
	//fputc2(POSINT_TAG,fout);
	//fputc2(*(unsigned char*)(ptr+2),fout); fputc2(*(unsigned char*)(ptr+3),fout);
	//fout->fpos=fpos_save;
	*(ffpos)=POSINT_TAG;
	*(ffpos+1)=*(unsigned char*)(ptr+2);
	*(ffpos+2)=*(unsigned char*)(ptr+3);
}
void push_value(long v)
{
	unsigned char *ptr;
	ptr=&v;
	//printf("\nds pushvalue abs=%ld",mabs(v)); ngetchx();
	if(mabs(v)<=255) //chars
	{
		fputc2(0x01,fout);
		fputc2(v,fout);
	}
	else
	{
		if(mabs(v)<=65535) //chars
		{
			//printf("\nC'est un entier=%ld \n *argptr=%x %X\n",v,*argptr,v); ngetchx();
			if(v>=0) fputc2(POSINT_TAG,fout);
			else fputc2(NEGINT_TAG,fout);
			fputc2(*(ptr+2),fout); fputc2(*(ptr+3),fout);
		}
		else
		{
			if(mabs(v)<=4294967295)
			{
				if(v>=0) fputc2(IM_TAG,fout);
				else fputc2(37,fout);
				fputc2(*(ptr),fout); fputc2(*(ptr+1),fout); fputc2(*(ptr+2),fout); fputc2(*(ptr+3),fout); 
			}
			else
			{
				exit2("erreur pour cet entier");
			}
		}
	}	
}
char is_special_var(unsigned char *p)
{
	int i;
	for(i=0;i<nsvar;i++)
	{
		if(strcmp(special_var[i],p)==0) return 1;
	}
	return 0;
}
char is_existing_var(unsigned char *p)
{
	for(varnum=0;varnum<ndvar;varnum++)
	{
		if(strcmp(def_var[varnum],p)==0) return 1;
	}
	return 0;
}
char is_existing_lbl(unsigned char *p)
{
	for(lblnum=0;lblnum<numlbl;lblnum++)
	{
		if(strcmp(lbl_str[lblnum],p)==0) return 1;
	}
	return 0;
}
void add_var(unsigned char *p)
{
	def_var[ndvar]=p;
	varnum=ndvar;
	ndvar++;
}

void disp_var(void)
{
	int i;
	for(i=0;i<ndvar;i++)
	printf("\n%s",def_var[i]);
	ngetchx();
}

void goto_process(void)
{
	int dif;
	if(*argptr!=0) exit2("\nOnly varentity for lbl");
	ptr=GetStrnArg(argptr);
				if(!is_special_var(ptr)) //si ce n'est pas une speciale var
			{
				if(!is_existing_lbl(ptr)) //si elle n'existe pas
				{
					//exit2("Not yet defined lbl");
					fputc2(13,fout); fposgoto[numgoto]= file_pos; fputc2(0,fout); fputc2(0,fout);
					goto_str[numgoto]=ptr; numgoto++;
				}
				else
				{
					dif=(long)( file_pos)-(long)fposlbl[lblnum];
					//printf("dif=%d base dix",dif); ngetchx();
					if(mabs(dif)<=127) { fputc2(0x05,fout); fputc2(dif,fout);}
					else { fputc2(13,fout); fputc2(*(char*)(&dif),fout);fputc2(*((char*)(&dif)+1),fout);}
				}
			}
			else
			{
				exit2("\nLabel name goto forbiden.");
			}
}
void var_process(void)
{
	ptr=GetStrnArg(argptr);
				if(!is_special_var(ptr)) //si ce n'est pas une speciale var
			{
				if(!is_existing_var(ptr)) //si elle n'existe pas
				{
					add_var(ptr);
				}
			}
			else
			{
				exit2("\nThis var name is forbiden.");
			}
}

void _main(void)
{
	ESI arg = top_estack;
	ESI argg,r;
	SYM_ENTRY *src_entry;
	unsigned char *temp_str,*ptrr;
	int *uip,ui;
	int dif;
	unsigned int i,size_handle;
	unsigned long ulv;
	char isifc;
	long lv;
	FILE* f;
	//Pile *pileif;				//ICI ICI
	//mem_to_file("coubnvghcoucou",14,"coucou");
  arg=top_estack; numline = 0; line = 0;
  i=0;nfonc=0; size=0; nsvar=0; ndvar=0; sizevarlist=0; lblnum=0; numlbl=0; numgoto=0;
  
  //IF
  aif=0; aeif=0;
  //WHILE
  aw=0; aew=0;
  /*
  //FOR
  af=0; aef=0;
  //LOOP
  al=0; ael=0;
  */
  //numwhile=0; numfor=0; numif=0; iflevel=0; ni=0; ne=0; nf=0; ifi=0; nj=0;
  ///init_bkm();
   //pileelse=newPile();
  //initPile(pileelse);
  while(strcmp(fonc[i],"enddef")!=0)
  {
  	nfonc++; i++;									//nfonc=nbre exact de fonctions
  }
  //printf("\nnfonc=%d",nfonc); ngetchx();
  i=0;
  while(strcmp(special_var[i],"enddef")!=0)
  {
  	nsvar++; i++;									//nsvar=nbre exact de var definies
  }
  //printf("\nnsvar=%d",nsvar); ngetchx();
  if(GetArgType (arg) != STR_TAG) exit2("\nSource string expected.\n");
  temp_str = GetStrnArg(arg);
  
  strcpy (srcname , temp_str);			

  f=fopen(srcname,"r");
  srcsize=*(unsigned int*)(f->base);
  fclose(f);
  
  clrscr();
  //printf("\nsrcname:%s",srcname); ngetchx();
  src_entry = DerefSym(SymFind(SYMSTR(srcname)));
 
	//printf("\nnom : %s taille : %d", srcname, srcsize);
	argptr=HToESI(src_entry->handle);
	if((fout=fopen("out","wb"))==NULL) exit2("prob memoire");

	//printf("\n*argptr-7=%x",*(argptr-7));
	if(*(argptr-7)==0xE8) argptr-=9;
	else argptr-=7;
	
	//printf("\n*argptr=%x",*argptr);
	//ngetchx();
	//ngetchx();
	

	file_ori= fout->fpos;
	file_pos= fout->fpos;
	fputc2(OTH_TAG,fout); //OTH_TAG=tibasic statement
	//printf("\n Valeur de *argptr=%x +2=%x",*argptr, *(argptr+2)); ngetchx();
	if(*argptr!=USERFUNC_TAG)       //se charge de detecter "init()"
	{
		exit2("init() expected line 1");
	}
	else
	{
		if(strcmp(GetStrnArg(argptr),"init")!=0)
		{
			exit2("init() expected line 1  - 2");
		}
		argptr-=1;
	}
	tibasic:
	  arg=argptr;
	while(*argptr!=0xE9 && !((*argptr==0xE8 || *argptr==0xE7) && *(argptr-1)==0 && *(argptr-2)==0 && *(argptr-3)=='t' && *(argptr-4)=='r' && *(argptr-5)=='a' && *(argptr-6)=='t' && *(argptr-7)=='s' && *(argptr-8)==0 && (*argptr==0xE8 || *argptr==0xE7)))
	{
	
		//if(*argptr==0xE9) {fputc2(0xE9,fout); fputc2(OTH_TAG,fout); exit2("fini par tibasic");}
		//fputc2(*argptr,fout);
		//printf("\nrecharche start argptr=%x",*argptr); ngetchx();
		argptr--;
	}
	
	
	//printf("\nTIbasic : argptr=%x avant start",*argptr); ngetchx();
	 i=arg-argptr;
	 ptrr=&i;
	fputc2(*(ptrr),fout); fputc2(*(ptrr+1),fout);
	 
	 //push_value(arg-argptr);
	 for(argg=argptr+1;argg<=arg;argg++)
	 {
	 	fputc2(*argg,fout);
	 }
	 if(*argptr==0xE9)
		{
			fputc2(0xE9,fout); fputc2(OTH_TAG,fout);
			//ngetchx(); 
			fclose(fout);
			//printf("\nSuccess!");			LLAA FFIINN
			//deletePile(pileif);
			//ngetchx();
			exit(4);
		}
	 argptr-=9;
	qbasic:
	while(1)  //si on est dans du qbasic
	{
		//printf("\nqbasic : argptr=%x",*argptr); if(ngetchx()=='f') {exit2("aborted by f");}
		if(*argptr>=0x1 && *argptr<=0x1B) //si c'est une variable a------z . En fait, ca traite aussi tout ce qui n'est pas extra_tibasic token. On peut donc rajouter d'autres _TAG mais pas de _ITAG
			{
	
				str_az[4]='a'+*argptr;
				//printf("\nstr_az=%s",str_az); ngetchx();
				ptr=str_az;
				///////////
				//if(strcmp(ptr,"end")==0) { fputc2(OTH_TAG,fout); argptr-=2; goto tibasic;}  //on retourne alors au tibasic
				if(!is_special_var(ptr)) //si ce n'est pas une speciale var
				{
					if(!is_existing_var(ptr)) //si elle n'existe pas
					{
						add_var(ptr);
						exit2("Var name a-z and grec\nare frobiden."); //Cette ligne enlève la possibilité d'utiliser les variables de a à z dans les programmes, enlever cette ligne si on souhaite les avoirs mais l'exécution sera parfois buguée
					}
				}
				else
				{
					//exit2("You can't use this\nvar name.");
				}
				
				
				fputc2(0x2,fout); //Tag des variables
				fputc2(varnum,fout); //Attention! nombre de variables limités à 256
				//////////
				argptr--;
				//exit2("var a>-<z aren't allowed");
			}
		relaunch:		//si on passe là, alors on a pas de a----z
		switch(*argptr)
		{
			case 0xE9: //fin du programme
			fputc2(0xE9,fout); fputc2(OTH_TAG,fout);
			fclose (fout);
			exit(4);
			break;
			case 0xE4: //indicateur I_TAG pour fonctions autres
			if(*(argptr-1)==0x30) {argptr--; goto relaunch;}  //si label_tag
			if(*(argptr-1)==0x2F || *(argptr-1)==0x3A || *(argptr-1)==0x74 || *(argptr-1)==0x0E || *(argptr-1)==0x16 || *(argptr-1)==0x3B|| *(argptr-1)==0x10|| *(argptr-1)==0x3D|| *(argptr-1)==0x15 || *(argptr-1)==0x0B || *(argptr-1)==0x18 || *(argptr-1)==0x11) {argptr--; goto relaunch;}  //si goto_tag if_tag for  endfor exit(=break) ifthen endif while endwhile else loop endloop
			break;
			case 0x3D:	//while
			fputc2(0x3D,fout);
			aw++; aew++;
			alw[aew]=aw;
			push_value(alw[aew]);
			argptr--;
			break;
			case 0x15:		//endwhile			*(ptrg+1)=*((unsigned char*)(&dif)+1);
			fputc2(0x15,fout);
			push_value(alw[aew]);
			aew=aew-1;
			argptr-=3;
			break;
			case 0x2F:		//gere GOTO
			argptr--;
			if(*(argptr)!=0) exit2("GOTO must be a variable name");
			fputc2(0x05,fout); //tag pour signifier GOTO
			//goto_process();
			break;
			case 0x3B:		//ifthen
			fputc2(0x3B,fout);
			aif++; aeif++;
			alif[aeif]=aif;
			push_value(alif[aeif]);
			argptr--;
			break;
			case 0x0B:	//else
			fputc2(0x45,fout);
			push_value(alif[aeif]);
			argptr--;
			break;
			case 0x10:		//endif
			fputc2(0x4F,fout);
			push_value(alif[aeif]);
			aeif=aeif-1;
			argptr--;
			break;
			case 0x18:    //LOOP_ITAG
			exit2("Loop:endloop forbiden.\nUse lbl:goto instead");
			//fputc2(24,fout);
			//al++; ael++;
			//all[ael]=al;
			//push_value(all[ael]);
			argptr--;
			break;
			case 0x11:		//ENDLOOP_ITAG
			//fputc2(34,fout);
			//push_value(all[ael]);
			//ael=ael-1;
			argptr--;
			break;
			case 0x3A:		//correspond à IF_ITAG
			fputc2(0x9,fout); //tag de if(teste la valeur logique)
			exit2("\nIf: without endif is\n forbiden.\nEndif expected.");
			argptr--;
			break;
			case EXIT_ITAG:
			argptr--;
			fputc2(0x16,fout);
			break;
			case LIST_TAG:	//217			LIST-TAG,num_of_var,nbelem,size_of_elem
			argptr--;	
			nbelemm=0;
			if(*argptr==0)		//So this is an instanciated list
			{
				ptr=GetStrnArg(argptr);
				
				if(!is_special_var(ptr)) //si ce n'est pas une speciale var
			  {
				  if(!is_existing_var(ptr)) //si elle n'existe pas
				  {
				  	add_var(ptr);
				  }
			  }
			  fputc2(LIST_TAG,fout);
				fputc2(varnum,fout);
				dim_list=GetIntArg(argptr);	//Size of the elements 1,2,4 (voir plus : not implemented yet)
				
				tmp_esi=argptr;
				while(*argptr!=END_TAG)		//Count the number of elements of the instanciated list
				{
//					printf("*argptr=%x",*argptr); ngetchx();
					if(*argptr!=POSINT_TAG && *argptr!=NEGINT_TAG && *argptr!=MINUS_TAG && !(*argptr==EXT_TAG && (*(argptr-1)==BIN_TAG || *(argptr-1)==HEX_TAG))) 
					{
						//printf("\n*argptr=%x \n*(argptr+1)=%x",*argptr,*(argptr+1)); ngetchx();
						exit2("When making an instanciated list\n with {name_var,...},\n the elements must be an \ninteger.\nFunctions are forbiden.");	
					}
					if(*argptr==MINUS_TAG)
					{
						argptr--;
					}
					if(*argptr==EXT_TAG && (*(argptr-1)==BIN_TAG || *(argptr-1)==HEX_TAG))
					{
						//printf("C'est un BIN ou un HEX"); ngetchx();
						argptr-=2;
					}
					
					nbelemm++;
					//SkipArg(argptr);
					GetIntArg(argptr);
				}
				push_value(nbelemm);	
				push_value(dim_list);		//Size of the elements 1,2,4 (voir plus : not implemented yet)
				argptr=tmp_esi;
				while(*argptr!=END_TAG)		
				{				
				//printf("\nvarn=%d nbelem=%d wide=%ld",varnum,dim_list,nbelemm);
				//ngetchx();
					switch (*argptr)
					{
						case MINUS_TAG:
						argptr--;
						fputc2(MINUS_TAG,fout);
						push_value(GetIntArg(argptr));
						break;
						case EXT_TAG:
						if(*(argptr-1)==BIN_TAG || *(argptr-1)==HEX_TAG)
						{
							argptr-=2;
							push_value(GetIntArg(argptr));
						}
						break;
						case POSINT_TAG:
						case NEGINT_TAG:
						push_value(GetIntArg(argptr));
						break;
					}					
				}
				
				}
				else			//So this is a non instanciated list
			{
				esi_start_nilist=argptr+1;			//point to LIST_TAG
				fputc2(216,fout);								//tag for a list of non instanciate values
				nilist_size_array_ptr=fout->fpos;	//remember the place to store the array size
				//allow memory for future storing of the size of the array , 3 bytes
				fputc2(0,fout);
				fputc2(0,fout);
				fputc2(0,fout);
				//fout->fpos++;
				push_value(dim_tios_list(argptr+1));		//esi_end_nilist affected in this function
			}
			break;
			case 0: //variable	VVV AAA RRR III AAA BBB LLL EEE
			ptr=GetStrnArg(argptr);
az:
			if(strcmp(ptr,"end")==0) { fputc2(OTH_TAG,fout); argptr-=2; goto tibasic;}  //on retourne alors au tibasic
			if(!is_special_var(ptr)) //si ce n'est pas une speciale var
			{
				if(!is_existing_var(ptr)) //si elle n'existe pas
				{
					add_var(ptr);
				}
			}
			else
			{
				exit2("\nThis var name is forbiden.");
			}
			fputc2(0x2,fout); //Tag des variables
			fputc2(varnum,fout); //Attention! nombre de variables limités à 256
			//argptr--;
			break;
			case 0xE3:		//correspond aux extra tibasic token
			argptr--;
			if(*argptr==INDIR_TAG)
			{
				fputc2(14,fout); //indirection
				var_process();
				fputc2(varnum,fout);
			}
			switch(*argptr)
			{
			  case 0x2b:	//nombre binaire
			  case 0x2c:	//si nombre Hexadécimal a convertir
			  argptr-=1;
			  push_value(GetIntArg(argptr));
			  break;	
			}
			break;
			case 	0x91:			//div_tag
			fputc2(DIV_TAG,fout);
			argptr--;
			break;
			case 	0x8F:			//mul_tag
			fputc2(MUL_TAG,fout);
			argptr--;
			break;
			case 	0x8D:			//sub_tag
			fputc2(SUB_TAG,fout);
			argptr--;
			break;
			case 0x8b:		//add_tag
			fputc2(ADD_TAG,fout);
			argptr--;
			break;
			case 0xE7:  // ':'
			if(*(argptr-1)==0) argptr-=2;
			else exit2("line must have no type");
			break;
			case 0xE8: //enter
			if(*(argptr-1)==0) argptr-=2;
			else exit2("line must have no type");
			break;
			case 0x58: //je pense que ca correspond a la fin d'un argument 'X'
			fputc2(0x58,fout); argptr--;
			//printf("\nY a un 'X'"); ngetchx();
			break;
			case STORE_TAG:  //sto
			argptr--;
			fputc2(STORE_TAG,fout);
			break;
			case 0x30:		//label tag
			fputc2(0x4,fout); //tag pour signifier LABEL
			argptr--;
			//fputc2(lblnum,fout);
			break;
			case FOR_ITAG:		//FOR_ITAG
			exit2("For:Endfor instructions\nare forbiden.\n Use While:Endwhile instead");
			/*fputc2(0x74,fout);  
			af++; aef++;
			alf[aef]=af;
			push_value(alif[aef]);
			argptr--;*/
			break;						//ENDFOR_ITAG
			case ENDFOR_ITAG:
			exit2("For:Endfor instructions\nare forbiden.\n Use While:Endwhile instead");
			/*fputc2(0x0E,fout); 
			push_value(alf[aef]);
			aef=aef-1;
			argptr--;*/
			break;
			case SUBSCRIPT_TAG:		//=0d213  ; List and matrix element(Tibasic). Syntax : var[a,b,...] ou var[a][b]...
			argptr--;
			fputc2(SUBSCRIPT_TAG,fout); 
			tmp_esi=argptr;
			GetStrnArg(argptr);	//skip the var name
			nbelemm=0; //temporary variable
			while (*argptr!=END_TAG)	//search for the dimension of the list/matrix (stored in nbelemm). Tibasic fixed to 2 the maximum dimension
			{
				GetIntArg(argptr); nbelemm++;
			}
			if(nbelemm==2) {exit2("\nWriting var_name[a][b] or\nvar_name[a,b] is forbiden.\nOnly admitted : varname[a]\nMatrix writting forbiden.\nList only admitted.");}
			argptr=tmp_esi;
			//printf("Dimension = %ld",nbelemm); ngetchx();
			//exit2("[] not legal, use bv wv or lv"); 
			break;
			case RAND_TAG:
			fputc2(101,fout); argptr--;
			break;
			case NOT_TAG:
			fputc2(0x79,fout); argptr--;
			break;
			case OR_TAG:
			fputc2(0x83,fout); argptr--;
			break;
			case AND_TAG:
			fputc2(0x84,fout); argptr--;
			break;
			case LT_TAG:		//inf
			fputc2(0x85,fout); argptr--;
			break;
			case LE_TAG:	//inf equ
			fputc2(0x86,fout); argptr--;
			break;
			case EQ_TAG:	//eq
			fputc2(0x87,fout);
			argptr--;
			break;
			case GE_TAG:		//sup eq
			fputc2(0x88,fout); argptr--;
			break;
			case GT_TAG:		//sup
			fputc2(0x89,fout); argptr--;
			break;
			case NE_TAG:		// not equ !=
			fputc2(0x8A,fout); argptr--;
			break;
			case XOR_TAG:
			fputc2(0x82,fout); argptr--;
			break;
			case 0x2D: //STR_TAG
			fputc2(STR_TAG,fout);
			ptr=GetStrnArg(argptr);
			push_value(strlen(ptr));
			fputs(ptr,fout);
			fputc2(0,fout);
			break;
			case END_TAG:
			//if(is_ok==1) {fputc2(END_TAG,fout); is_ok=0;}
			//fputc2(END_TAG,fout);
			if(argptr==esi_end_nilist)
			{
				push_posint_value((long)(fout->fpos)-(long)(nilist_size_array_ptr)+1-6,nilist_size_array_ptr);
			}
			argptr--; break;
			case POSINT_TAG:
			push_value(GetIntArg(argptr));
			break;
			case MINUS_TAG:
			argptr--;
			fputc2(MINUS_TAG,fout);
			break;
			case NEGINT_TAG:
			push_value(GetIntArg(argptr));
			break;
			case USERFUNC_TAG: //fonction a nous
			if(!(get_foncnum())) {/*printf("NNNNUUUMMM=%x",foncnum);*/ ngetchx(); exit2("fonctions inconnues");}
			//if(foncnum2==84) {fputc2(84,fout);	/*lbl_process()*/; goto relaunch; } //si c'est un "fonc()" alors met le nom de la fonc comme un label
			//if(foncnum2==82) {fputc2(82,fout); /*goto_process()*/; goto relaunch; } //si c'est un "call()" alors met le nom de la fonc comme un goto
			if(foncnum2==11) {fputc2(11,fout); if(*argptr!=0) exit2("handle sto in var only"); var_process(); fputc2(varnum,fout); argptr--; goto tibasic;} //si c'est endh()
			//fputc2(USERFUNC_TAG,fout);
			//printf("\nFONCNUM=%d",foncnum2);
			fputc2(foncnum2,fout);
			if(foncnum2==27) { fputc2(0,fout); fputc2(0,fout); }	//La string est directemnt enregistrée dans le fichier
			if(foncnum2==0x3) {var_process(); fputc2(varnum,fout);}
			break;
			SkipArg(argptr);
			printf("\ncas non traite *argptr=%x",*argptr);
		}// fin switch
		
	}
		ngetchx();
		//del_bkm();
		exit2("Fin anormale");
}