Obligement - L'Amiga au maximum

Mercredi 13 décembre 2017 - 21: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

 


Test d'Amiga E
(Article écrit par Lionel Vintenat et extrait d'Amiga News - avril 1995)


L'Amiga ne manque pas de langages de programmation à découvrir. On y trouve aussi bien les "classiques" comme le C, le Prolog, le Lisp, le Fortran, etc., que des langages spécifiques comme AMOS, ACE, Blitz Basic, etc., voire des "exotiques" comme False et BrainFuck (à essayer absolument si vous êtes un fana de langages). Parmi ceux qui sont propres à notre machine, il en est un qui arrive maintenant à maturité : l'Amiga E.

Présentation

Amiga E est un langage développé par Wouter van Oortmerssen (qui n'en est pas à son coup d'essai) et est placé dans le domaine du "librement distribuable", par opposition à commercial. Plus précisément, les versions 3.x sont sharewares (il vous en coûtera 200 FF pour vous enregistrer), et les versions précédentes (je n'en connais personnellement qu'une seule : la 2.1b) sont freeware. Vous pouvez vous les procurer toutes les deux sur les disquettes CAM, et bien sûr sur un miroir Aminet (dans dev/e) pour ceux qui ont le bonheur d'être connectés à Internet. Les distributions v3.x contiennent une version de démonstration du compilateur, shareware oblige, qui refuse de produire des exécutables de plus de 8 ko. C'est largement suffisant pour découvrir le langage, mais pour développer sérieusement, il faudra toucher à votre porte-monnaie !

Le langage lui-même a une vocation généraliste, c'est-à-dire que vous pouvez virtuellement programmer ce que vous voulez avec (démos, utilitaires, jeux, etc.). Cependant, de l'aveu même de l'auteur, il s'adapte particulièrement bien à la programmation du système d'exploitation, et tous les utilisateurs d'Amiga E que je connais l'emploient à cette fin. Il se retrouve donc directement en concurrence avec le langage C et l'assembleur, combat difficile car ces deux adversaires règnent déjà en maîtres dans ce domaine. Mais notre rival a des atouts dans son sac que nous verrons par la suite. Commençons d'abord par un rapide retour en arrière...

Historique

L'histoire d'Amiga E peut se diviser en deux grandes périodes : l'avant et l'après version 3. La dernière distribution survivante de l'avant version 3 est la v2.1b.

Celle-ci posait les bases du langage, et on y trouvait déjà des caractéristiques très alléchantes qui lui avaient valu l'adhésion d'un public restreint mais dynamique ! Cependant, cette version souffrait de certaines limitations qui l'empêchaient de prétendre au titre de langage sérieux. Aujourd'hui, elle est devenue complètement obsolète, et il n'y a plus de raison (sinon financière) de l'utiliser encore.

Le tournant dans l'évolution du langage a été la sortie l'été dernier de la version 3. Celle-ci a mis fin à la plupart des limitations, et surtout, a apporté beaucoup de nouveaux concepts et de nouvelles caractéristiques. La transition s'est faite avec quelques balbutiements puisque la toute première version de cette nouvelle ère, la 3.0a, comportait quelques bogues vraiment gênants. Deux correctifs sont venus arranger tout ça, et depuis novembre, nous disposons d'Amiga E v3.0e qui ne comporte plus de bogues importants connus (pour l'instant :-)). Procurez-vous donc au moins cette version pour profiter pleinement du langage, le mieux étant bien sûr de récupérer la dernière en date, à savoir la 3.1a qui apporte encore de nouvelles possibilités, mais rien d'aussi fondamental que le passage à la version 3.

Caractéristiques

Rentrons maintenant dans le coeur du langage. La première chose qui frappe avec Amiga E est la "légèreté" de l'ensemble. Le compilateur fait moins de 90 ko et a besoin d'un Mo de mémoire pour tourner confortablement. Il faut bien sûr rajouter à cela les modules (équivalents E des includes du C et de l'assembleur) du système, mais l'ensemble est tout à fait viable sur un Amiga sans disque dur et avec seulement un Mo de mémoire. De plus, la vitesse de compilation est exceptionnellement rapide : comptez plus de 20 000 lignes compilées par minute sur un Amiga 7 MHz (dixit la documentation). Rajoutez à cela qu'Amiga E fonctionne avec le Kickstart 1.3 et vous aurez compris qu'il peut être utilisé sur n'importe quel Amiga (enfin peut-être pas un Amiga 1000 de base :-)).

La syntaxe du langage obéit à des règles rigoureuses (mots-clés en majuscules, etc.) qui sont parfois contraignantes mais qui assurent une certaine "uniformité" des sources. Pour peu qu'on prenne la peine d'indenter correctement.

L'ensemble est très lisible car toutes les structures des programmes sont clairement encadrées par des paires distinctes :

 (PROC/ENDPROC,
 FOR/ENDFOR,
 WHILE/ENDWHILE, etc.).

On trouve bien sûr dans Amiga E tous les éléments d'un langage évolué : les structures de contrôle classiques (boucles for, while et repeat, instructions if-then-else et select, etc.), les chaînes de caractères (formatées ou non) et les réels, les tableaux, les macros (à partir de la version 3.1a), les fonctions, etc. Ces dernières sont particulièrement puissantes car elles peuvent être récursives, avoir des arguments par défaut, et même retourner plusieurs valeurs !

Il est possible de faire de la compilation séparée en divisant son programme en modules. Les variables et les procédures d'un module peuvent soit rester privées au module, soit être exportées pour être utilisées dans d'autres modules.

Un des éléments essentiels d'Amiga E est son système de typage. En effet, il ne connaît qu'un seul type : les mots longs de 32 bits ! Rassurez-vous, ceci est un raccourci, Amiga E fait quand même des distinctions un peu plus fines. Mais le principe de base est de traiter tout type de manière interne comme un mot long. Cette façon de procéder pourra en choquer plus d'un. Il est évident que la quasi-absence d'un contrôle de type laissera passer des erreurs à la compilation.

Mais d'un autre côté, ce système est d'une grande "souplesse" : les fonctions deviennent en quelque sorte "naturellement génériques" (elles retournent toutes le même type !), il est facile d'échanger et de mélanger les données, et de nombreuses vérifications superflues sont évitées (qui n'a pas été énervé par un message du type "pointers don't point the same type" ?). Dans le langage E, deux types de données (vous voyez qu'il y en a plusieurs :-)) font l'objet d'un soin particulier : les chaînes de caractères et les listes.

En effet, à côté des chaînes de caractères classiques terminées par un octet nul, Amiga E propose les chaînes E. Elles aussi se terminent par un octet nul, mais elles possèdent des informations supplémentaires qui sont la taille maximale et un "pointeur de chaînage". En pratique, cela signifie que vous pouvez manipuler les chaînes E (avec des fonctions dédiées) sans jamais vous soucier de déborder hors de leur emplacement en mémoire, et que vous pouvez construire très facilement des listes de chaînes E (toujours avec des fonctions dédiées). Ces informations supplémentaires étant stockées dans des "offsets" négatifs par rapport au pointeur sur la chaîne, vous pouvez utiliser les chaînes E à la place des chaînes classiques sans aucun problème.

Les listes E, vous l'aurez compris, sont aux tableaux de mots longs, ce que les chaînes E sont aux tableaux de caractères.

Une caractéristique très pratique d'Amiga E est la génération d'exceptions, un peu comme le fait ADA. En quelques mots, vous pouvez ajouter à chaque fonction un "handler" (gestionnaire) d'exception, qui n'est rien d'autre qu'un bout de code supplémentaire. Quand une exception est levée (au moyen d'une instruction spéciale) dans une fonction, l'exécution est détournée vers le handler d'exception associé. Si celui-ci n'existe pas, tous les appels de fonction sont remontés jusqu'à en trouver une qui comporte un tel handler (si aucun handler n'est trouvé, le programme s'arrête). Plus fort encore, vous pouvez demander au langage de lever automatiquement une exception quand, par exemple, la fonction OpenLibrary() retourne 0 (signe d'un échec) ! Plus besoin de le tester vous-même pour chaque appel. Cela devient alors un vrai plaisir de traiter les cas d'erreur, un seul handler central suffisant en général pour l'ensemble.

Amiga E possède directement, intégrées au compilateur, de nombreuses fonctions pour faciliter la vie du programmeur. Certaines servent à la manipulation des chaînes (chaînes E ou chaînes classiques) et des listes, et d'autres permettent un accès simplifié et élémentaire à certaines parties du système (gestion des fichiers, graphisme, etc.), sans que vous ayez justement besoin de connaître ces aspects du système. Parmi ces dernières, signalons les puissantes fonctions d'allocation de mémoire. En utilisant celles-ci plutôt que celles du système, la mémoire allouée sera rendue à la fin du programme sans que vous ayez à vous en préoccuper, et une exception pourra être automatiquement levée si une allocation est impossible. Pour simplifier encore, toutes les fonctions des bibliothèques exec, dos, intuition et graphics sont directement comprises par le compilateur sans déclaration préalable.

Un des aspects les plus séduisants d'Amiga E est son assembleur intégré. En effet, celui-ci est complètement assimilé au langage lui-même. En pratique, cela signifie que vous pouvez mélanger à tout moment des instructions assembleur avec des instructions "normales". L'assembleur devient donc un sous-ensemble du langage E. Mais cela va plus loin : vous pouvez parfaitement écrire des choses comme MOVE.B a,b (où a et b sont des variables). Le compilateur remplacera les noms a et b dans le code généré par les registres ou les emplacements mémoire correspondants à ces variables ! Il est difficile de faire plus pratique pour optimiser des bouts de code.

Depuis la version 3, Amiga E est orienté objet. La programmation orientée objet est une "autre façon de concevoir" ses programmes, qui possède d'énormes avantages (et bien sûr quelques défauts) par rapport à la programmation classique à flux de contrôle. Dans ce domaine, Amiga E propose tout ce qu'on peut en attendre : objets avec attributs (publiques ou privés) et méthodes, héritage des attributs et des méthodes, polymorphisme et généricité "naturelle" (voir précédemment).

On trouve aussi dans Amiga E des choses plus "ésotériques" empruntées à d'autres langages comme les cellules et les expressions "quotées" du Lisp, et l'unification du Prolog. Ces éléments du langage n'ont sans doute pas d'utilité pour le programmeur débutant, mais peuvent se révéler fort utiles pour des besoins ponctuels, et de toutes façons, abondance ne nuit pas !

Enfin, rien n'est jamais parfait dans ce bas monde, et Amiga E n'échappe pas à cette règle. On peut lui reprocher de ne générer que du code 68000 (pour les réels, il utilise les bibliothèques IEEE de l'Amiga, donc un coprocesseur mathématique est automatiquement utilisé si présent), que ce code ne soit pas vraiment optimisé (Amiga E sort un code très compact et peut affecter des variables à des registres, mais rien d'aussi puissant que les optimiseurs de SAS/C ou GCC n'est encore implémenté), de ne pas avoir de priorités pour les expressions (celles-ci sont évaluées de gauche à droite), de ne gérer que les tableaux à une dimension (il faut créer un objet spécifique pour contourner cette limitation) et de pas permettre d'héritage multiple (un objet ne peut avoir qu'un seul père).

Il faut noter que les deux dernières limitations sont dues à l'absence de vrai typage, et donc il y a peu d'espoir de voir évoluer la situation. Par contre, les premières peuvent être considérées comme temporaires.

Conclusion

Comme je l'ai dit au début, Amiga E se place sur le terrain difficile de la programmation système, face au langage C et à l'assembleur. Il possède cependant des atouts de poids.

Sa taille très modeste et sa rapidité de compilation en font le langage idéal pour les petites configurations, voire l'unique langage orienté objet qui leur soit accessible. La possibilité d'intégrer de manière transparente de l'assembleur aux sources ne manquera pas de séduire les puristes du binaire. Enfin, pour l'amigaïste programmeur qui veut se faire plaisir avec sa machine, Amiga E est une solution à considérer : pour une somme modique, vous avez un langage orienté objet très puissant.

Seul GCC vous en propose plus pour moins cher, mais ce n'est pas la même échelle, ni pour les besoins en mémoire, ni pour l'encombrement du disque ! Enfin, une communauté dynamique s'est constituée autour de ce langage, et on trouve maintenant beaucoup de sources d'exemple, des utilitaires annexes, des passerelles vers MUI, Triton et BGUI, des documentations, etc.

Pour résumer, je conseillerai à tous ceux que la programmation système intéresse, et qui n'ont pas encore définitivement fixé leur choix quant à leur langage de prédilection, d'essayer Amiga E. Il constitue une alternative au rapport qualité-prix plus qu'intéressante.

Nom : Amiga E.
Développeur : Wouter van Oortmerssen.
Genre : langage de programmation.
Date : 1994.
Configuration minimale : Amiga OCS, 68000, AmigaOS 1.3.
Licence : shareware.
Prix : environ 200 FF.
Téléchargement : Aminet.


[Retour en haut] / [Retour aux articles]