.NOLIST
	#include "ti83.inc"		; Ce fichier a été "customisé", vous devez par conséquent le télécharger si vous voulez compiler le programme
	#DEFINE nbrLabels		saferam1		; Adresse où est stocké le nombre de labels (voir nbrLabels)
	#DEFINE listLabels		saferam1+2		; Adresse où sont stockés les labels pour les associer par la suite avec les GoTo
	#DEFINE progBasicStart	saferam1+$6E	; Adresse où est stocké l'adresse de départ du programme Basic
	#DEFINE progASMAddr		saferam1+$70	; Adresse où est stocké l'adresse actuelle dans le saferam du programme ASM (qui augmente à chaque rajout)
	#DEFINE progASMStart	saferam1+$72	; Adresse où est stocké l'adresse de départ du programme ASM
	#DEFINE addrASMSize		saferam1+$74	; Adresse où est stockée l'adresse où est stocké la taille du programme ASM
	#DEFINE progASMSize		saferam1+$76	; Adresse où est stocké la taille que prend l'actuel programme ASM
	#DEFINE currentSize		saferam1+$78	; Adresse où est stocké la taille de l'instruction pour un traitement rapide
	#DEFINE progBasicAddr	saferam1+$7A	; Adresse où est stocké l'adresse actuelle dans la table des programmes du programme basic qui est incrémenté à chaque fin d'instruction
	#DEFINE addr2Change		saferam1+$7C	; Adresse où est stocké une information temporaire
	#DEFINE sizeBefSto		saferam1+$7E	; Adresse indicant la taille du programme au moment où la routine Sto est mise
	#DEFINE containIf		saferam1+$80	; Adresse indicant s'il y a des conditions dans le programme
	#DEFINE containInput	saferam1+$82	; Adresse indicant s'il y a des input dans le programme
	#DEFINE nbrAddrs		saferam1+$84	; Adresse où est stocké le nombre d'adresses (voir listAddrs)
	#DEFINE listAddrs		saferam1+$86	; Adresse où sont stockés des informations pour des étapes se déroulant à la fin du programme (pour avoir les adresses des textes pour les _puts, etc)
	.org 9327h
.LIST
	
start:
	call _clrlcdfull
	call _homeUp

	call _zeroop1
	ld hl,progBasicName		; On vérifie si le programme BASIC existe
	ld de,OP1
	ld bc,6
	ldir
	call _Chkfindsym
	ret c					; Si non, on quitte le programme
	push de

	ld hl,progASMName
	ld de,OP1
	ld bc,6
	ldir
	call _Chkfindsym
	call nc,_DELVAR
	ld hl,1
	call _CREATEPROG
	ld (addrASMSize),de
	inc de
	inc de
	ld (progASMAddr),de
	ld (progASMStart),de
	
	ld hl,0					; On intialise certaines valeurs
	ld (nbrAddrs),hl
	ld (nbrLabels),hl
	ld (containIf),hl
	ld (containInput),hl
	ld (progASMSize),hl
	pop hl
	ld b,(hl)				; On met la taille du programme basic dans a
	inc hl
	inc hl
	ld (progBasicStart),hl
	ld (progBasicAddr),hl	; On met l'adresse de début du programme basic dans le saferam

