; RTF module FORTH
; Guillaume Tello
; guillaume.tello@orange.fr
; july 2024
; version 1.01 : accepte les fichiers FOR en dehors de l'‚diteur
; version 1.02 : RTFtab pour fixer la taille d'une tabulation

GEMDOS MACRO    ; fn,pile
   move #\1,-(sp)
   trap #1
   if \2<=8
      addq.l #\2,sp
   else
      add.w #\2,sp
   endif
   ENDM

		section	text

debut:	
	dc.b "READ_FOM"	; identifiant module g‚n‚ral FORTH
	dc.b ".RTF"			; objets support‚s
	dc.w $0002			; type 0 = compatible PARX, sinon, n=nbr de redef diff‚rentes de modexe
	dc.b "FOR2RTF "	; nom court
	dc.w 102				; version
	dc.b "Forth source to RTF   ½2024 GT",0 ; long name (30 caractŠres + z‚ro)
	dc.b 2+1				; 2 si mots red‚finis, 1 si do_param pr‚sent
	bra modinfo
	bra modpal
	bra modexe
	bra do_param		; si bit #0
	
	; ici, type=0, red‚finition des mots modinfo, modpal, modexe si bit #1
	
	dc.b "RTFmode",0	; si l'un des mots n'est pas red‚fini,
	dc.b "RTFfont",0	   ; on met simplement dc.b 0
	dc.b "RTFsave",0		; fonction 1
	dc.b "RTFtab",0		; fonction 2
	even					; assure la parit‚
	
	
	; langue ordre p modinfo
	; en 4(SP)on trouve SNDB
	; sur A6 la pile FORTH

	; flag RTFmode	: 0 ASCII Atari, 1 ASCII Ibm	
modinfo:
	lea ibm(pc),a0
_flag_comm:
	tst.l (a6)+
	sne (a0)
	moveq #2,d0			; Ok ou 0 pour erreur
	rts

	; selon le mode (… r‚gler avant!)
	; IBM   : " .." RTFfont
	;		Donne le nom de la famille de fontes, par d‚faut " Arial"
	;		si 0 au lieu d'une adresse, revient au d‚faut.
	; Atari : n RTFfont
	;		Si n=0, revient au r‚glage par d‚faut : System Font
	; 		Sinon, 1,2,3 pour Normal, Gras, Italique et ID de la fonte et dessous chaine du nom.
	;     Exemple: " Bitstream Charter" 5648 1 RTFfont
	
modpal:
	lea defaut(pc),a2
	tst.b 1(a2)			; pc ou atari?
	beq.s .atari
	move.l (a6)+,d0	; adr ou 0 ?
	sne (a2)				; 0 si 0 (d‚faut), FF sinon
	bne.s .famille
	bra.s .exit
.famille:
	move.l d0,a0
	lea famille(pc),a1
.copy:
	move.b (a0)+,(a1)+
	bne.s .copy
.exit
	moveq #2,d0
	rts
.bug: moveq #0,d0
	rts
.atari:
	move.l (a6)+,d0	; code
	sne (a2)				; 0 si 0 (defaut), FF sinon
	beq.s .exit		
	bmi.s .bug
	cmp.l #3,d0
	bgt.s .bug
	lea fonten(pc),a0
	lea nomn(pc),a1
	lsl.l #3,d0			; *8
	lea -8(a0,d0.l),a0	; pointe sur le bon identifiant
	lsr.l #1,d0
	muls #9,d0			; *36
	lea -36(a1,d0.l),a1	; pointe sur le bon nom
	move.l (a6)+,d3	; identifiant
	move.l (a6)+,a2	; nom
.nom:
	move.b (a2)+,(a1)+	; nom copi‚
	bne.s .nom
	move.b #'f',(a0)+		; identifiant pr‚c‚d‚ de f
	ext.l d3
	bpl.s .lb0				; si positif, tout va
	neg.l d3
	move.b #'-',(a0)+		; sinon, on colle un signe
.lb0:
	move.l a0,a1			; passe par A1 car aussi appel‚ par header
	bsr.s d3_to_str_a1
	bra.s .exit	

d3_to_str_a1:
	lea mot+10(pc),a2		; zone temporaire
	clr.b (a2)				; pour terminer le nombre
