Obligement - L'Amiga au maximum

Mardi 28 mars 2017 - 12:07  

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


Soutien

N'hésitez pas à soutenir le projet Obligement



Contact

David Brunet

Courriel

 


Test d'AMOS Assembler 1.1
(Article écrit par Gilles Bihan et extrait d'Amiga News - avril 1992)


L'oeuvre colossale qui a été mise au monde par François Lionet n'a pas fini de nous étonner. Non content d'avoir programmé le langage le plus extraordinaire depuis l'invention du pastis, il a créé une dynamique propre à toutes les extensions possibles. Il ne fait pas tout, mais il a ouvert les portes à bon nombre de compléments à la programmation. Rappelons-nous les facétieuses extensions d'AMOS 3D, permettant au premier venu de faire des jeux sur trois plans, ou encore le compilateur tout en un, directement intégrable dans vos créations.

Un autre de ses enfants prodiges nous a été révélé en fouillant dans la disquette d'AMOS Compiler : AMOS Assembler.

Cette merveille, là aussi, ne manque pas d'intérêt. Elle permet, et c'est sans nul doute son unique but, d'intégrer facilement des parties de code machine dans vos programmes AMOS. Un peu mis à l'écart par le compilateur, il n'en est pas moins un outil de programmation fort puissant et utile.

DevKa and Co...

L'assembleur est, à mon avis (et je le partage), le langage le plus rapide et le plus puissant qui existe. En effet, il n'y a pas d'interprétation, on parle donc directement avec les dieux (c'est-à-dire ce vieux pochard de 68000 et ses acolytes), et les péripéties de la compilation ne viennent pas alourdir une situation déjà bien compliquée. Cependant, une grosse tare handicape la bestiole : faire un petit programme ça va, un moyen ça va encore, mais un gros, bonjour les dégâts.

Eh oui, la moindre broutille en assembleur prend vite des dimensions incommensurables, et se retrouver dans les sources devient vite un sport fatigant. De plus, les sessions de débogage font à la longue sentir leur effet neurodestructeur. L'idée a germé alors d'intégrer dans une structure plus souple créée par un langage évolué des morceaux (petits de préférence) d'assembleur, afin d'accélérer certaines parties des programmes.

Tous les langages offrent cette possibilité, mais cela n'est pas toujours des plus faciles. En effet, si les uns attestent dès le départ de facultés spéciales à bien digérer le problème (le C en général), d'autres sont plutôt sensibles à la moindre intrusion (le BASIC par exemple). Pour le C, cela s'explique très bien : le passage obligé à la compilation crée une symbiose totale. Pour le BASIC, les stress de l'interprétation provoquent parfois des surprises.