loopProgram:				; Boucle principale qui pracourt le programme basic

	push bc
	ld a,(hl)				; a prend la valeur du token basic courrant
	ex de,hl
	; En basic cela donnerait...
	ld bc,18				; If a=tClLCD OR a=tClDrw
	ld (currentSize),bc		; 18->(currentSize)
	ld hl,ClrHome			; "CD5547CD5B51CD7547"->hl
	cp tClLCD
	jr z,suit
	cp tClDrw
	jr z,suit
	
	ld hl,6					; If a=tPause
	ld (currentSize),hl		; 6->(currentSize)
	ld hl,Pause				; "CDFE4C"->hl
	cp tPause
	jr z,suit
	
	ld hl,2					; If a=tReturn
	ld (currentSize),hl		; 2->(currentSize)
	ld hl,StoreInVar		; "C9"->hl
	cp tReturn
	jr z,suit
	
	cp tDisp				; If a=tDisp
	jp z,AsmDisp			; Goto AsmDisp
	
	cp tLbl					; If a=tLbl
	jp z,AsmLabel			; Goto AsmLabel

	cp tGoto				; If a=tGoto
	jp z,AsmGoTo			; Goto AsmGoTo

	cp tIf					; If a=tIf
	jp z,AsmIf				; Goto AsmIf
	
	cp tWhile				; If a=tWhile
	jp z,AsmLoops			; Goto AsmLoops
	
	cp tRepeat				; If a=tRepeat
	jp z,AsmLoops			; Goto AsmLoops

	cp TSTORE				; If a=TSTORE
	jp z,AsmSto				; Goto AsmSto

	cp tInput				; If a=tInput
	jp z,AsmInput			; Goto AsmInput

	cp tPrompt				; If a=tPrompt
	jp z,AsmInput			; Goto AsmInput

	cp tEnd					; If a=tEnd
	jp z,AsmEnd				; Goto AsmEnd
	
	jr ifNothing			; If no tokens correspond, jump to ifNothing
suit:
	push hl
	ld hl,(currentSize)
	ld de,(progASMAddr)
	call _INSERTMEM
	pop hl
	ld de,(progASMAddr)		; On copie ce qu'il y a à copier
	ld bc,(currentSize)
	ldir

	ld (progASMAddr),de		; On met à jour la taille du programme ASM et son adresse
	ld hl,(currentSize)
	ld de,(progASMSize)
	add hl,de
	ld (progASMSize),hl
ifNothing:
	pop bc
	ld hl,(progBasicAddr)	; On incrémente l'adresse du programme basic
	inc hl
	ld (progBasicAddr),hl
	dec b
	ld a,b
	or a
	jp nz,loopProgram		; On recommence tant que b!=0 (tant que hl ne soit pas à la fin du programme)

	ld hl,80
	ld de,(progASMAddr)
	call _INSERTMEM
	ld hl,StoreInVar		; On copie le "C9" (ret), la routine Disp et la routine sto
	ld bc,80
	push bc
	ldir

	ld a,(containIf)		; On verifie si le programme contient des conditions
	or a
	jr z,noIfs				; Si non, pas besoin de faire ceci
	ld bc,(progASMSize)
	ld (sizeBefSto),bc
	ld hl,78
	add hl,bc
	ld (containIf),hl
	
	ld hl,102
	push hl
	call _INSERTMEM
	pop bc
	pop hl
	add hl,bc
	push hl
	ld hl,Equal
	ldir

	ld a,(containInput)
	or a
	jr z,noInputs
	ld hl,(progASMSize)
	pop bc
	push bc
	add hl,bc
	dec hl
	ld (containInput),hl
	ld hl,46
	push hl
	call _INSERTMEM
	pop bc
	pop hl
	add hl,bc
	push hl
	ld hl,RoutInput
	ldir

noInputs:
	
	push de
	ld de,(progASMAddr)
	ld hl,6
	ld bc,(containIf)
	srl b
	rr c
	push bc
	inc bc
	call calculateAddrToToken
	ld hl,42
	pop bc
	inc bc
	call calculateAddrToToken
	pop de

noIfs:
	ld (progASMAddr),de		; On met à jour la taille du programme ASM et son adresse
	ld hl,(progASMSize)
	pop bc
	add hl,bc
	ld (progASMSize),hl

	ld a,(nbrAddrs)			; Début de la routine pour copier les infos se trouvant après le ret (texte pour le _puts, etc...) et pour mettre les valeurs aux GoTo
	or a
	jr z,End
	ld b,a					; b = nombre d'adresses
	ld hl,listAddrs			; hl = position dans la liste
