Obligement - L'Amiga au maximum

Vendredi 21 juillet 2017 - 08:43  

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 : Amiga E - structure d'une source
(Article écrit par Yann Armand et extrait d'Amiga News - juin 1995)


A l'instar des autres langages procéduraux, comme le Pascal ou le C, le E possède une structure de source en quatre parties :

1)
MODULE <path/module>, .....

2)
DEF <variable>:<type>, ......

3)
PROC main()
    DEF <variable locale>
    ...
    <corps du programme>
    ...
ENDPROC

4)
PROC <nom de procédure>(<variables>:<type>)
    DEF <variable locale>
    ...
    <corps de la procédure>
    ...
ENDPROC

Examinons chacune de ces parties :

1) Appel des MODULES, grâce auxquels, entre autres, nous aurons accès aux fonctions et variables des bibliothèques du système. Une particularité du compilateur E est que les fonctions des bibliothèques exec, intuition, dos et graphics, sont directement accessibles sans que nous ayons à appeler leurs modules.

2) DEFinition des variables globales, accessibles par n'importe quelle procédure. Nous pouvons en préciser le type, c'est-à-dire ce qu'elle représente : INT pour les entiers, CHAR pour les caractères, LONG pour les mots long, STRING pour les chaînes de caractères -qui sont en fait des ARRAY OF CHAR-, OBJECT pour les structures et PTR pour les pointeurs qui peuvent leur être associés comme nous le verrons plus loin.

3) La procédure main(), en fait la procédure maîtresse de notre programme, qui sera exécutée en premier.

4) La déclaration des procédures annexes utilisées par la procédure main() soit de façon répétitive, soit pour faciliter la lecture de la procédure main().

Les procédures

Nous auront souvent à créer nos propres fonctions, auxquelles nous passerons des arguments et qui nous renverrons un ou plusieurs résultats.

Les procédures peuvent agir sur les variables globales définies en début de sources, mais aussi sur toutes les variables dites locales, qui sont déclarées à l'intérieur même de la procédure.

Les arguments d'une procédure sont aussi des variables locales. Celles-ci sont exclusivement attachées à la procédure et elle seule peut y accéder. La seule façon de faire sortir d'une procédure la valeur d'une variable locale est de la renvoyer en résultat.

Prenons un exemple. Réécrivons de deux façons différentes la procédure STRLEN() qui renvoie la longueur d'une chaîne de caractères :

Dans les deux cas nous utilisons l'argument chaine -un pointeur sur une chaîne de caractères- et nous définissons une variable locale i qui va compter les caractères. La fin de la chaîne sera détectée par la présence d'un caractère nul.

Dans le premier cas, tant que le caractère observé n'est pas nul nous incrémentons i. Une fois trouvé ce caractère, nous finissons la procédure par ENDPROC i, qui renvoie la valeur de i.

Dans le second cas, nous créons une boucle infinie qui teste le caractère courant et qui incrémente i. Lors du test, si la valeur du caractère est 0, alors on sort de la procédure sans la finir par RETURN i, qui renvoie lui aussi la valeur de i.

Nous découvrons ici un des points forts des procédures : nous n'avons pas à nous soucier de la façon de traiter le problème tant qu'on connaît l'utilisation. En effet, si nous écrivons :

longueur:=strlen('bonjour')

Dans les deux cas longueur recevra 7.

Pour en finir avec les arguments, il faut savoir qu'ils peuvent recevoir une valeur par défaut. Ainsi, lors d'un appel à la procédure, si l'argument n'est pas précisé, il reçoit sa valeur par défaut. Ces arguments doivent néanmoins être déclarés en dernier :

PROC toto(a,b=0,c=3)

Un appel toto(2,5) sera équivalent à toto(2,5,3).
Une déclaration PROC toto(a,b=1,c) est illégale.

