Obligement - L'Amiga au maximum

Dimanche 24 septembre 2017 - 12:37  

Translate

En De Nl Nl
Es Pt It Nl


Rubriques

 · Accueil
 · A Propos
 · Articles
 · Galeries
 · Glossaire
 · Hit Parade
 · Liens
 · Liste jeux Amiga
 · Quizz
 · Téléchargements
 · Trucs et astuces


Articles

 · Actualité (récente)
 · Actualité (archive)
 · Comparatifs
 · Dossiers
 · Entrevues
 · Matériel (tests)
 · Matériel (bidouilles)
 · Points de vue
 · En pratique
 · Programmation
 · Reportages
 · Tests de jeux
 · Tests de logiciels
 · Tests de compilations
 · Articles divers

 · Articles in english
 · Articles in other languages


Twitter

Suivez-nous sur Twitter




Liens

 · Sites de téléchargements
 · Associations
 · Pages Personnelles
 · Moteurs de recherche
 · Pages de liens
 · Constructeurs matériels
 · Matériel
 · Autres sites de matériel
 · Réparateurs
 · Revendeurs
 · Presse et médias
 · Programmation
 · Développeurs logiciels
 · Logiciels
 · Développeurs de jeux
 · Jeux
 · Autres sites de jeux
 · Scène démo
 · Divers
 · Informatique générale


Jeux Amiga

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


Trucs et astuces

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


Glossaire

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


Partenaires

Annuaire Amiga

Amedia Computer

Relec

Hit Parade


Contact

David Brunet

Courriel

 