listAddr:
	push bc
	push hl
	ld (addr2Change),hl		; On met hl dans un adresse intermédiaire (temporaire) pour pouvoir la réutiliser par la suite
	
	ld de,OP1				; On copie l'adresse de la position dans la liste dans OP1
	ld bc,2
	ldir
	ld hl,(OP1)				; Pour pouvoir ensuite récuperer la valeur de l'adresse dans a (moyen le plus simple que j'ai trouvé)
	ld a,(hl)
	cp tDisp				; If a == tDisp
	call z,addDisp
	cp tGoto				; If a == tGoto
	call z,addGoTo
	cp TSTORE				; If a == TSTORE
	call z,addSto
	cp tIf					; If a == tIf
	call z,fillIfWhileRepeat
	cp tWhile				; If a == tWhile
	call z,addWhile
	cp tEnd					; If a == tEnd
	call z,addEnd
	cp tInput				; If a == tInput
	call z,addInput
	cp tPrompt				; If a == tPrompt
	call z,addInput

	pop hl
	pop bc
	ld de,4					; On avance de 4 octets dans la liste
	add hl,de
	djnz listAddr			; On décrémente b et on recommence tant que b!=0
End:
	ld hl,9
	ld de,(progASMAddr)
	call _INSERTMEM
	ld hl,progEnd			; On copie le "End -|0000-|End"
	ld bc,9
	push bc
	ldir

	ld de,(progASMAddr)		; On met à jour la taille du programme ASM et son adresse
	ld hl,(progASMSize)
	pop bc
	add hl,bc
	ld (progASMSize),hl
	
	ld hl,progASMSize
	ld de,(addrASMSize)
	ld bc,2
	ldir
	ret						; Fin du programme


; If the token is Disp_
; ------------------------------
AsmDisp:
	push de
	call addAnAddr
	pop hl
	inc hl
	ld a,(hl)
	cp tString
	jr z,isAQuote
	ld a,1
	ld (containIf),a
	ld hl,18				; On rajoute l'équivalent hexadécimal de <call _puts>
	ld (currentSize),hl
	ld hl,DispEqual
	jp suit
isAQuote:
	ld hl,18				; On rajoute l'équivalent hexadécimal de <call _puts>
	ld (currentSize),hl
	ld hl,Disp
	jp suit

addDisp:
	ld hl,(addr2Change)		; On récupère l'adresse temporaire dans hl
	push hl
	call _ldHLind
	inc hl
	ld a,(hl)
	pop hl
	cp tString
	jr z,notAnEqual
	ld c,$F4
	call fillIfWhileRepeat
	ld hl,(sizeBefSto)
	ld bc,50
	add hl,bc
	srl h
	rr l
	ld b,h
	ld c,l
	ld hl,$FFFC
	call calculateAddrToToken
	ret
notAnEqual:
	inc hl					; Ce dont on a besoin est deux octets plus loin
	inc hl
	ld de,OP1				; On copie l'adresse dans OP1
	ld bc,2
	ldir
	ld hl,(OP1)				; On met sa valeur dans hl
	push hl
	
	ld hl,(progASMSize)		; On fait une opération pour savoir où doit-on mettre le pointeur pour le _puts
	srl h
	rr l
	ld de,9327h
	add hl,de
	ld b,4
	ld de,OP1+3
	call decToHexToToken	; On transforme en héxadécimal et en tokens

	ld hl,OP1				; On inverse les octets
	ld de,OP1+4
	ld bc,2
	ldir
	pop de
	ld hl,OP1+2
	ld bc,4
	ldir

	ld hl,(addr2Change)		; On transforme et copie le texte du disp en tokens
	ld de,OP1
	ld bc,2
	ldir
	
	ld de,(OP1)
	inc de
	ld b,255
howManyLetters:
	inc de
	inc b
	ld a,(de)
	cp tEnter				; On compte le nombre de caractère en attendant un tEnter ou un tString
	jr z,endHowManyLetters
	cp tString
	jr z,endHowManyLetters
	jr howManyLetters
endHowManyLetters:
	ld c,b
	ld b,0
	push bc
	ld b,c
	
	ld de,(progASMAddr)		; On transforme toute la chaine en héxadécimal puis en tokens
	ld hl,(OP1)
	inc hl
	inc hl
	inc de
