*SOURCE*

******************* Cherche et remplace by GRC *****************


* Cherche dans un fichier une liste de mots spécifiés et les remplace
* par leur équivalence



print:	MACRO
	movem.l	d0-d7/a0-a6,-(a7)
	move.l	dos,a6
	move.l	output,d1
	move.l	#\1,d2
	move.l	#\2,d3
	jsr	-48(a6)			; write
	movem.l	(a7)+,d0-d7/a0-a6
	ENDM

lockit:	MACRO
	move.l	dos,a6
	move.l	\1,d1
	move.l	#-2,d2			; lire
	jsr	-84(a6)			; lock
	move.l	d0,\2
	tst.l	d0
	ENDM

examine:MACRO
	move.l	\1,d1
	move.l	#\2,d2
	jsr	-102(a6)		; examine
	tst.l	d0
	ENDM

unlock:	MACRO
	move.l	\1,d1
	jsr	-90(a6)			; unlock
	ENDM
	
alloc:	MACRO
	move.l	4,a6
	move.l	\1,d0
	move.l	#$10000,d1		; public + clear
	jsr	-198(a6)		; allocmem
	move.l	d0,\2
	tst.l	d0
	ENDM
	
openr:	MACRO
	move.l	dos,a6
	move.l	\1,d1
	move.l	#1005,d2		; mode old
	jsr	-30(a6)			; open
	move.l	d0,\2
	tst.l	d0
	ENDM

openw:	MACRO
	move.l	dos,a6
	move.l	\1,d1
	move.l	#1006,d2		; mode new
	jsr	-30(a6)			; open
	move.l	d0,\2
	tst.l	d0
	ENDM

read:	MACRO
	move.l	dos,a6
	move.l	\1,d1
	move.l	\2,d2			; buffer
	move.l	\3,d3			; longueur
	jsr	-42(a6)			; read
	ENDM

write:	MACRO
	move.l	dos,a6
	move.l	\1,d1
	move.l	\2,d2			; buffer
	move.l	\3,d3			; longueur
	jsr	-48(a6)			; write
	ENDM
	
close:	MACRO
	move.l	dos,a6
	move.l	\1,d1
	jsr	-36(a6)			; close
	ENDM


RawdoFMT:MACRO
	movem.l	d0-d7/a0-a6,-(a7)
	move.l  4,a6
	lea     \1,a0           ; texte a convertir
	lea     \2,a1           ; données
	lea     putchproc,a2    ; routine a appeler
	lea     \3,a3           ; destination
	jsr     -522(a6)        ; rawdofmt
	movem.l	(a7)+,d0-d7/a0-a6
	ENDM



c_et_r:
	movem.l	d0/a0,-(a7)

	bsr	open_lib
	beq	error
	move.l	dos,a6
	jsr	-60(a6)			; output
	move.l	d0,output

	movem.l	(a7)+,d0/a0

	subq	#1,d0		; si aucun parametre
	beq	info		; affichage d'un texte d'info

search:

	cmp.b	#$20,(a0)+	; on cherche l'argument (apres espace)
	bne.s	.f		; trouve
	dbra	d0,search	; d0 contient le nombre de carac.
				; constituant le parametre
	bra	info
.f:
	
	subq	#1,a0
	move.l	a0,found
search2:
	cmp.b	#$20,(a0)+
	beq.s	.f
	dbra	d0,search2

	bra	info
.f:
	clr.b	-1(a0)
	move.l	a0,found2

search3:
	cmp.b	#$20,(a0)+
	beq.s	.f
	dbra	d0,search3

	bra	info
.f:
	clr.b	-1(a0)
	move.l	a0,found3
zero:
	cmp.b	#$0a,(a0)+
	beq.s	.f
	dbra	d0,zero
.f:	clr.b	-1(a0)


	print	message,message_long

	lockit	found,lock
	beq	error_lock
	examine	lock,fileinfo
	beq	error
	lea	fileinfo,a0
	move.l	124(a0),longueur	; longueur du fichier en octets
	unlock	lock


	lockit	found2,lock
	beq	error_lock
	examine	lock,fileinfo
	beq	error
	lea	fileinfo,a0
	move.l	124(a0),longueur2	; longueur du fichier en octets
	unlock	lock


	print	processing,processing_long

