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 : ARexx - Instruction PARSE (seconde partie)
(Article écrit par François Gueugnon et extrait d'Amiga News Tech - septembre 1991)
|
|
Nous avons analysé, dans le précédent numéro, la première partie de
l'instruction PARSE, celle qui correspond à la source de la chaîne de caractères. Il nous reste à analyser la
deuxième partie de cette instruction, qui correspond au traitement de la chaîne acquise.
Imaginons que la chaîne acquise soit composée de plusieurs mots séparés par des espaces : "Ceci est la chaîne
à traiter abcdefghijklmnopqrstuvwxyz". Nous allons extraire les mots, parties ou groupes de mots, selon un
modèle (en anglais "template"). Les différentes formes d'analyse concernent uniquement la définition des séparateurs de chaîne.
Analyse par marque (token)
Dans cette forme, la partie traitement est composée de noms de variables qu'on utilisera ultérieurement au
cours du déroulement du programme. L'écriture formelle de l'analyse par marque est la suivante :
PARSE 'source' data1 data2 nom3
|
Les noms des variables sont ceux que l'on souhaite : ils sont séparés par un espace, qui est le séparateur standard.
Plusieurs cas peuvent se présenter :
1. Le nombre de variables est exactement égal au nombre de mots de la chaîne acquise. Dans ce cas, chaque mot
de la chaîne acquise est placé dans une variable, dans le même ordre. Ainsi, utilisée avec notre chaîne précédente,
l'instruction...
PARSE 'source' data1 data2 nom3 nom4 toto dimension a15
|
...placera "Ceci" dans data1, "est" dans data2, "la" dans nom3, "chaîne" dans nom4, "à" dans toto,
"traiter" dans dimension et "abcdefghijklmnopqrstuvwxyz" dans a15. Les variables utilisables sont
celles qui sont légales dans ARexx, tableaux y compris. On pourra les utiliser selon les besoins.
2. Le nombre de variables est inférieur à celui de mots de la chaîne acquise. L'affectation débute
de la même façon (un mot par variable), mais la dernière variable contient tout le reste de la chaîne, de façon
à ne pas en "perdre" un morceau au vol. Ainsi :
PARSE 'source' data1 data2 nom3
|
...placera "Ceci" dans data1, "est" dans data2 et "la chaîne à traiter abcdefghijklmnopqrstuvwxyz" dans nom3.
3. Le nombre de variables est plus grand que le nombre de mots de la chaîne acquise. L'affectation se fera
alors comme précédemment, un mot par variable, et les variables supplémentaires resteront vides. A ce propos, si
une variable n'est pas affectée, ARexx la remplace par son nom. Par exemple :
...écrira littéralement à l'écran la chaîne VariableVide. Ce n'est pas un cas d'erreur.
4. Une variable spéciale, représentée par le point "." peut être utilisée. Sa particularité est de fournir
une place dans l'instruction PARSE uniquement pour qu'elle fonctionne correctement, mais ce qui est dans le point
n'est pas récupérable. Il s'agit d'une variable jamais affectée, une espèce de filtre. Ainsi :
...sépare la chaîne acquise en deux morceaux : le premier mot dans le point, le reste dans data1,
qui reste la seule partie récupérable. La position du ou des points dans la définition est laissée à la
discrétion du programmeur.
Analyse par position
Cette forme est plutôt utilisée lorsque la chaîne acquise est monolithique, par exemple 'abcdefghijklmnopqrstuvwxyz'.
Le séparateur va être défini par un chiffre indiquant la position de coupure.
- Analyse par position absolue :
PARSE 'source' 3 data1 5 data2 10 data3
|
...met "cd" dans data1, "efghi" dans data2 et "jklmnopqrstuvwxyz" dans data3. La valeur assignée à la
variable est la sous-chaîne commençant à la position courante et allant jusqu'à, mais sans l'inclure, la
position notée.
- Analyse par position relative : dans ce cas, on indique par "+" ou "-" le décalage par rapport à la
position courante.
PARSE 'source' 3 data1 +9 data2 -6 data3
|
...met "cdefgh" dans data1, "ijklmnopqrstuvwxyz" dans data2 et "cdefghijklmnopqrstuvwxyz" dans data3.
Ces deux formes peuvent être mélangées. Cela nécessite une vue claire de ce que l'on veut, car il est rapidement
possible de "perdre les pédales" ! Petit truc : effectuez toujours mentalement la différence entre deux délimiteurs ;
des valeurs négatives ramènent au début de la chaîne source.
Analyse par figures
Dans ce mode, on décrit le séparateur par une sous-chaîne qui existe dans la chaîne acquise.
PARSE 'source' data1 'g' data2 'qrs' data3
|
...met "abcdef" dans data1, "hijklmnop" dans data2 et "tuvwxyz" dans data3. "g" et "qrs" ont été définis comme des
séparateurs et sont exclus des sous-chaînes.
Analyse multiple
Il est possible d'effectuer plusieurs analyses sur la même chaîne dans la même instruction. Attention : la
chaîne traitée reste toujours la chaîne acquise initiale ; les différents traitements ne l'altèrent pas. Le mot-clé
est WITH. La notation formelle est la suivante :
PARSE 'source' WITH analyse1, analyse2, ..., analyseN
|
...où analyse1 à analyseN représentent chacune l'une des formes d'analyse précédemment étudiées. Notons que
si une analyse par position est utilisée, il est nécessaire de donner la première position derrière le mot-clé WITH.
Nous voici arrivés à la fin des descriptions élémentaires de l'instruction PARSE. A peu près toutes les combinaisons
sont possibles entre 'source' et 'traitement' et à l'intérieur de 'traitement'. La richesse est telle qu'il n'est
pas possible de décrire tous les cas. Une expérience est parfois nécessaire.
Nous allons terminer le chapitre des éléments théoriques par les instructions d'entrée/sortie. Après quoi nous
pourrons commencer les exercices pratiques.
Lecture et écriture d'un fichier
La procédure de lecture ou d'écriture est formellement la même. Le principe en est le suivant : ARexx n'est pas en
liaison directe avec le fichier extérieur. Il faut définir une variable logique qui permettra de converser avec
l'extérieur. Cela est effectué par la fonction OPEN(). La forme générale est la suivante :
x = OPEN('varlogique', 'fichier externe', 'option')
|
- "varlogique" est une variable qui servira à interpeller le fichier externe.
- "fichier externe" est la définition du fichier extérieur comprenant éventuellement son chemin (path) complet.
- "option" peut prendre trois valeurs essentielles : "A" pour accoler (append), "R" pour lire (read),
"W" pour écrire (write).
On peut ouvrir autant de fichiers que l'on veut. Si l'on veut lire et écrire sur le même, il faut ouvrir une voie
lecture et une autre écriture... indépendamment de notions de prudence dans une telle manoeuvre.
Dans la variable x, l'on trouve le résultat de l'opération sous forme booléenne (1 si l'opération a réussi, 0 sinon).
Comme toujours, si varlogique est le nom à utiliser, il doit être placé entre apostrophes ; si
c'est le contenu de varlogique qui doit être utilisé, c'est une variable sans apostrophes.
Il en va de même pour les autres termes de l'instruction.
Enfin, un fichier ouvert doit être fermé à un moment ou à un autre. S'il est vrai que terminer le programme ferme
les fichiers encore ouverts, ce n'est toutefois pas très élégant. "Exit gracefully", suggère le livre des
recommandations aux développeurs. Pour ce faire, une instruction simple :
L'ouverture des fichiers externes peut se faire à n'importe quel moment du programme en cours, mais toutefois et
bien entendu avant leur utilisation !
On peut ouvrir pour tous les cas optionnels prévus : les fichiers en ":", "dfx:", "dhx:", "prt:", "ser:",
"par:", "con:", etc. Nous en verrons différents exemples. Lorsque le fichier requiert une définition spécifique,
par exemple CON:, celle-ci fait partie de la description, comme dans CON:100/50/320/100/MaFenêtre.
Il faut maintenant acquérir ou écrire des informations dans le fichier sélectionné. L'instruction de lecture est :
x = READCH('nomlogique', longueur)
|
Celle d'écriture :
x = WRITECH('nomlogigue', longueur)
|
Dans un cas comme dans l'autre, "longueur" indique le nombre de caractères à traiter. Pour la lecture, ce qui est
réellement lu est placé dans x et peut être plus petit que ce qui est demandé si l'on arrive en fin de fichier.
Pour l'écriture, on trouve dans x le nombre de caractères réellement écrits.
Ce sont ces deux instructions qui permettent d'avoir accès à un fichier de nature quelconque, puisque le caractère
est l'atome des fichiers en dehors de toute signification relationnelle à l'intérieur de ces fichiers.
Ces deux instructions ont une version simplificatrice lorsque le fichier analysé est organisé en lignes avec un
retour chariot en fin de ligne. C'est le cas des fichiers texte. Dans ce cas et uniquement dans ce cas, deux
instructions similaires permettent de traiter des lignes plutôt que des caractères, libérant ainsi l'utilisateur du
travail de comptage des caractères. Il s'agit de :
Et :
x = WRITELN('varlogique')
|
...avec les mêmes définitions que pour READCH() et WRITECH().
A retenir
L'instruction PARSE 'source' 'traitement' permet d'acquérir et de séparer une chaîne source en éléments
différents selon plusieurs méthodes mixables.
Les opérations d'entrées/sorties s'effectuent par l'intermédiaire d'une variable logique.
Les commandes READLN() et WRITELN() ne peuvent être utilisées que sur des fichiers organisés en lignes
(fichier texte), sinon, c'est le plantage assuré !
|