strToToken:
	push hl
	push bc

	push hl
	ld hl,2
	call _INSERTMEM
	pop hl

	ld a,(hl)				; hl est le token
	cp TSPACE
	jr nz,InAS
	ld a,20h
InAS:	; Is not A Space
	ld h,0
	ld l,a
	ld b,2					; b est combien de fois doit-on diviser pour obtenir un token
	call decToHexToToken
	pop bc
	ld hl,4					; Puisque la routine decToHexToToken copie à l'envers, on avance de 4
	add hl,de
	ex de,hl
	pop hl
	inc hl
	djnz strToToken
	dec de
	
	ld hl,2
	call _INSERTMEM
	ld hl,StrEnd			; On rajoute le petit 00 à la fin de la chaîne
	ld bc,2
	ldir
	ld (progASMAddr),de

	pop de					; On met à jour la taille du programme ASM et son adresse
	sla d
	sla e
	inc de
	inc de
	ld hl,(progASMSize)
	add hl,de
	ld (progASMSize),hl
	ret

; If the token is Label_
; ------------------------------
AsmLabel:
	ld a,(nbrLabels)		; On va à l'adresse où on va copier le nom du label et son adresse
	ld e,a
	sla a
	add a,e
	ld b,a
	ld de,listLabels
	dec de