all:
	alloc	longueur,mem
	beq	error_mem
	print	alloc_file_ok,alloc_file_ok_long

	alloc	longueur2,mem2
	beq	error_mem
	print	alloc_eq_ok,alloc_eq_ok_long

	openr	found,file
	beq	error_lock	
	read	file,mem,longueur

	print	lecture_file,lecture_file_long

	close	file
	

	openr	found2,file
	beq	error_lock	
	read	file,mem2,longueur2

	print	lecture_eq,lecture_eq_long

	close	file



	print	process,process_long



	move.l	mem,a0			; début du fichier à traiter
	move.l	a0,a1
	add.l	longueur,a1		; fin

	move.l	mem2,a2			; début du fichier des équivalences
	move.l	a2,a3
	add.l	longueur2,a3		; fin

	lea	table,a4		; table ou l'on range l'adresse du mot
					; trouvé et son équivalence

	move.l	a0,d0			; note de l'adresse de départ fich
	move.l	a2,d1			; note de l'adresse de départ eq
	clr.l	d7

	bra	affi_eq
compare:
	move.b	(a2),d2
	cmp.b	(a0),d2			; 1er octet fichier = equivalence
	beq	vrai
	addq	#1,a0
	cmp.l	a1,a0
	bhs	autre_eq		; on a plus rien a chercher pour
					; cette équivalence
	addq	#1,d0

	btst	#7,$bfe001
	beq	fine

	bra	compare	
vrai:
	addq	#1,a0
	addq	#1,a2
	addq	#1,d7
	
	cmp.b	#"=",(a2)
	beq	on_a_le_mot

	move.b	(a2),d2
	cmp.b	(a0),d2
	beq	vrai

	move.l	d1,a2
	addq	#1,d0
	move.l	d0,a0
	clr.l	d7
	bra	compare			; ici la comparaison est mauvaise

on_a_le_mot:
	cmp.l	#fintable,a4
	bhs	fine			; pour overflow
	
	move.l	d0,(a4)+		; on sauve l'adresse du mot a changer
	addq	#1,a0
	move.l	a0,d0
	addq	#1,a2			; on sauve son équivalent
	move.l	a2,(a4)+

	move.l	d7,(a4)+		; on sauve la longueur a sauter

	clr.l	d7
.eq:
	cmp.l	a3,a2
	bhs.s	eqtu
	addq	#1,d7
	cmp.b	#$0a,(a2)+
	bne.s	.eq
eqtu:
	subq	#1,d7
	move.l	d7,(a4)+		; on sauve la longueur de l'equivalent

	clr.l	d7
	move.l	d1,a2			; pour regarder s'il y en a pas d'autre
	bra	compare

autre_eq:
	move.l	mem,a0
	move.l	a0,d0
	move.l	d1,a2
	clr.l	d7
a_eq:
	cmp.l	a3,a2
	bhs.s	fine
	addq	#1,d7
	cmp.b	#$0a,(a2)+
	bne.s	a_eq

	move.l	a2,d1

affi_eq:
	movem.l	d0-d7/a0-a6,-(a7)
	clr.l	d7
	move.l	a2,a6
s_long:
	cmp.l	a3,a6
	bhs.s	fine2
	addq	#1,d7
	cmp.b	#"=",(a6)+
	bne.s	s_long

	subq	#1,d7

	move.l	dos,a6
	move.l	output,d1
	move.l	a2,d2
	move.l	d7,d3
	jsr	-48(a6)			; write eq
	move.l	output,d1
	lea	CR,a2
	move.l	a2,d2
	move.l	#3,d3
	jsr	-48(a6)			; write CR+Erase line
	movem.l	(a7)+,d0-d7/a0-a6

	clr.l	d7
	bra	compare			; c'est reparti

fine2:
	movem.l	(a7)+,d0-d7/a0-a6
fine:

	print	ecrit_file,ecrit_file_long

	openw	found3,file
	beq	error_lock

	move.l	mem,a0
	move.l	a0,a1
	add.l	longueur,a1
	lea	table,a4

	clr.l	ratio
	move.l	#100,ratioprint
ecrit:
	btst	#7,$bfe001
	beq	hop

	cmp.l	(a4)+,a0		; un mot a modifier ?
	beq	ecrit_eq

	add.l	#3*4,a4			; on saute les autre données
	cmp.l	#fintable,a4
	blo.s	ecrit
	lea	table,a4

	movem.l	a0-a4,-(a7)
	move.l	dos,a6
	move.l	file,d1
	move.l	a0,d2			; buffer
	move.l	#1,d3			; longueur
	jsr	-48(a6)			; write
	movem.l	(a7)+,a0-a4

	add.l	#1,ratio

	move.l	ratio,d0
	cmp.l	ratioprint,d0		; octets écrit
	blo.s	pas_affi_ratio

	rawdofmt percentraw,ratio,percent	; affichage de la longueur
	print	percent,percent_long		; du fichier écrit

	move.l	ratio,ratioprint
	add.l	#100,ratioprint
pas_affi_ratio:

	addq	#1,a0
	cmp.l	a0,a1
	bhs	ecrit

	bra	hop