Programmation : Introduction et premiers exemples en ARexx
(Article inspiré du manuel d'AmigaOS 3.9 - février 2004)


ARexx est l'équivalent Amiga du langage de programmation REXX créé par IBM. Il vous fournit la liberté de configurer sur-mesure votre environnement de travail. Il est particulièrement utile en tant que langage de script car il vous permet de contrôler et modifier des applications et de maîtriser la façon dont elles intéragissent entre elles.

Cet article d'introduction vous initiera à ARexx, et vous proposera la création de vos premiers exemples ARexx.

Introduction à l'ARexx

Le langage de programmation ARexx (Amiga REXX) peut être considéré comme un noeud de communications dans lequel les applications - même celles créées par des développeurs différentes - peuvent échanger des données et commandes. Par exemple, en utilisant ARexx, vous pouvez ordonner à un produit de télécommunication de se connecter à un tableau d'affichage électronique, d'y télécharger des données financières, puis de les transférer automatiquement à un tableur pour des analyses statistiques - et ceci sans intervention de l'utilisateur.

ARexx est un langage interprété qui traite des fichiers ASCII. L'interpréteur ARexx est le programme RexxMast, situé dans le répertoire "System" du Workbench sous AmigaOS et dans "MOSSYS:C" sous MorphOS. RexxMast gère l'exécution d'un programme ARexx. Si RexxMast détecte une erreur pendant la traduction ou l'exécution d'une ligne, il s'arrête et affiche un message d'erreur à l'écran. Ce test interactif est la fois un outil d'apprentissage et une aide au débogage de programmes parce qu'il précise où et quand une erreur se produit.

A qui est destiné ARexx ?

Vous n'avez pas besoin d'une expérience intensive de l'Amiga pour utiliser les programmes et scripts ARexx, mais vous devez tout de même savoir comment :
  • Ouvrir un Shell et saisir des commandes AmigaDOS.
  • Utiliser un éditeur de texte, comme ED, MEmacs, CygnusED ou GoldED.
  • Créer un fichier "user-startup".
Cependant, pour créer ou modifier des scripts ARexx, vous devrez avoir assimilé les principes de base des environnements Workbench et AmigaDOS. Les utilisateurs expérimentés de l'Amiga peuvent trouver l'ARexx plus facile et plus puissant que l'AmigaDOS. En effet, ARexx peut être utilisé pour améliorer ou remplacer les commandes AmigaDOS et les scripts, mais aussi créer des applications intégrées.

ARexx sur Amiga

ARexx est géré sur toutes les plates-formes matérielles Amiga. ARexx a été intégré dans le système d'exploitation Amiga depuis la version 2.0 du Workbench Amiga. ARexx utilise plus particulièrement deux caractéristiques primordiales du système d'exploitation Amiga : le multitâche et la communication interprocessus.

Le multitâche est la faculté à exécuter plus d'un programme simultanément. Par exemple, vous pouvez éditer un fichier, formater une disquette et modifier les couleurs de votre écran en même temps.

La communication entre processus (IPC) est réalisée via l'utilisation de ports de messages (liés à des programmes), une adresse contenue dans une application qui peut recevoir et envoyer des messages. Chaque port de message a un nom et l'envoi d'un message vers une application dans un script ARexx nécessite l'utilisation d'un nom de port.

Le protocole d'envoi/réception d'un message est :
  1. Une application ouvre son port de message à son initialisation.
  2. L'application se met en attente d'un message.
  3. Le système d'exploitation de l'Amiga notifie à l'application qu'un message est arrivé sur son port.
  4. L'application va lire ce message.
  5. L'application notifie à l'expéditeur du message (ARexx) que le message a été reçu et traité. Cet échange de message n'est pas limité à une application et ARexx. Plusieurs applications peuvent envoyer et recevoir des messages en utilisant ARexx comme noeud de communications. Cependant, toutes les applications doivent être compatibles ARexx.
Caractéristiques d'ARexx

Les caractéristiques du langage de programmation ARexx sont :
  • Données non typées - Une donnée est traitée comme une chaîne de caractères et les variables ne sont pas déclarées.
  • Exécution Interprétée - La faculté de l'ARexx à lire et exécuter évite la phase supplémentaire de compilation du programme.
  • Gestion automatique de ressources - L'allocation automatique interne de mémoire supprime les chaînes et données devenues inutiles.
  • Trace, capture, et débogage - La trace et la capture permettent la gestion des erreurs qui normalement interrompraient le programme. Les fonctions de débogage vous permettent de voir le source complet de votre programme, réduisant le temps de développement et de test.
  • Bibliothèques de fonctions - Des bibliothèques de fonctions externes fournissent des fonctions avancées et préprogrammées.
ARexx dans le Workbench

Les programmes ARexx sont habituellement stockés dans le répertoire "REXX:" (qui est souvent assigné au répertoire "SYS:S"). Bien que les programmes puissent être stockés dans n'importe quel répertoire, les placer dans "REXX:" présente plusieurs avantages :
  • Vous pouvez exécuter les programmes sans avoir à saisir leurs chemins d'accès complets.
  • Tous les programmes ARexx sont placés au même endroit.
  • La plupart des applications cherchent les programmes ARexx dans "REXX:".
Comme vous pouvez placer un programme ARexx n'importe où, vous pouvez également le nommer à votre convenance. Cependant, adopter une simple nomenclature rendra la gestion des programmes plus facile. Les programmes exécutés à partir du Shell doivent avoir l'extension ".rexx" pour les distinguer des fichiers lancés par d'autres applications.

Démarrer ARexx

Pour commencer à utiliser ARexx, vous devez exécuter le programme RexxMast. Celui-ci peut être lancé automatiquement ou manuellement. Chaque fois qu'ARexx est démarré ou arrêté, une fenêtre d'information apparaît.

Pour démarrer ARexx manuellement, double-cliquez sur l'icône "RexxMast" du répertoire "System" du Workbench. Sous MorphOS, ouvrez un Shell et tapez : "rexxmast >NIL:".

Il y a deux méthodes pour démarrer ARexx automatiquement : placez l'icône de RexxMast dans le répertoire "WBStartup" ou éditez le fichier "S:user-startup".

Pour placer RexxMast dans le répertoire "WBStartup", ouvrez le répertoire "System" et faites glisser l'icône "RexxMast" dans le répertoire "WBStartup", puis redémarrez votre Amiga.

Pour éditer le fichier "S:user-startup" il suffit de :
  • Ouvrir un éditeur de texte.
  • Ouvrir le fichier "S:user-startup".
  • Saisir "REXXMAST >NIL:".
  • Sauvegarder le fichier.
  • Redémarrez la machine.
Exécuter des programmes ARexx

La commande RX est utilisée pour exécuter un programme ARexx. Si un chemin d'accès complet précède le nom du programme, ce dernier est seulement recherché dans le répertoire mentionné. Si aucun chemin d'accès n'est mentionné, le programme est recherché dans le répertoire courant et dans "REXX:".

Tant que les programmes sont stockés dans le répertoire "REXX:", vous n'aurez pas besoin de mentionner l'extension ".rexx" dans le nom du programme. Autrement dit, saisir :

RX Program.rexx

est équivalent à :

RX Program

Un petit programme peut directement être saisi sur une ligne de commande en encadrant la ligne du programme par des guillemets. Par exemple, le programme suivant enverra cinq fichiers nommés myfile.1, ..., myfile.5 vers l'imprimante.

RX "DO i=1 to 5;
ADDRESS command `copy myfile.' | | i `prt:'; END"

Quand une application est compatible ARexx, vous pouvez exécuter les programmes ARexx à partir des applications en sélectionnant une option de menu ou en spécifiant une option de commande. Référez-vous à la documentation du logiciel pour des informations supplémentaires.

Les programmes ARexx peuvent être exécutés à partir du Workbench en leur créant une icône "projet" ou "outil". Vous devez donc préciser la commande RX comme outil par défaut de votre icône. Dans la fenêtre d'information de l'icône, saisissez : "Default Tool: SYS:Rexxc/RX".

Lorsque l'icône est activée, RX lance RexxMast (si celui-ci n'est pas déjà actif). Il exécute le fichier associé à l'icône comme un programme ARexx.