toLabel:
	inc de					; On parcourt listLabels jusqu'à la prochaine place libre...
	djnz toLabel
	
	ld hl,(progBasicAddr)	; On met dans cette place libre le nom du label (A-Z)
	inc hl
	ld a,(hl)
	ld (de),a
	inc de
	push de					; On sauvegarde la place libre suivante (où sera mis l'adresse du label)

	ld hl,(progASMSize)		; On fait un calcul pour trouver l'adresse du label (9327h + taille du prog)
	ld a,2
	call _divHLbyA
	ld de,9327h
	add hl,de
	ex de,hl
	ld hl,OP1
	ld (hl),d
	inc hl
	ld (hl),e

	ld hl,OP1				; On met l'adresse dans la place libre
	pop de
	ld bc,2
	ldir

	ld a,(nbrLabels)		; On incrémente le nombre de labels
	inc a
	ld (nbrLabels),a
	jp ifNothing			; On continue le programme

; If the token is Goto_
; ------------------------------
AsmGoTo:
	call addAnAddr
	ld hl,6					; On rajoutte le C30000
	ld (currentSize),hl
	ld hl,JP
	jp suit

addGoTo:
	ld hl,(addr2Change)		; On recupere le nom du label associé au GoTo
	ld de,OP1
	ld bc,2
	ldir
	ld hl,(OP1)
	
	inc hl
	ld a,(hl)
	ld hl,listLabels
scanListLabels:				; On le cherche dans la liste des labels
	ld c,(hl)
	ld de,3
	add hl,de
	cp c
	jr nz,scanListLabels
	dec hl
	dec hl
	ld de,OP1				; On copie dans OP1 l'adresse du label
	ld bc,2
	ldir
	
	ld hl,(addr2Change)		; On transforme l'adresse en tokens
	inc hl
	inc hl
	call _ldHLind
	ld de,3
	add hl,de
	ex de,hl
	ld b,4
	ld hl,(OP1)
	call decToHexToToken
	ret

; If the token is If_
; ------------------------------
AsmIf:
	call addAnAddr
	ld hl,26				; On rajoutte ce qui est nécessaire au if
	ld (currentSize),hl
	ld hl,IfWhileRepeat
	jp suit
	
; If the token is While_ or Repeat_
; ------------------------------
AsmLoops:
	push af
	call addAnAddr
	pop af
	cp tRepeat
	jp z,ifNothing

	ld hl,IfWhileRepeat
	ld bc,26
	ld (currentSize),bc
	jp suit
	
addWhile:
	ld c,$F6				; On met une sorte de clé pour que la routine reconnaisse que c'est un While
	call fillIfWhileRepeat
	ret

; If the token is For(
; ------------------------------
;AsmFor:
;	call addAnAddr
;	ld hl,
;	ld bc,
;	ld (currentSize),bc
;	jp suit

; If the token is Sto
; ------------------------------
AsmSto:
	call addAnAddr
	ld a,1					; On indique que le programme contient des equations
	ld (containIf),a

	ld hl,18				; On rajoutte ce qui est nécessaire au sto
	ld (currentSize),hl
	ld hl,IfWhileRepeat
	jp suit

addSto:
	ld hl,(addr2Change)		; On récupère l'adresse temporaire dans hl
	push hl					; On économise des octets en le pushant
	call _ldHLind
	ld c,255
counter:					; On compte combien de tokens fait l'equation
	dec hl
	inc c
	ld a,(hl)
	cp tEnter				; On attend un tEnter
	jr z,afterCounter
	ld de,(progBasicStart)
	call _cphlde
	jr nz,counter
	inc c
afterCounter:
	pop hl
	push bc					; On sauvegarde le nombre de tokens de l'equation
	ld b,0
	call _ldHLind
	sbc hl,bc				; On va au début de l'equation
	dec hl
	ld (OP1),hl				; On met l'adresse dans OP1
	ld hl,(progASMSize)
	ld de,$F4				; Une clé pour que la routine reconnaisse que c'est un Sto
	call afterHowManyCharacters ; On va a un endroit précis de la routine fillIfWhileRepeat
	pop bc
	ld bc,(sizeBefSto)
	rr b
	rr c
	inc bc
	ld hl,$FFFC
	call calculateAddrToToken ; On met l'adresse de la routine Sto dans le programme ASM
	ex de,hl
	ld de,12
	sbc hl,de
	ex de,hl
	ld hl,(addr2Change)
	call _ldHLind
	inc hl
	call _ldHLind
	ld b,2
	call decToHexToToken	 ; On met le token de la variable dans laquelle stocker
	ret
	
; If the token is End
; ------------------------------
AsmEnd:
	call addAnAddr
	ld a,1					; On indique que le programme contient des equations
	ld (containIf),a
	ld b,255
	ld de,$FFFC				; Pour que la routine fasse -4
	call calculateTheEnd
	call _ldHLind
	ld a,(hl)
	cp tWhile
	jr z,endWhile
	cp tRepeat
	jr z,endRepeat
	jp ifNothing

endWhile:
	ld hl,6
	ld (currentSize),hl
	ld hl,EndWhileRepeatFor ; Routine pour economiser des octets
	jp suit
endRepeat:
	ld bc,26
	ld (currentSize),bc
	ld hl,IfWhileRepeat
	jp suit
	
addEnd:
	ld hl,(addr2Change)
	ld b,255
	ld de,$FFFC				; Pour que la routine fasse -4
	call calculateTheEnd
	push hl
	call _ldHLind
	ld a,(hl)
	pop hl
	cp tWhile
	call z,addEndWhile
	cp tRepeat
	call z,addEndRepeat
	ret
	
addEndRepeat:
	push hl
	push hl
	inc hl
	inc hl
	call _ldHLind
	dec hl
	dec hl
	ld (currentSize),hl		; Je me sert exceptionnellement de currentSize pour stocker temporairement l'adresse ASM du Repeat 
	pop hl
	ld de,(addr2Change)
	inc de
	inc de

	ex de,hl
	ld a,(hl)
	inc hl
	ld l,(hl)
	ld h,a
	ex de,hl

	ld (addr2Change),hl
	inc hl
	inc hl
	ld (hl),d
	inc hl
	ld (hl),e
	ld c,$F8
	call fillIfWhileRepeat

	ld hl,(currentSize)
	ld de,(progASMStart)
	sbc hl,de
	rr h
	rr l
	ld b,h
	ld c,l

	pop hl
	inc hl
	inc hl
	call _ldHLind
	ex de,hl
	ld hl,20
	call calculateAddrToToken
	ret
	
addEndWhile:
	inc hl
	inc hl
	call _ldHLind
	ld de,(progASMStart)
	sbc hl,de
	dec hl
	dec hl
	rr h
	rr l
	ld b,h
	ld c,l
	ld hl,(addr2Change)
	inc hl
	inc hl
	call _ldHLind
	ex de,hl
	ld hl,0
	call calculateAddrToToken
	ret

; If the token is End
; ------------------------------
AsmInput:
	call addAnAddr
	ld a,1
	ld (containInput),a

	ld hl,10
	ld (currentSize),hl
	ld hl,Input
	jp suit

addInput:
	ld hl,(addr2Change)
	push hl
	call _ldHLind
	inc hl
	ex de,hl
	pop hl
	inc hl
	inc hl
	call _ldHLind
	inc hl
	ex de,hl
	call _ldHLind
	ld b,2
	call decToHexToToken
	ld bc,(containInput)
	srl b
	rr c
	inc bc
	ld hl,5
	call calculateAddrToToken
	ret


; Routines
; ---------------------------------------------------------------------------------------------------

fillIfWhileRepeat:
	; Routine pour ne pas repeter le code
	; BC : Eventuelle clé...
	push bc
	ld hl,(progASMSize)		; On stocke la taille actuelle du programme
	push hl
	ld hl,(addr2Change)		; On récupère l'adresse temporaire dans hl
	ld de,OP1				; On copie l'adresse dans OP1
	ld bc,2
	ldir
	ld hl,(OP1)
	ld c,255
howManyCharacters:
	inc hl
	inc c
	ld a,(hl)
	cp tEnter				; On attend un tEnter
	jr nz,howManyCharacters
	pop hl
	pop de
afterHowManyCharacters:
	push de
	push hl
	ld b,0
	push bc					; On sauvegarde le nombre
	
	ld b,c					; On transforme l'équation en tokens et on le met à la suite du programme
	ld hl,(OP1)
	ld de,(progASMAddr)
	inc de
	inc hl
equToToken:
	push hl
	push bc
	push hl
	ld hl,2
	call _INSERTMEM
	pop hl
	call _ldHLind
	ld b,2					; b est le nombre de fois qu'on diviser HL pour obtenir un token
	call decToHexToToken
	pop bc
	ld hl,4					; Puisque la routine decToHexToToken copie à l'envers, on avance de 4
	add hl,de
	ex de,hl
	ld hl,(progASMSize)		; On met à jour la taille du programme
	inc hl
	inc hl
	ld (progASMSize),hl
	pop hl
	inc hl
	djnz equToToken			; On repete jusqu'à ce qu'il y ait un tEnter
	dec de
	ld (progASMAddr),de
	
	ld hl,(addr2Change)		; On met dans OP1 l'adresse du début de la routine If dans le programme ASM
	inc hl
	inc hl
	ld de,OP1
	ld bc,2
	ldir
	
	ld de,(OP1)				; On remplit le ld c,[...] dans la routine du If (nombre de caractères de l'équation) (0E00)
	inc de
	pop hl
	ld b,2
	call decToHexToToken
	
	ld hl,7					; On remplit le ld hl,addrEquation (210000)
	pop bc					; BC est l'ancienne taille du programme
	srl b					; On divise par 2 BC car les valeurs sont par deux quand on exécute le
	rr c					; programme (CD 55 47) mais par un quand il est stocké dans la mémoire (C D 5 5 4 7)
	call calculateAddrToToken ; Pour en savoir plus sur cette routine et ses paramètres, voir + bas
	ld hl,2					; On remplit le call addrRoutineIf (CD0000)
	ld bc,(containIf)
	srl b
	rr c
	inc bc
	call calculateAddrToToken
	
	pop bc
	ld a,c
	cp $F4
	ret z
	push bc
	push de
	ld hl,(addr2Change)		; On voit où est l'adresse du End correspondant au If
	ld b,1
	ld de,4
	call calculateTheEnd	; Cette routine sert à determiner quel End correspond
	inc hl					; On veut sont adresse ASM donc on avance de deux
	inc hl					; (deux 1er octets = adresse programme basic) (octets suivants = adresse programme ASM)
	call _ldHLind
	pop de
	pop bc
	ld a,c
	cp $F6
	call z,toWhile
	cp $F8
	ret z
	push de
	ld de,(progASMStart)	; On fait à peu près pareil que précédemment
	sbc hl,de
	srl h
	rr l
	ld b,h
	ld c,l
	ld hl,4
	pop de
	call calculateAddrToToken
	ret
	
toWhile:
	push de
	ld de,6					; Taille de l'algorithme du End
	add hl,de
	pop de
	ret

addAnAddr:
	; INPUTS
	; 	Aucun registre demandé
	; OUTPUTS
	; 	HL : Renvoie l'adresse dans la liste des adresse (listAddrs)
	; 	A : Renvoie le nombre d'adresses dans la liste des adresses
	ld hl,(progBasicAddr)	; On prend l'adresse du token pour la mettre dans une adresse libre de la
	inc hl					; liste des adresses
	ld a,(nbrAddrs)
	ld de,listAddrs
	or a					; Si c'est la première adresse qu'on stocke...
	jr z,firstAddr			; ...passer cette étape
	sla a
	sla a
	ld b,a
loopToNext:
	inc de
	djnz loopToNext
firstAddr:
	push de
	ld hl,progBasicAddr		; On copie l'adresse
	ld bc,2
	ldir
	ld hl,(progASMAddr)		; On copie l'adresse du prog ASM courrant dans la liste des adresses
	inc hl
	inc hl
	ex de,hl
	ld (hl),e
	inc hl
	ld (hl),d
	ld a,(nbrAddrs)			; On incrémente le nombre d'adresses dans la liste
	inc a
	ld (nbrAddrs),a
	pop hl
	ret
	
calculateTheEnd:
	; HL : Adresse où est stocké l'adresse où est stocké l'adresse du curseur du programme basic
	; Exemple si HL=$8263 : ($8263) = ($965A) = D4h
	ld c,1
loop1:
	add hl,de
	push hl
	call _ldHLind
	ld a,(hl)
	pop hl
	cp tIf
	jr z,addOne
	cp tWhile
	jr z,addOne
	cp tFor
	jr z,addOne
	cp tRepeat
	jr z,addOne
	cp tEnd
	jr nz,loop1Suit
	ld a,b
	sub c
	ld c,a
loop1Suit:
	ld a,c
	or a
	jr nz,loop1
	ret
addOne:
	ld a,b
	add a,c
	ld c,a
	jr loop1Suit
	
calculateAddrToToken:
	; HL : De combien faut-il avancer dans DE pour obtenir l'endroit où doit être stocké le résultat
	; DE : Adresse où est stocké la position du curseur sur le programme
	; BC : Quelle est l'adresse à stocker
	add hl,de				; On met dans HL l'adresse où va être stocké l'adresse
	push hl
	ld de,OP1+3				; On calcule l'adresse à inserer, on la transforme en tokens, on inverse
	ld hl,9327h				; les octets puis on la met dans l'adresse précédemment calculé (add hl,de)
	add hl,bc
	ld b,4
	call decToHexToToken
	ld hl,OP1
	ld de,OP1+4
	ld bc,2
	ldir
	pop de
	
	ld hl,OP1+2				; On met tout ça dans DE
	ld bc,4
	ldir
	ret

decToHexToToken:
	; HL : Ce qui doit être stocké (EX : 9263h)
	; DE : Adresse de fin où le résultat doit être stocké
	; B : De combien de caractères est composé HL (EX : Si HL==33581, BC doit être égal à 5)
	ld a,16
	call _divHLbyA	; We change to an hexadecimal number
	add a,30h
	cp 3Ah
	jp m,NAN		; If it is not a number...
	add a,7			; ...add 7 to a
NAN:
	ld (de),a		; We put the token in the adresse wich is in de
	dec de
	djnz decToHexToToken
	ret

progASMName:
	.db PROGOBJ,"FINAL",0
progBasicName:
	.db PROGOBJ,"BASIC",0
ClrHome:
	.db "CD5547" ; call _clrlcdfull
	.db "CD5B51" ; call _Grbufclr
	.db "CD7547" ; call _homeup
Disp:
	.db "210000" ; On met l'adresse du texte dans hl (par défaut $0000, modifié par la suite)
	.db "CD0D47" ; On appelle la romcall "_puts"
	.db "CD3D47" ; call _newline
DispEqual:
	.db "010000" ; ld bc,0
	.db "210000" ; ld hl,AddrDeLequation
	.db "CD0000" ; call RoutineDisp
Pause:
	.db "CDFE4C" ; call _getkey
StrEnd:
	.db "00"	 ; À la fin d'une chaîne, pour arrêter un _puts, on a besoin de deux zéros
JP:
	.db "C30000" ; JP $####
IfWhileRepeat:
	.db "010000" ; ld bc,0
	.db "210000" ; ld hl,AddrDeLequation
	.db "CD0000" ; call Equal
	.db "B7CA0000" ;or a + jp z,End
EndWhileRepeatFor:
	.db "C30000" ; On revient en haut de la boucle
StoreInVar:
	.db "C9"	 ; Fin du programme (puisqu'étant mis en même temps...)
	.db "C5CD0000" ; push bc + call Equal 
	.db "CD9242" ; call _ZEROOP2		[--
	.db "CD8E41" ; call _OP1TOOP2			peut être amélioré
	.db "CD3245" ; call _PUSHREALO2		--]
	.db "CD8E42" ; call _zeroop1
	.db "F1323A80" ; pop af + ld (OP1+1),a
	.db "CDD84E" ; call _Stoother
	.db "C9"	 ; Fin de la routine
	; Routine Disp (avec, puisque mis en même temps)
	.db "CD0000" ; call Equal
	.db "3E09"	 ; ld a,9
	.db "CD264D" ; call _formEReal
	.db "214F80" ; ld hl,OP3
	.db "CD0D47" ; call _puts
	.db "C9"	 ; Fin de la routine
RoutInput:
	.db "F53E01" ; push af + ld a,1
	.db "32C880" ; ld (ASM_IND_CALL),a
	.db "CDB250" ; call PGMIO_EXEC
	.db "CD3645" ; call _PUSHREALO1
	.db "CD8E42" ; call _zeroop1
	.db "F1323A80" ; pop af + ld (OP1+1),a
	.db "CDD84E" ; call _stoOther
	.db "C9"	 ; Fin de la routine
Input:
	.db "3E00"	 ; ld a,VAR
	.db "CD0000" ; call RoutInput
Equal:
	.db "E5C5"	 ; push hl + push bc
	.db "CD8E42" ; call _zeroop1
	.db "213980" ; ld hl,OP1
	.db "360323" ; ld (hl),EQUOBJ + inc hl
	.db "365E23" ; ld (hl),TVAREQU + inc hl
	.db "3610"	 ; ld (hl),10h
	.db "CD2A44" ; call _ChkFindSym
	.db "D4AA44" ; call nc,_DELVAR
	.db "E12600E5" ; pop hl + ld h,0 + push hl
	.db "CD7E44" ; call _CREATEEQU
	.db "1313"	 ; inc de + inc de
	.db "C1E1"	 ; pop bc + pop hl
	.db "EDB0"	 ; ldir
	.db "CD9A41" ; call _op4toop1
	.db "CD8C4E" ; call _PARSEINP
	.db "3A3B80" ; ld a,(OP1M)
	.db "0604"	 ; ld b,4
	.db "CB3F"	 ; rr a
	.db "10FC"	 ; djnz $-4
	.db "C9"	 ; Fin de la routine
progEnd:
	.db tEnter,tEnd,tEnter,"0000",tEnter,tEnd
	
.echo "Taille finale : ", $ - start * 2 + 16
.end

; Statistiques : 
; ----------------------------------------------
; La routine decToHexToToken est appelée 11 fois
;
; Il y a un total de 12 tokens supportés
; 	- ClrHome
; 	- ClrDraw
; 	- Pause 
; 	- Goto 
; 	- Label 
; 	- If 
; 	- Disp 
;	- While 
;	- Repeat 
;	- Sto
;	- Input 
;	- Prompt