Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Programmation : Amiga E - programme "Cherche"
(Article écrit par Yann Armand et Pierre Girard et extrait d'Amiga News - septembre 1995)
|
|
Suite à votre courrier, il semblerait que je sois allé un peu vite dans mes explications. Ainsi, avec Pierre, mon nouvel acolyte,
nous allons reprendre point par point les sujets abordés dans le premier article, qui
nous servira de référence.
Comme promis, nous allons faire une petite incursion dans le système en programmant un petit utilitaire : "Cherche". Celui-ci va
rechercher une chaîne de caractères dans un fichier de notre choix.
Structure du programme
1) Nous déclarons les variables utilisées par le programme.
2) Traitement des arguments : Cherche sera lancé à partir du CLI, sous la forme : cherche texte fichier. Il nous faut donc récupérer
les arguments texte et fichier.
3) Lecture du fichier : nous lisons le fichier et le stockons en mémoire.
4) Recherche du texte : nous recherchons le texte dans la copie du fichier que nous avons en mémoire.
Traitement des arguments
Depuis l'arrivée des ROM 2.0, la lecture des arguments est gérée par le DOS, grâce à la fonction ReadArgs(). Comme beaucoup de
fonctions du système, elle manipule les pointeurs mémoire, monstres préhistoriques qui nécessitent un article entier pour faire
le tour de leur anatomie (pour très bientôt !). Nous passerons donc sous silence l'explication de cette partie du programme.
Lecture du fichier
Après avoir étudié les arguments, nous procédons maintenant à la lecture du fichier. Il nous faut tout d'abord connaître sa
longueur, ce qui est un jeu d'enfant avec la fonction FileLength() du E. Cette valeur est alors stockée dans le variable filelen.
Pour pouvoir utiliser le fichier, nous devons d'abord l'ouvrir, ce qui est réalisé par la fonction Open() de la dos.library. Celle-ci
requiert deux arguments : le nom du fichier et le mode d'ouverture. Celui-ci peut être soit OLDFILE, ce qui permet d'ouvrir un
fichier en lecture et en écriture, ou bien NEWFILE. Dans ce cas, un nouveau fichier est ouvert en écriture et s'il existe un
fichier du même nom, il est écrasé par le nouveau. Pour notre programme, nous utilisons donc le mode OLDFILE. La fonction Open
retourne un identificateur, ici stocké dans filehandle.
L'instruction suivante nous permet de réserver un emplacement mémoire de la longueur du fichier, à l'aide de la fonction New()
qui est interne au compilateur du E. Nous pouvons alors stocker le fichier à cet endroit grâce à la fonction Read() de la dos.library
qui a besoin comme paramètres de l'identificateur du fichier, de l'adresse de la mémoire allouée et de la longueur du fichier à
lire. A présent que les données ont été transférées en mémoire, nous pouvons refermer le fichier avec l'instruction Close().
Recherche du texte
Elle s'effectue dans une boucle de la longueur du fichier moins la longueur du texte recherché et ce, à partir du premier
caractère (ce qui correspond à la position 0). L'astuce consiste à utiliser la fonction EXIT du E qui permet de sortir d'une
boucle suivant une condition. Dans notre cas, l'arrêt de la boucle aura lieu si le texte recherché (texte) est le même que celui
qui se trouve à la position actuelle (buffer+i). Il faut à nouveau mentionner la longueur du texte recherché. La ligne qui suit
la boucle teste si on est arrivé à la fin du fichier (moins la longueur de la chaîne, bien-sûr). Si ce n'est pas le cas, cela
signifie que le texte recherché a été trouvé et un petit WriteF() affiche alors la position de celui-ci dans le fichier, à
l'octet près. Sinon, un message indique que la chaîne de caractère n'a pas été rencontrée. Enfin, comme nous travaillons
proprement, il nous faut libérer la mémoire que nous avons utiliser grâce à la fonction Dispose().
Quelques conseils
Ce n'est qu'un rappel, puisque vous avez tous lu la documentation du E. Mais souvenez-vous que les mots-clés du E doivent être
écrits en majuscule. De la même façon, les fonctions des bibliothèques ont une majuscule au début de chaque mot qui, mis ensemble,
composent le nom de la fonction comme ReadArgs (un bon point à ceux qui ont compris). Pour vous aider, essayez de
vous procurer le kit Commodore 3.1 (aux alentours de 150 FF).
Nous vous donnons rendez-vous la mois prochain. D'ici là, les petits malins peuvent s'amuser à décortiquer la fonction WriteF().
/* Recherche d'un texte dans un fichier */
PROC main()
DEF rdargs,i
DEF args:PTR TO LONG
DEF result[2]:ARRAY OF LONG
DEF texte[32]:STRING,file[32]:STRING
DEF filehandle,filelen,buffer
/* traitement des arguments */
args:=0
IF rdargs:=ReadArgs('/M/A',args,NIL)
result:=^args
StrCopy(texte,result[0],StrLen(result[0]))
StrCopy(file,result[1],StrLen(result[1]))
FreeArgs(rdargs)
ELSE
WriteF('Usage: text file')
CleanUp(0)
ENDIF
/* lecture du fichier */
filelen:=FileLength(file)
IF filehandle:=Open(file,OLDFILE)
buffer:=New(filelen)
Read(filehandle,buffer,filelen)
Close(filehandle)
ELSE
WriteF('impossible d''ouvrir le fichier sn',file)
CleanUp(0)
ENDIF
/* recherche du texte */
FOR i:=0 TO filelen-StrLen(texte)
EXIT StrCmp(texte,buffer+i,StrLen(texte))
ENDFOR
IF i<(filelen-StrLen(texte))
WriteF('"s" found at position dn',texte,i)
ELSE
WriteF('"s" not found in file : sn',texte,file)
ENDIF
Dispose(buffer)
ENDPROC
|
|