En C, l'intégration de morceaux (choisis) de code machine se fait soit à la formation des liens (par l'intégration de fichier objet liable), ou directement dans les sources C (comme le fait Aztec C avec ses #ASM et #ENDASM).

Ces processus sont d'ailleurs repris en général par tous les langages compilés, tel que le Pascal par exemple. Pour le BASIC, la seule solution est de charger le code en mémoire, et après quelques manipulations scabreuses, les appeler avec un CALL (trivial, non ?). AMOS, comme le GFA ou l'ABasic, permet ce genre de manipulation, avec cependant une petite facilité offerte : le chargement des codes dans une "bank" (banque), banque sauvée avec le programme, et qui intègre la source.

L'Amosynthèse

AMOS Assembler offre une nouvelle possibilité : intégrer dans vos programmes un véritable code assembleur. Il est capable d'assembler, de gérer, et de lancer. Le programme se présente sous la forme d'une routine compilée en mode AMOS. Cette façon de compiler donne naissance à un fichier ".AMOS" pouvant être lu et utilisé directement sous l'interpréteur d'AMOS (la même forme a été retenue pour le compilateur). Il est donc nécessaire pour l'utiliser dans les sources de fusionner le programme "AssemblerAmos".

Deux sous-programmes font alors leur apparition : _ASSEMBLER[A$,_ASM_VAR1, _ASM_VAR2,_ASM_VAR3] et _COMPILED.

Si vous essayez de déplier (unfold) les procédures, vous verrez dans la première trois choses : le placement des options dans des registres D0 à D3, un appel à l'assembleur, et une restitution en sortie du contenu de D4. Quant à _COMPILED elle est inouvrable, car c'est elle qui contient le programme AMOS Assembler compilé. Un "Set Buffer 50" se trouve au début. Il doit y rester. Si vous le déplacez, AMOS vous recrachera l'hérésie. C'est normal, c'est une fonction d'initialisation. De toute manière, il est préférable de laisser l'ensemble AMOS Assembler en début de programme.

On s'aperçoit donc avec ce petit tour d'horizon que l'extension assembleur intègre parfaitement vos programmes. Son utilisation s'apparente alors à celle d'un sous-programme de type Procedure... End Proc. L'appel va se faire tout simplement en intégrant le nom de la procédure, puis entre crochets les quatre paramètres qu'elle réclame : _ASSEMBLER[A$, départ, fin, list_on].

Vous le voyez donc, rien de très sorcier, et nous pouvons toujours et encore le dire, convivial.

L'art du Codamos

Le principe retenu est celui de l'assemblage d'une source contenue dans une variable texte vers une banque mémoire AMOS. Votre code source assembleur va donc apparaître intégralement dans votre listing BASIC. Commençons par la banque. Celle-ci va contenir le code machine proprement dit. AMOS la reconnaît comme une banque de type ASM. La confusion n'est donc pas possible, et il suffit de lancer la commande "List Bank" pour s'en persuader. Pour commencer, il faut donc réserver une banque. Celle-ci sera toujours la banque numéro 14. On la crée en insérant la commande Reserve As Work 14,512, où le dernier paramètre représente la taille (ici on a une banque de 512 octets).

Pour compléter le tableau, il faut maintenant dire à l'assembleur d'initialiser celle-ci comme sa mémoire de travail. Il faut invoquer : _ASSEMBLER["initialise label buffer",512,0,0]

On spécifie ici un ordre d'initialisation du tampon mémoire, d'une taille voulue. Seul ces deux paramètres sont demandés, et le numéro de banque n'est pas indiqué. C'est pourquoi il faut absolument réserver la banque 14. A noter ici que la procédure _ASSEMBLER peut faire diverses opérations, simplement en lui passant les ordres dans la chaîne texte. Il ne reste plus maintenant qu'à insérer la source assembleur. Celle-ci va être placée dans une variable texte. On écrit ainsi les mnémomniques : X$=X$+"move.l #10,d0;".

Les différents ordres sont séparés par un point-virgule uniquement. Les labels sont suivis d'un ":". Il ne doit pas y avoir d'espace entre chaque ligne du programme. Par exemple :

AMOS Assembler

Ce qui en assembleur conventionnel donne :

AMOS Assembler

Pas très catholique, mais cela s'intègre bien dans le paysage local. Tous les codes classiques sont reconnus, ainsi que les divers modes numériques (octal, binaire, décimal ou hexadécimal). Les pseudo-opérateurs "DC" sont possibles, mais on ne peut leur attribuer qu'une seule case mémoire (Byte, Word, Long) à la fois.

Pour faire un DC.B 'Salut' ,0; il faut utiliser une commande spécifique à AMOS Assembler : rd Salut"+chr$(0)+";", ou "rd", pour Raw Data, est le pseudo-opérateur retenu pour permettre l'entrée de données sous forme ASCII.

De même, b $3210302390 permet d'insérer des codes décimaux à la chaîne. Il n'y a pas de place pour les BLK et autres DCB. EVEN et ALIGN sont inconnus au bataillon. Ces fonctions sont remplies directement par l'assembleur, qui place les vides nécessaires pour rendre les adresses paires.

Une dernière directive offerte est "*" permettant d'insérer des commentaires, et acceptant les codes de contrôle, afin d'agrémenter vos listings. Il est possible grâce à "Def Fn" de créer des macros. Par exemple, si voulez insérer à répétition dans la source un move.l dx,a0;", une fonction du type Def Fn _INS$(a$)="move.l "+a$+",a0;" doit être mise au début du programme. Ensuite, l'insertion dans la chaîne source se fait par x$=x$+fn _INS$("d0"). Ce n'est pas un véritable langage dans le langage, mais cela rend bien des services.

Il n'est pas possible de faire une assignation du type "ExecBase equ 4". Par contre, on peut très bien insérer des variables, et grâce à _ASSEMBLER["S et var varname=expression",0,0,0] remplacer celles-ci par leur valeur. L'expression peut également faire l'objet d'une opération arithmétique. Une commande similaire existe pour les labels en la personne de _ASSEMBLER["Add label labelname=expression",1,0,0].

Une possibilité d'évaluation est offerte. Celle-ci est essentielle, car elle permet, entre autres, de délivrer l'adresse de départ exacte du programme : _ASSEMBLER["evaluate expression",0,0,0].

L'expression peut comporter une opération mathématique en y combinant des variables et des adresses de la source assembleur.

Un _ASSEMBLER["evaluate START+ $10", 0,0,0] est possible, et donnera l'adresse de départ incrémentée de 17. Pour connaître l'adresse d'appel du programme ou d'un sous-programme, il suffit de donner le label. Ainsi _ASSEMBLER["evaluate START",0,0,0] donnera en retour l'adresse de saut. Celle-ci s'obtient en consultant "Param", qui est la variable contenant la valeur de retour de la procédure Assembler. Pour lancer le programme, il suffira alors de faire un "Call Param". On peut aussi, faire un "Call start(14)".

Bit à bit...

Pour assembler proprement dit, il faut invoquer _ASSEMBLER[a$, memf, meml, list_on], où :
  • "a$" est la variable texte contenant la source.
  • "memf" l'adresse de départ de la banque 14 qui s'obtient par un 'Start(14)'.
  • "meml" l'adresse de fin de la banque qui s'obtient par un 'Start(14)+Length(14)'.
  • Et "list_on" qui active la sortie à l'écran de l'assemblage si on y place Truc (et False dans le cas contraire).
Les erreurs vous sont signalées, et AMOS vous rend la main en stoppant net la suite du programme. Que dire de plus : c'est simple, n'est-il pas ?

L'appel aux routines se fait, comme on a déjà pu le dire, par un "Call". Il peut être accompagné d'une option : en effet, on peut passer une valeur, valeur qui représentera un pointeur sur une adresse, qui pourra être récupérée en assembleur grâce à un "(a3)". Par exemple, "Call Param,Phybase(0)", donne l'adresse du premier bitmap contenu dans l'adresse mémoire A3. Les autres registres peuvent être assignés par Dreg(x) et Areg(x). A la fin de l'exécution du programme, on peut récupérer le nouveau contenu de ces registres. La possibilité est donc assez largement offerte pour établir les communications essentielles entre AMOS et le code machine.

Il est possible enfin de sauver la banque 14 avec son programme, et de l'intégrer dans d'autres logiciels, simplement en appelant celle-ci, et en lançant avec l'aide d'un "Call". AMOS Assembler n'est alors plus utile. Cette solution est d'ailleurs très pratique dans le cas d'une compilation du programme AMOS.

Effectivement, le compilateur refuse (et c'est un peu normal) de recompiler ce qui l'a déjà été (c'est-à-dire l'assembleur). Une fois la routine mise au point, exécutez une fois le programme, ensuite passez en mode direct, et entrez "Save "Bank14.abk",14". Effacez de votre source tout ce qui rappelle de près ou de loin AMOS Assembler et la commande de réservation de banque. Enfin, ajoutez un Load "Bank14.abk",14.

Évidemment, il fallait s'y attendre, tous les délires en programmation ne seront pas permis. AMOS est là, bien présent, et certaines opérations auront des conséquences irréversibles. Il faut faire très attention à ne pas empiéter sur les platebandes d'AMOS. Évitez toute manipulation hasardeuse du registre A7 ou de la "stack". J'ai pu en faire l'expérience en appelant certaines fonctions des bibliothèques, qui ont provoqué les colères mythiques du grand Guru. De plus, les programmes doivent toujours être en adressage relatif. De toute façon s'entêter à vouloir programmer à la manière Amstrad 464 n'apporte jamais rien de bon. Comme le montre le listing d'exemple, on peut s'aider des fonctions d'appel bibliothèque d'AMOS, telle que DOSCALL ou GFXCALL. C'est dangereux, le manuel ne vous le cache pas, mais cela peut aider.

L'insertion d'AMOS Assembler dans vos sources augmentera d'une façon substantielle le poids de vos listings (a peu près 56 806 octets).

AMOS Assembler
Listing d'exemple

Ce n'est pas cher, et ça rapporte gros

La documentation explicative est succincte, et les exemples rares. Mais cela suffit, car il n'y a en fait pas grand-chose de compliqué. Il est évident cependant qu'il faut déjà être initié aux méandres de la programmation assembleur.

L'auteur, Gary Symons, annonce la prochaine sortie d'un débogueur, et d'un moniteur-désassembleur. En attendant ces extensions, il faut reconnaître que pour le prix, on en a pour ses sous : AMOS Assembler est compris dans le paquetage AMOS Compiler. Le principe d'intégrer une source assembleur dans un BASIC n'est pas nouveau, car le Basic V de l'Archimedes, entre autres, interprète comme du BASIC les codes assembleurs (ouais, mais lui c'est une bête à part).

Conclusion

Il faut bien avoir à l'esprit que cela sert surtout à la programmation de certains effets ou calculs dans les programmes AMOS. Il n'est nullement question de développer des programmes entiers (même si en théorie c'est possible). Le but est bien celui que j'ai pu exprimer au début de cet article : mettre un peu de pêche dans un programme AMOS. On peut dire que c'est une réussite, car l'ensemble AMOS et assembleur est détonant. Bientôt peut-être AMOS C, permettant d'inclure du C dans l'AMOS ?

Nom : AMOS Assembler 1.1.
Développeur : Gary Symons.
Genre : logiciel de programmation.
Date : 1991.
Configuration minimale : Amiga OCS, 68000, 512 ko de mémoire.
Licence : commercial.
Prix : 295 FF (inclus dans AMOS Compiler).


[Retour en haut] / [Retour aux articles]