ARexx gère deux types d'outils : "Console", qui spécifie une fenêtre et "CMD", qui indique une commande. Vous saisissez ces types d'outils dans la fenêtre d'information de l'icône de la façon suivante :

Console=CON:0/0/640/200/Example/Close
CMD=rexxprogram

Exemples de programmes

Les exemples suivants illustrent la façon d'utiliser ARexx pour afficher des chaînes de caractères sur votre écran, effectuer des calculs et activer les fonctionnalités de vérification d'erreur.

Les programmes peuvent être saisis dans n'importe quel éditeur de texte ou traitement de texte. Sauvegardez vos programmes commes des fichiers "texte" au format ASCII si vous utilisez un traitement de texte. ARexx gère la table de caractères ASCII étendue (Å, Æ, ß). Ces caractères étendus sont interprétés comme des caractères ordinaires et seront passés de minuscules en majuscules.

Les exemples illustrent également l'utilisation des bases de la syntaxe ARexx comme :
  • Les lignes de commentaire.
  • Les règles d'espacement.
  • La prise en charge de la casse.
  • L'utilisation d'apostrophes et de guillemets.
Chaque programme ARexx est constitué d'une ligne de commentaire qui décrit le programme, et d'une instruction qui affiche le texte à l'écran. Les programmes ARexx doivent toujours commencer par une ligne de commentaire. Les /* (slash, astérisque) au début de la ligne et les */ (astérisque, slash) à la fin indiquent à l'interpréteur RexxMast qu'il a affaire à un programme ARexx. Sans les /* et */, RexxMast ne reconnaîtra pas le fichier comme un programme ARexx. Une fois qu'il a commencé à exécuter le programme, ARexx ignore tous les autres commentaires du fichier. Cependant, les lignes de commentaire sont très utiles pour améliorer la lisibilité du programme. Ils peuvent aider à la structure et à la compréhension du programme.

Exemple 1 : Amiga.rexx