ecrit_eq:
	move.l	(a4)+,a3		; adresse de l'equivalent
	move.l	mem2,a5
	add.l	longueur2,a5
ecrit_eq_loop:

	movem.l	a0-a5,-(a7)
	move.l	dos,a6
	move.l	file,d1
	move.l	a3,d2			; buffer
	move.l	4(a4),d3		; longueur de l'equivalent
	add.l	d3,ratio
	jsr	-48(a6)			; write
	movem.l	(a7)+,a0-a5


	add.l	(a4)+,a0
	add.l	#4,a4
	bra	ecrit

hop:
	rawdofmt percentraw,ratio,percent	; affichage de la longueur
	print	percent,percent_long		; du fichier écrit

	close	file


	print	fin_trait,fin_trait_long


fin:
;	btst	#6,$bfe001
;	bne.s	fin

	tst.l	mem
	beq.s	pas_alloc
	move.l	4,a6
	move.l	mem,a1
	move.l	longueur,d0
	jsr	-210(a6)		; freemem fichier
	tst.l	mem2
	beq.s	pas_alloc
	move.l	4,a6
	move.l	mem2,a1
	move.l	longueur2,d0
	jsr	-210(a6)		; freemem equivalences
pas_alloc:
	bsr	close_lib
	moveq	#0,d0
	rts

error:
	moveq	#103,d0
	rts

error_lock:
	print	no_find,no_find_long
	bra	fin
error_mem:
	print	pas_mem,pas_mem_long
	bra	fin
	
info:
	print	message,message_long
	print	notice,notice_long
	bra	fin


open_lib:
	move.l	4,a6
	lea	dos_name,a1
	jsr	-408(a6)		; openlib()
	move.l	d0,dos
	tst.l	d0
	rts
close_lib:
	move.l	4,a6
	move.l	dos,a1
	jsr	-414(a6)		; closelib()
	rts


putchproc:
        move.b  d0,(a3)+
        rts


	even

dos:
	dc.l	0
output:
	dc.l	0
found:
	dc.l	0
found2:
	dc.l	0
found3:
	dc.l	0
handle:
	dc.l	0
lock:
	dc.l	0
longueur:
	dc.l	0
longueur2:
	dc.l	0
mem:
	dc.l	0
mem2:
	dc.l	0
file:
	dc.l	0
			
	even
	cnop	0,32

fileinfo:
	dcb.b	260,0




dos_name:
	dc.b	"dos.library",0

message:
	dc.b	10,27,"[1mCherche et remplace by GRC in 1992 v2.0"
	dc.b	27,"[0m",10,10
message_long=*-message

notice:
	dc.b	"Usage:",10
	dc.b	"C&R <Fichier à modifier> <Fichier "
	dc.b	"des équivalences> <Destination>",10,10
	dc.b	"Le fichier contenant les équivalences est sous la forme:",10
	dc.b	10,"Beau=joli",10
	dc.b	"NULL=0",10
	dc.b	10
notice_long=*-notice

no_find:
	dc.b	"Fichier non trouvé ... Essaie encore une fois !!!",10
	dc.b	10
no_find_long=*-no_find

processing:
	dc.b	"OK c'est parti ... patience ...",10
processing_long=*-processing

pas_mem:
	dc.b	10,"ERREUR:Allocation de la mémoire impossible !",10,10
pas_mem_long=*-pas_mem

alloc_file_ok:
	dc.b	10,"Allocation de la mémoire du fichier ok ...",10
alloc_file_ok_long=*-alloc_file_ok

alloc_eq_ok:
	dc.b	10,"Allocation de la mémoire du fichier "
	dc.b	"des équivalences ok ...",10
alloc_eq_ok_long=*-alloc_eq_ok

lecture_file:
	dc.b	10,"Lecture du fichier ok ...",10
lecture_file_long=*-lecture_file

lecture_eq:
	dc.b	10,"Lecture du fichier des équivalences ok ...",10
lecture_eq_long=*-lecture_eq

ecrit_file:
	dc.b	10,"Ecriture du fichier destination ... patience ...",10,10
	dc.b	"( 00000000 )  caractères écrit ...",13
ecrit_file_long=*-ecrit_file

fin_trait:
	dc.b	10,10,"Fin du process atteint !!! (C'est fini)",10,10
fin_trait_long=*-fin_trait

CR:
	dc.b	$9b,$4d,13

process:
	dc.b	10,"Construction de la table des échanges ...",10,10
process_long=*-process	

percentraw:
	dc.b	"( %08ld",0
percent:
	dc.b	"( NNNNNNNN ",13,0
percent_long=*-percent


	
	even

	section	tableaux,bss


ratio:
	ds.l	1
ratioprint:
	ds.l	1
table:
	ds.b	1000*4*2
fintable:


*END SOURCE*