Une particularité des procédures en E est de pouvoir retourner plusieurs valeurs (3 au maximum). Rien n'est plus simple, il suffit d'enchaîner les variables de résultats avec :

ENDPROC a,b ou RETURN a,b,c

L'appel à de telles procédures se fera ainsi :

a,b:=toto(i)

"a" reçoit la première valeur de retour et "b" la seconde. S'il en existe une troisième, elle est ignorée.

Dans les traitements imbriqués comme :

a:=cos(toto(5,3))

"a" recevra le cosinus de la première valeur de retour de toto(5,3).

Les Objets

Examinons maintenant un élément primordial du langage pour la programmation du système, j'ai nommé les Objets. Ces derniers sont assimilables aux Structures du C ou aux Records du Pascal.

Un objet rassemble plusieurs variables -elles peuvent être de types différents-, que l'on regroupe sous un seul nom pour les manipuler facilement.

Par exemple :

OBJECT cd
    nom[50]:STRING      /*nom du CD*/
    durée:INT           /*durée en min*/
    plages:INT          /*nb de plages*/
    positin:INT         /*position de rangement*/
    ENDOBJECT

Nous avons créé un nouveau type cd, il ne nous reste plus qu'à l'affecter à une variable :

DEF metallica:cd

"metallica" est une variable de type cd. Nous pouvons lui assigner des valeurs...

  -globalement:
    metallica:=['Master of puppets',
                        54,8,38]:cd

  - individuellement:
    metallica.nom:='Master of puppets'
    metallica.plages:=8

On lit les variables de l'objet de la même façon :

    IF metallica.durée<60 THEN 
                WriteF('ce cd rentre sur
                une cassette')
    title:=metallica.nom

Le système pullule d'objets, par exemple un écran sera décrit par un OBJECT screen, une fenêtre par un OBJECT window et bien d'autres encore... Pour y accéder nous utilisons des pointeurs (PTR) qui sont en fait des LONG dans lesquels sont stockées des adresses. Définissons hetfield un pointeur sur un objet de type cd :

    DEF hetfield:PTR TO cd

Assignons lui une valeur :

    hetfield:=metallica

Et nous l'utilisons comme un objet :

    title:=hetfield.nom

Nous obtenons "Master of puppets" dans la variable title.

L'exemple

Voici pour finir un petit programme donnant la liste des écrans ouverts, qui résume ce que nous venons de voir. L'algorithme est simple : on trouve le premier écran (intbase.firstscreen), tant que le pointeur scr n'est pas nul, on écrit son nom et on cherche le suivant.

Pour finir

Pour mieux comprendre, jetez un oeil au module "intuition:screen.m" grâce à bin/ShowModule. Et pour ne pas rester inactif, dévorez les articles sur le C et l'assembleur, traitant du système dans les précédents numéros. Vous trouverez des mines d'informations sur les OBJECTS (structures) du système.

    /* 1ere version */
    PROC strlen(chaine)
        DEF i=0
        WHILE chaine[i]<>0
              i:=i+1
        ENDWHILE
    ENDPROC i


    /* 2nde version */
    PROC strlen(chaine)
        DEF i=0
        LOOP
        IF chaine[i]=0 THEN RETURN i
                i:=i+1
        ENDLOOP
    ENDPROC


    /* exemple donnant la liste des */
    /* ecrans ouverts */

    MODULE 'intuition/intuitionbase'
    MODULE 'intuition/screens'

    DEF scr:PTR TO screen
    DEF intbase:PTR TO intuitionbase

    PROC main()
        intbase:=intuitionbase
        scr:=intbase.firstscreen
        WHILE scr<>0
            WriteF('\s\n',scr.title)
            scr:=findnextscreen(scr)
        ENDWHILE
    ENDPROC

    PROC findnextscreen(sc:PTR TO screen)
        sc:=sc.nextscreen
    ENDPROC sc


[Retour en haut] / [Retour aux articles] [Article suivant]