.lb0:
	divs #10,d3
	swap d3
	add.b #'0',d3
	move.b d3,-(a2)
	clr d3
	swap d3
	bne.s .lb0
.copy:
	move.b (a2)+,(a1)+
	bne.s .copy	
	rts


	; sauvegarde les valeurs du FORTH
	; v‚rifie la pr‚sence de l'interpr‚teur par l'adresse de buf0 (routine=0 si absent)
		
do_param:
	bsr save_forth_values
	move #96,d0				; pad
	bsr exec_forth
	move.l adresse(pc),a0
	tst.l 709*4(a0)		; sommes nous sous l'interpr‚teur?
	bne.s .inter			; si oui, r‚cup‚rer les adresses de l'‚diteur
	clr.l -(a6)				; sinon, simuler !
	clr.l -(a6)
	clr.l -(a6)
	clr.l -(a6)
	bra.s .suite	
.inter:
	move #602,d0			; bstart variable.w
	bsr exec_forth
	move #159,d0			; bsize variable.w
	bsr exec_forth
	move #168,d0			; lmax variable.w
	bsr exec_forth
	move #709,d0			; buf0
	bsr exec_forth
.suite:
	lea beuf(pc),a0
	move.l (a6)+,(a0)+	; buf0 adresse du source
	move.l (a6)+,(a0)+	; lmax derniŠre ligne du source
	move.l (a6)+,(a0)+	; bsize nombre de lignes-1 du block
	move.l (a6)+,(a0)+	; bstart num‚ro de la 1ere ligne du block
	move.l (a6)+,(a0)+	; pad, servira de buffer temporaire
	lea defaut(pc),a0
	clr.l (a0)				; falgs … z‚ro (defaut et Atari)
	moveq #0,d0				; OK
	rts

;get_intout:
;	move.l vdipb(pc),a0
;	move.l 12(a0),a0		; intout	
;	rts

save_forth_values:
	lea debut(pc),a0		; r‚cupŠre les donn‚es envoy‚es par MODLOAD
	lea adresse(pc),a1
	move.l -(a0),(a1)+	; adresse
	move.l -20(a0),a0		; extra data
	move.l (a0)+,(a1)+	; ordres
	move.l (a0)+,(a1)+	; nombre de mots FORTH
	move.l (a0)+,(a1)+	; nombre de mots cr‚ants
	rts

	; d0=code du mot FORTH … ‚x‚cuter
	
exec_forth:
	lea adresse(pc),a0
	move.l (a0),a0			; base des adresses
	lsl.w #2,d0
	move.l 0(a0,d0.w),a0	; adresse du mot
	jsr (a0)					; execute
	rts