Ce programme vous montre comment utiliser SAY dans un bloc d'instructions pour afficher des chaînes de caractères à l'écran. Les instructions sont des clauses du langage qui indiquent une certaine action à effectuer. Celles-ci commencent toujours par un mot-clé. Dans l'exemple suivant, le mot-clé est SAY (les mots-clé sont toujours passés en majuscules lors de l'exécution du programme). Le SAY suivant est un exemple de chaîne. Une chaîne est une suite de caractères délimitée par des apostrophes (`) ou des guillemets (").

/*Un programme tout simple*/
SAY `Amiga. The Computer For the Creative Mind.'

Saisissez le programme ci-dessus et sauvegardez-le en "REXX:Amiga.rexx". Pour lancer ce programme, ouvrez une fenêtre "Shell" et saisissez :

RX Amiga

Bien que le chemin d'accès complet et le nom du programme soient "Rexx:Amiga.rexx", vous n'avez pas besoin de saisir le nom du répertoire "REXX:" ou l'extension ".rexx" si le programme a été sauvegardé dans le répertoire "REXX:".

Vous devrez voir le texte suivant dans votre fenêtre "Shell" : "Amiga. The Computer for the Creative Mind".

Exemple 2 : Age.rexx

Ce programme vous invite à saisir du texte et lit ce que vous avez saisi.

/*Calcule l'âge en nombre de jours*/
SAY `Entrez votre âge:'
PULL age
SAY `Vous êtes vieux de ' age*365 `jours.'

Sauvegardez ce programme en "REXX:Age.rexx" et exécutez-le avec la commande :

RX age

Le programme commence par une ligne de commentaire qui décrit ce qu'il va faire. Tous les programmes commencent par un commentaire. L'instruction SAY affiche le texte d'invite à l'écran.

L'instruction PULL lit la ligne saisie par l'utilisateur, c'est-à-dire dans ce cas, l'âge de l'utilisateur. PULL lit la saisie, la passe en majuscules et la stocke dans une variable. Les variables sont des symboles qui peuvent contenir une valeur. Choisissez des noms de variables parlants. Cet exemple utilise le nom de variable "age" pour mémoriser le nombre saisi.

La dernière ligne multiplie la variable "age" par 365 et utilise l'instruction SAY pour afficher le résultat. La variable "age" ne doit pas être déclarée comme un nombre car sa valeur a été vérifiée quand elle a été utilisée dans l'expression. c'est un exemple de donnée non typée. Pour voir ce qui peut se passer si "age" n'est pas un nombre, essayez de lancer le programme avec une saisie non numérique pour l'âge. Le message d'erreur résultant vous affiche le numéro de ligne et le type d'erreur qui est survenu.

Exemple 3 : Calc.rexx

Ce programme vous présente l'instruction DO, qui répète l'exécution de lignes d'un programme. Il illustre également l'opérateur exponentiel ( **). Saisissez ce programme et sauvegardez-le comme "REXX:Calc.rexx". Pour exécuter ce programme, utilisez la commande "RX calc".

/*Calcule des carrés et des cubes.*/
DO i = 1 to 10 /*Début de la boucle - 10 itérations*/
SAY i i**2 i**3 /*Réalise les calculs*/
END /*fin de la boucle*/
SAY `Traitement terminé.'

La commande DO répète l'exécution des lignes de commande placées entre les instructions DO et END. La variable "i" est un indice pour la boucle qui est augmenté d'1 à chaque itération. Le nombre suivant, le symbole TO est la limite pour l'instruction DO et pourrait être une variable ou une expression complexe plutôt que la simple constante 10.

Généralement, les programmes ARexx utilisent un seul espace entre les chaînes de caractères alphanumériques. Dans le programme 3, cependant, l'espacement n'est pas mentionné entre les caractères d'exponention ( **) et les variables (i et 2, i et 3).

Les lignes d'instructions à l'intérieur de la boucle ont été indentées (décalées). Ce n'est pas requis par le langage, mais cela améliore la lisibilité du programme, parce que vous pouvez facilement visualiser où la boucle commence et où elle prend fin.

Exemple 4 : Even.rexx

L'instruction IF permet à des lignes de commande d'être exécutées conditionnellement. Dans cet exemple, les nombres de 1 à 10 sont classés comme paires ou impaires en les divisant par 2 et en analysant le reste. L'opérateur arithmétique // calcule le reste après une division.

/*Paire ou impaire?*/
DO i = 1 to 10 /*Début de la boucle - 10 itérations*/
IF 1 // 2 = 0 THEN type = `even'
ELSE type = `odd'
SAY i `is' type
END /*Fin de la boucle*/

La ligne IF indique que si le reste de la division de la variable "i" par 2 est égal à 0, alors on initialise la variable "type" à paire. Sinon, le programme n'exécutera pas la clause THEN et traitera la clause ELSE, initialisant la variable "type" à impaire.

Exemple 5 : Square.rexx

Cet exemple introduit le concept de fonction, un ensemble d'instructions exécutées dans un environnement adéquat en mentionnant le nom de la fonction. Les fonctions vous permettent de créer de grands programmes complexes à paritr de modules plus petits. Les fonctions permettent aussi d'utiliser le même code pour des opérations similaires dans différents programmes.

Les fonctions sont spécifiées dans une expression, un nom suivi d'une parenthèse ouvrante (il n'y a pas d'espace entre le nom et la parenthèse). Une ou plusieurs expressions, appelées paramètres, peuvent suivre la parenthèse. Le dernier paramètre doit être suivi d'une parenthèse fermante. Ces arguments passent des informations nécessaires à la fonction pour le traitement.

DO i = 1 to 5
SAY i square (i) /*Appelle la fonction "square"*/
END
EXIT
square: /*Nom de la fonction*/
ARG x /*Lit le paramètre*/
RETURN x**2 /*Renvoie le carré du paramètre*/

Démarrant avec DO et finissant avec END, une boucle est initialisée avec un index "i", qui sera augmenté d'1. La boucle sera répétée cinq fois. Elle contient une instruction qui appelle la fonction "square" quand l'expression est évaluée. Le résultat de la fonction est affiché en utilisant l'instruction SAY.

La fonction "square", définie par les instructions ARG et RETURN , calcule le carré du paramètre. ARG charge la valeur du paramètre "i" et RETURN renvoie le résultat de la fonction à l'instruction SAY.

Une fois que le programme est appelé par la boucle, il recherche le nom de la fonction "square", charge le paramètre "i", réalise le calcul et retourne à la ligne suivante de la boucle DO/END. L'instruction EXIT arrête le programme après la dernière itération de la boucle.

Exemple 6 : Results.rexx

L'instruction TRACE active les caractéristiques de vérification d'erreur d'ARexx.

/*Illustre la trace du programme "results" */
TRACE results
sum = 0 ; sumsq = 0;
DO i = 1 to 5
sum = sum + 1
sumsq = sumsq + i**2
END
SAY `sum=' sum `sumsq=' sumsq

L'écran affiche les lignes du source exécutées, chaque passage dans la boucle DO/END, et le résultat final de l'expression. En enlevant l'instruction TRACE vous afficherez seulement le résultat final : sum = 15 sumsq = 55.

Exemple 7 : Grades.rexx

Ce programme calcule la note finale d'un étudiant donné en se basant sur quatre essais et une participation en classe. La moyenne des essais 1 et 2 compte pour 30% de l'évaluation, la moyenne des essais 3 et 4 pour 45% et la participation pour 25%.

Une fois que la note est affichée, une option permettant de continuer avec un autre calcul est affichée. La réponse est "Chargée" (PULL) : si elle est différente de Q (quitter), la boucle continue. Si la réponse est égale à Q, le programme quitte la boucle et se termine.

/*Programme de notation*/
SAY "Bonjour, Je vais calculer la note finale pour toi."
Response = 0
DO while response ~ = "Q "/*On boucle tant que la réponse n'est pas Q*/
SAY "Saisis toutes les notes de l'étudiant."
SAY "Essai 1:"
PULL es1
SAY "Essai 2:"
PULL es2
SAY "Essai 3:"
PULL es3
SAY "Essai 4:"
PULL es4
SAY "Participation:"
PULL p
Final = (((es1 + es2)/2*.3) + ((es3 + es4)/2*.45) + (p*.25))
SAY "La note finale de cet étudiant est " Final
SAY "Veux-tu recommencer? (Q pour arrêter.)"
PULL response
END
EXIT

Sources d'informations supplémentaires
  • Manuel AmigaOS 3.9 - cet article est repris et adapté du manuel AmigaOS 3.9.
  • Modern Programming Using REXX, de R.P. O'Hara et D.G. Gomberg, Prentice-Hall, 1985.
  • The REXX Language : A Practical Approach to Programming, de M.F. Cowlishaw, Prentice-Hall, 1985.
  • Programming in REXX, J. Ranade IBM Series, de Charles Daney.
  • Using ARexx on the Amiga, de Chris Zamara et Nick Sullivan, Abacus, 1991.
  • Amiga ROM Kernel Reference Manual : Libraries, Troisième Edition, Addison-Wesley, 1992.


[Retour en haut] / [Retour aux articles]