; pile 4(SP):sndb (avec a4-a5-a6 sauv‚s, c'est 16(sp))

modexe:
	moveq #0,d7				; revoi par d‚faut
	cmp.l #'XFOM',d1
	bne.s .exit				; ici choisir que faire si appel direct … modexe
								; message d'erreur ou un traitement par d‚faut
	cmp #1,d0				; est-ce RTFsave?
	bne _fonction2			; non, on saute
	move.l (a6)+,d0		; nom fichier
	movem.l a4-a6,-(sp)	; les registres du FORTH	
	clr -(sp)				; fichier normal
	move.l d0,-(sp)	; nom du fichier
	GEMDOS 60,8				; cr‚ation
	move.l d0,d7			; handle
	bgt.s .ok
.bug:
	movem.l (sp)+,a4-a6	; r‚cupŠre
	moveq #0,d0				; 0 erreur
	rts
.fin:
	movem.l (sp)+,a4-a6
	move d7,-(sp)
	move.l d0,d7			; conserve valeur retour
	GEMDOS 62,4				; fclose
	tst.l d0					; erreur fichier ?
	beq.s .exit				; non, garder D7
	moveq #0,d7				; si erreur, annuler valeur de retour!
.exit:
	move.l d7,d0			; valeur renvoy‚e
	rts
.ok:
	lea defaut(pc),a5		; les 4 octets de config
	clr 2(a5)				; new et mode
	clr.l 4(a5)				; compte
	bsr header
	beq.s .fin				; erreur d'‚criture header

	move.l 16(sp),a0		; le SNDB
	move.l debut+8(pc),d0	; code ".RTF"
	cmp.l (a0),d0			; valeur magique?
	bne.s .editeur
	clr.l (a0)+				; efface valeur magique pour le prochain appel
	moveq #0,d0				; si valeur magique, fichier FOR charg‚ ailleurs
	move.l (a0)+,a3		; adresse du fichier FOR
	cmp.l a3,d0
	beq.s .fin				; adresse nulle...???
	move (a3),d6			; nombre de lignes
	addq.l #6,a3			; saute lignes/taille totale
	subq #1,d6				; pour la boucle
	bra.s .lb0				; et on y va !		
.editeur:
	moveq #0,d0
	lea beuf(pc),a0
	move.l (a0)+,a3		; pointeur texte source
	cmp.l a3,d0
	beq.s .fin				; erreur, l'‚diteur n'est pas disponible
	move.l (a0)+,a1		; pointeur sur lmax
	move.l (a0)+,a2		; pointeur sur bsize
	move.l (a0)+,a0		; pointeur sur bstart
	move (a1),d6			; lmax, nombre de lignes … traiter
	subq #1,d6				; pour la boucle
	move (a0),d0			; bstart
	bmi.s .lb0				; si <0, pas de bloc, A3/D6 correct
	move (a2),d2			; bsize
	bpl.s .lb1				; taille correcte
	sub d0,d6				; sinon de bstart … lmax
	bra.s .lb2
.lb1:
	move d2,d6				; nombre de lignes vient de bsize
.lb2:	
	bra.s .lb3
.lb4:
	add (a3),a3				; avance vers la premiŠre ligne
.lb3:
	dbf d0,.lb4
.lb0:
	move.l pad(pc),a1		; pointeur de ligne
	bsr tabulations
	tst.l 4(a5)				; compte?
	beq.s .suite			; si nul, interpr‚ter la ligne
	cmp.b #'>',(a3)		; on cherche >comp...
	bne.s .lb12
	cmp.l #'comp',1(a3)
	bne.s .lb12
	move.b 5(a3),d0
	beq.s .yes				; >comp suivi de z‚ro
	cmp.b #' ',d0			; ou >comp suivi d'un espace?
	bne.s .lb12
.yes:
	clr.l 4(a5)				; >comp trouv‚, annule compte
	bra.s .suite			; et continue l'interpr‚tation
.lb12:
	subq.l #1,4(a5)		; sinon, un compte de moins
	bsr ajoute_ligne		; et ajoute la ligne sans interpr‚tation
	bsr copie_mot
	bra.s .lb13				; finit ligne et boucle
.suite:
	bsr motsuivant			; nouveau mot
	bne.s .lb5				; il y a bien un mot sur la ligne
.lb13:
	bsr finir_ligne		; sinon, fin de ligne et ‚crire
	beq .fin					; erreur d'‚criture...
	bra .boucle
.lb5:
	move.b 3(a5),d5		; 0, mode normal, 3 si mot … souligner
	clr.b 3(a5)
	lea mot(pc),a0
	cmp #$5C00,(a0)		; \ tout seul, donc une remarque
	bne.s .lb7
	bsr prepare_comm
	moveq #2,d5				; mode italique
	bra.s .lb6				; et voil… !
.lb7:
	bsr trouve_mot
	beq.s .lb6				; pas trouv‚, garder mode D5
	cmp.l dico(pc),d4
	bpl.s .lb6				; mot en dehors des mots FORTH
	moveq #1,d5				; sinon, mode gras
	moveq #3,d0				; au cas ou pour souligner
	cmp #919,d4				; >fom ?
	beq.s .souligne
	cmp #78,d4				; d‚but de def?
	beq.s .souligne
	cmp #571,d4				; debut def assembleur?
	beq.s .souligne
	cmp.l create(pc),d4	; mot cr‚ant?
	bmi.s .souligne
	lea mot(pc),a0
	cmp.b #'&',(a0)		; mot commen‡ant par &?
	beq.s .souligne
	moveq #0,d0
.souligne:
	move.b d0,3(a5)		; nouveau mode de soulignement
.lb6:
	bsr adapte_mode		; modifier le mode d'‚criture ‚ventuellement
	bsr copie_mot			; ajoute le mot
	cmp #138,d4				; chaine … suivre?
	bne.s .lb8
.lb9:
	bsr chaine				; les ." et "
	moveq #0,d5				; retour … la normale
	bsr adapte_mode
	bsr copie_mot			; ajoute  la chaŒne
	bra .suite
.lb8:
	cmp #139,d4				; chaine … suivre?
	beq.s .lb9
	cmp #862,d4				; >include
	bne.s .lb10
.lb11:
	bsr directives
	bra .suite
.lb10:
	cmp #865,d4				; >export
	beq.s .lb11
	cmp #866,d4				; >exec
	beq.s .lb11
	cmp #902,d4				; >ask
	beq.s .lb11
	cmp.b #3,2(a5)			; est-ce un mot soulign‚?
	bne .suite				; non !
	moveq #0,d5				; si oui, revenir tout de suite au mode normal
	bsr adapte_mode
	bra .suite				; mot suivant!
.boucle:
	dbf d6,.lb0				; encore des lignes?
	bsr termine				; termine le fichier
	bra .fin

tabulations:
	addq.l #2,a3			; saute la taille de la ligne
	moveq #0,d0
	move.b (a3)+,d0
	subq #1,d0				; tabulations
	divs #3,d0				; groupes de 3
	beq.s .lb5
	bra.s .lb0
.lb1:
	move.b #'\',(a1)+
	move.b #'t',(a1)+
	move.b #'a',(a1)+
	move.b #'b',(a1)+
.lb0:
	dbf d0,.lb1
	move.b #' ',(a1)+		; pour finir les tab
.lb5:
	swap d0					; reste de 0 … 2
	bra.s .lb6
.lb3:
	move.b #' ',(a1)+
.lb6:
	dbf d0,.lb3
.lb4:
	rts	

	; copie de mot vers pad en arrangeant les caractŠres sp‚ciaux \,{,}
	; et en modifiant les caractŠres 128-255 si le mode IBM est demand‚
	
copie_mot:
	lea mot(pc),a0
	lea vers_ibm(pc),a2
.lb0:
	moveq #0,d0
	move.b (a0)+,d0
	beq.s .fin
	cmp #'\',d0
	beq.s .double
	cmp #'{',d0
	beq.s .double
	cmp #'}',d0
	bne.s .simple
.double:
	move.b #'\',(a1)+
.simple:
	tst.b 1(a5)				; jeu IBM ?
	beq.s .no_trans		; non, on garde l'Atari
	btst #7,d0				; caractŠre 128-255 ?
	beq.s .no_trans		; no, rien … faire
	move.b -128(a2,d0.l),d0	; sinon, passer au monde PC
.no_trans:
	move.b d0,(a1)+
	bra.s .lb0		
.fin:
	rts

finir_ligne:
	move.b #'\',(a1)+		; demande un nouveau paragraphe
	move.b #'p',(a1)+
	move.b #'a',(a1)+
	move.b #'r',(a1)+
	move.b #' ',(a1)+
	bra write				; ‚crit sur disque

motsuivant:
	move.b (a3)+,d0
	beq.s .finligne
	cmp #32,d0
	bne.s .trouve
	move.b d0,(a1)+	; ajoute l'espace si c'en est un
	bra.s motsuivant
.trouve:
	lea mot(pc),a0
	moveq #0,d1			; taille
.lb0:
	move.b d0,(a0)+
	addq #1,d1
	move.b (a3)+,d0
	beq.s .fin
	cmp.b #32,d0
	bne.s .lb0
.fin:
	clr.b (a0)
	subq.l #1,a3
	moveq #1,d0			; renvoie NE si un mot trouv‚
	rts
.finligne:
	subq.l #1,a3
	moveq #0,d0			; renvoie EQ si fin ligne
	rts

	; cherche si le mot existe dans le dictionnaire
	; en entr‚e: mot et d1 sa taille
	; en sortie NE si trouv‚ et d4 son code
	; EQ si pas trouv‚
	
trouve_mot:
	moveq #0,d4
	move.l ordres(pc),a0
   moveq #0,d2
.autre:  move.b (a0)+,d2
   beq.s .findic
   cmp.b d1,d2
   beq.s .voyons
.bennon: add.l d2,a0
   addq.l #1,d4
   bra.s .autre
.voyons: lea mot(pc),a2
   move d2,d3
   subq #1,d3
   move.l a0,a6
.lab6:   cmp.b (a2)+,(a6)+
   dbne d3,.lab6
   bne.s .bennon
.findic:
	tst.b d2				; renvoie EQ si fin du dictionnaire
	rts					; NE si mot trouv‚
	
header:
	move.l pad(pc),a1
	tst.b 1(a5)			; mode !
	beq.s .atari
	lea rtf_starti(pc),a0
	bsr.s .add_a0
	lea defaut_ibm(pc),a0
	tst.b (a5)			; d‚faut ou pas?
	beq.s .lb0
	lea famille(pc),a0
.lb0:
	bsr.s .add_a0
	lea rtf_starti2(pc),a0
	bsr.s .add_a0
	move.l tab(pc),d3
	cmp.l #720,d3
	beq write					; tabulation par d‚faut, rien … faire
	subq.l #1,a1				; revient sur l'espace
	lea deftab(pc),a0
	bsr .add_a0					; \deftab
	bsr d3_to_str_a1			; \deftabxxx
	move.b #32,-1(a1)			; remplace le dernier z‚ro par un espace	
	bra write
.add_a0:
	move.b (a0)+,(a1)+
	bne.s .add_a0
	subq.l #1,a1
	rts	
.add_a0_fonten:
	bsr.s .add_a0
	lea fonten(pc),a0
	bra.s .add_a0
.atari:
	lea defaut_atari(pc),a0
	tst.b (a5)
	beq.s .lb1
	lea rtf_starta(pc),a0
	bsr.s .add_a0_fonten	
	lea rtf_starta2(pc),a0
	bsr.s .add_a0
	move.l a4,-(sp)
	lea fonten(pc),a2
	lea nomn(pc),a4
	moveq #2,d2
.fontes:
	move.b #'{',(a1)+
	move.b #'\',(a1)+
	move.l a2,a0
	bsr.s .add_a0
	lea rtf_starta3(pc),a0
	bsr.s .add_a0
	move.l a4,a0
	bsr.s .add_a0
	move.b #';',(a1)+
	move.b #'}',(a1)+
	addq.l #8,a2
	lea 36(a4),a4
	dbf d2,.fontes
	move.l (sp)+,a4
	lea rtf_starta4(pc),a0
	bsr.s .add_a0_fonten
	lea rtf_starta5(pc),a0
.lb1:
	bsr.s .add_a0
	move.l tab(pc),d4
	cmp.l #720,d4
	beq.s write					; tabulation par d‚faut, rien … faire
	subq.l #1,a1				; revient sur l'espace
	move.l d4,d5				; premiŠre tabulation
	moveq #25,d2				; pas plus de 26 tabul en FORTH
.txloop:
	cmp.l #10000,d5
	bpl.s .txend
	move.b #'\',(a1)+
	move.b #'t',(a1)+
	move.b #'x',(a1)+
	move.l d5,d3
	bsr d3_to_str_a1			; \deftabxxx
	subq.l #1,a1				; revient sur le z‚ro
	add.l d4,d5					; nouvelle tabulation
	dbf d2,.txloop				; limite et suivant
.txend:
	move.b #32,(a1)+			; remplace le dernier z‚ro par un espace	
		
	
	; continue sur write!
	; ...
	; ne pas s‚parer ici!
			
	; block dans pad, a1 pointe sur 1er octet libre
	; renvoie NE si ‡a roule, EQ si erreur

write:
	move.l a1,d3
	move.l pad(pc),a0
	sub.l a0,d3				; nombre d'octets
	pea (a0)					; buffer
	move.l d3,-(sp)		; taille
	move d7,-(sp)			; handle
	GEMDOS 64,12
	cmp.l d0,d3				; tout a bien ‚t‚ ‚crit?
	beq.s .ok
	moveq #0,d0
	rts
.ok:
	moveq #2,d0			
	rts
		
termine:
	lea rtf_end(pc),a0
	move.l pad(pc),a1
.lb0:
	move.b (a0)+,(a1)+
	bne.s .lb0
	subq.l #1,a1
	bra.s write

	; entr‚e 2(a5) mode en cours, D5 mode voulu!
	; utilise d0
	
adapte_mode:
	cmp.b 2(a5),d5
	bne.s .lb0
	rts						; si ‚gal, rien … changer
.lb0:
	cmp #$FF00,(a5)		; mode Atari+Fontes ?
	beq.s .atarif			; oui!	
	move.b 2(a5),d0		; sinon ici, seulement \b,\i,\ul
	beq.s .lb1				; mode normal, rien … mettre
	bsr.s .code
	move.b #'0',(a1)+		; arrˆte l'ancien mode
.lb1:
	move.b d5,d0
	beq.s .lb2
	bsr.s .code
.lb2:
	move.b #' ',(a1)+		; et termine les codes
	move.b d5,2(a5)		; et met … jour
	rts
.code:
	move.b #'\',(a1)+
	cmp.b #1,d0
	bne.s .c2
	move.b #'b',(a1)+		; 1 = BOLD
	rts
.c2:
	cmp.b #2,d0
	bne.s .c3
	move.b #'i',(a1)+		; 2 = ITALIC
	rts
.c3:
	move.b #'u',(a1)+		; 3 = UNDERLINE
	move.b #'l',(a1)+
	rts
.atarif:
	move.b #'\',(a1)+
	move.b 2(a5),d0		; mode actuel
	cmp.b #3,d0				; underline?
	bne.s .af1
	bsr.s .c3				; ajoute ul
	move.b #'0',(a1)+		; \ul0
	move.b #'\',(a1)+	
.af1:
	cmp.b #3,d5
	bne.s .af2
	bsr.s .c3				; \ul
	move.b #'\',(a1)+
	moveq #0,d0				; en mode 3, force la fonte normale
	bra.s .af4
.af2:
	move.l d5,d0
.af4:
	lsl.l #3,d0
	lea fonten(pc),a0
	add.l d0,a0				; pointe sur la fonte selon 0/1/2
.af3:
	move.b (a0)+,(a1)+	; copie le  num‚ro de la fonte
	bne.s .af3
	subq.l #1,a1
	bra.s .lb2				; termine les codes

	; on vient de trouver "\ ", donc reste de ligne comme comentaire
	
prepare_comm:
	lea mot+1(pc),a0
.lb0:
	move.b (a3)+,(a0)+
	bne.s .lb0
	subq.l #1,a3
	rts

	; ici on traŒte les ." et "
chaine:
	lea mot(pc),a0
_ch_comm:
	move.b (a3)+,d0	; un caractŠre
	beq.s _ch_oups		; z‚ro? chaine mal finie...
	move.b d0,(a0)+
	cmp.b #34,d0		; est-ce le guillement final?
	bne.s _ch_comm		; non, on avance
	bra.s _ch_fin
_ch_oups:
	subq.l #1,a3		; en cas de z‚ro, revient dessus
_ch_fin:
	clr.b (a0)			; marque la fin
	rts

	; ici on traite les directives suivies d'une chaine
directives:
	lea mot(pc),a0
.lb0:
	move.b (a3)+,d0
	beq.s _ch_oups		; z‚ro, erreur...
	move.b d0,(a0)+
	cmp.b #34,d0		; cherche le " initial
	bne.s .lb0		
	bsr.s _ch_comm		; puis jusqu'… la fin de la chaŒne
	moveq #0,d5
	bsr adapte_mode	; mode normal
	bsr copie_mot		; et copie la chaŒne
	cmp #862,d4			; pour >include, c'est fini
	beq.s .exit
	cmp #902,d4			; pour >ask aussi
	beq.s .exit
	cmp #866,d4			; >exec?
	bne.s .lb1		
	; ici >exec, ajouter une ligne de plus pour la chaine de commande
;.lb3:
;	tst.b (a3)+
;	bne.s .lb3
;	subq.l #1,a3		; atteint le d‚but de ligne suivante
	moveq #1,d0			; nombre de lignes
	bra.s .lb2
.lb1:
	cmp #865,d4			; >export?
	bne.s .exit			; normalement impossible...
	; ici copie toutes les lignes suivantes jusqu'… ">comp"
	moveq #-1,d0
.lb2:
	move.l d0,4(a5)	; dans compte
.exit:
	rts

	; ici pour les lignes ajout‚es sans interpr‚tation
	; (export par exemple)	
ajoute_ligne:
	lea mot(pc),a0
.lb0:
	move.b (a3)+,(a0)+
	bne.s .lb0
	subq.l #1,a3
	rts

_fonction2:				; ici RTFtab
	lea tab(pc),a0
	move.l (a6)+,(a0)
	moveq #2,d0			; renvoie 2, Ok
	rts
	

	data
	
tab: dc.l 720			; tabulation par d‚faut

rtf_starta:  dc.b "{\rtf0\pc\def",0
rtf_starta2: dc.b "{\fonttbl",0
rtf_starta3: dc.b "\fnil ",0
rtf_starta4: dc.b "}\pard\ql\",0
rtf_starta5: dc.b "\fs24 ",0
rtf_starti: dc.b "{\rtf0\pc\deff1{\fonttbl{\f1\froman\fpqr2\fcharset0 ",0
rtf_starti2 dc.b ";}}\pard\ql\f1\fs24 ",0
defaut_ibm: dc.b "Arial",0
defaut_atari: dc.b "{\rtf0\pc\deff1{\fonttbl{\f1\fnil System Font;}}\pard\ql\f1\fs24 ",0
rtf_end:	dc.b "\sect}",0
deftab: dc.b "\deftab",0
vers_ibm: dc.b $c7,$fc,$e9,$e2,$e4,$e0,$e5,$e7	; 128 … 135
			 dc.b $ea,$eb,$e8,$ef,$ee,$ec,$c4,$c5	; 136 … 143
			 dc.b $c9,$e6,$c6,$f4,$f6,$f2,$fb,$f9	; 144 … 151
			 dc.b $ff,$d6,$dc,$f8,$a3,$d8,$d7,$83	; 152 … 159
			 dc.b $e1,$ed,$f3,$fa,$f1,$d1,$aa,$ba	; 160 … 167
			 dc.b $bf,$ae,$ac,$bd,$bc,$a1,$ab,$bb	; 168 … 175
			 dc.b $b0,$b1,$b2,$b3,$b4,$c1,$c2,$c0	; 176 … 183
			 dc.b $a9,$b9,$ba,$bb,$bc,$a2,$a5,$bf	; 184 … 191
			 dc.b $c0,$c1,$c2,$c3,$c4,$c5,$e3,$c3	; 192 … 199
			 dc.b $c8,$c9,$ca,$cb,$cc,$cd,$ce,$a4	; 200 … 207
			 dc.b $f0,$d0,$ca,$cb,$c8,$d5,$cd,$ce  ; 208 … 215
			 dc.b $cf,$d9,$da,$db,$dc,$a6,$cc,$df	; 216 … 223
			 dc.b $d3,$df,$d4,$d2,$f5,$d5,$b5,$fe	; 224 … 231
			 dc.b $de,$da,$db,$d9,$fd,$dd,$af,$b4	; 232 … 239
			 dc.b $f0,$b1,$f2,$be,$b6,$a7,$f7,$b8	; 240 … 247
			 dc.b $b0,$a8,$b7,$b9,$b3,$b2,$fe,$ff	; 248 … 255

	even
	
	bss
	
adresse: ds.l 1	; les adresses mots forth
ordres:	ds.l 1	; les mots forth	
dico:		ds.l 1	; combien de mots forth de base
create:	ds.l 1	; combien de mots g‚n‚rants
	; ne pas s‚parer
beuf:		ds.l 1
lmax:		ds.l 1
bsize:	ds.l 1
bstart:	ds.l 1
pad:		ds.l 1
defaut:	ds.b 1	; 0 si d‚faut (Atari = system font, IBM=Arial), sinon lire donn‚es
ibm:		ds.b 1	; FF si passer aux codes ASCII PC
mode:		ds.b 1	; 0 normal, 1 gras, 2 italique, 3 soulign‚
new:		ds.b 1	; FF si mot suivant cr‚‚
compte:	ds.l 1	; combien de lignes … ajouter sans interpr‚ter?
						; 0 si pas de comptage, -1 pour mode infini avec recherche de >comp
	; jusqu'ici
mot:		ds.b 82	; de quoi tenir une ligne !
famille: ds.b 32	; nom de la famille de fontes PC
fonten:	ds.b 8	; NORMAL de quoi contenir fxxxxx + 0, son identifiant
fonteg:	ds.b 8	; gras
fontei:	ds.b 8	; italique
nomn: 	ds.b 36	; nom de la fonte (32 octets +0)
nomq:		ds.b 36
nomi:		ds.b 36

	end