Obligement - L'Amiga au maximum

Samedi 21 octobre 2017 - 01:06  

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 : DICE - les particularités de DICE
(Article écrit par Laurent Faillie et extrait d'Amiga News - février 1994)


Aujourd'hui, pour ceux qui ne connaissent pas encore DICE, voici un petit survol des différentes possibilités que vous ne trouverez pas sur d'autres compilateurs, ou qui ne se trouvent pas dans la version freeware...

Les options de DCC

DCC est le "front-end" du compilateur, c'est-à-dire la commande que nous allons appeler pour faire une compilation. Sa syntaxe minimale est la suivante :

Dcc source.c -o resultat

Si tout se passe bien, source.c sera compilé pour créer un exécutable nommé "resultat". Comme je l'ai dit dans le second article, DCC prend aussi ses options dans une variable nommée DCCOPTS. Évidemment, les options de la ligne de commande ont priorité sur celles contenues dans la variable. Comme son cousin cc d'Unix, DCC a beaucoup d'options, mais voici la liste de celles qui sont les plus intéressantes :
  • Changement de version de système : il arrive souvent aux développeurs de devoir jongler avec différentes versions du système d'exploitation. Avec DICE, il est très facile de changer grâce aux options -1.3, -2.0, -2.1, -3.0, -3.1... Lorsque par exemple, nous mettons l'option -2.0, DICE cherchent les versions 2.0 des distributions, nommées Amiga20x.lib (le "x" est remplacé par une ou plusieurs lettres suivant le code utilisé -Small ou Large-, l'utilisation des registres et le profilage), les includes seront dans Dinclude:Amiga20/.

  • Pour les utilisateurs du 1.3, l'option -f permet de mettre résidents les autres composants du compilateur (Dc1, Das, Dlink).

  • -c et -a permettent de ne générer respectivement que les codes objets (.o) ou assembleur (.a). Il n'est d'ailleurs pas très beau à voir ce code assembleur, car je rappelle que c'est Das qui fait la majorité des optimisations...

  • -r : grâce à cette simple option, l'exécutable sera pur pour être mis résident.

  • -l bibliothèque : relie la bibliothèque indiquée.

  • -D constante[=valeur] : équivalent à mettre un #define constante valeur dans le source. J'ai, entre autres, utilisé cette option dans DiceConfig pour l'option Debug.

  • -s permet d'ajouter un "hunk symbole" à l'exécutable. Très utile pour déboguer car un désassembleur comme Dobj affichera les labels de sauts au lieu de leur valeur (exemple : jsr_bye au lieu de jsrff7c(PC)).

  • -mi : cette option active les appels en ligne (#pragma). Pour qu'une fonction puisse être appelée de cette manière, il faut qu'elle ait été parfaitement prototypée. Évidemment, toutes les fonctions utilisant le passage d'arguments par la pile utiliseront les "glue codes" car les #pragmas n'utilisent que les registres.

  • -proto : teste si toutes les fonctions sont prototypées. Très utile avec l'option précédente pour être sûr que toutes les fonctions seront appelées grâce aux #pragmas. Prototyper permet aussi d'éviter les bogues car le compilateur provoquera une erreur en cas de violation.

  • -new : lors d'une compilation séparée, seuls les blocs modifiés seront recompilés.

  • -prof à -prof3 : ces options permettent d'obtenir des informations statistiques sur l'exécution d'un programme, pour savoir, par exemple, où il perd du temps.

  • -// : comme en C++, grâce à cette option, des commentaires pourront être entrés. Tout ce qui se trouve derrière les // est ignoré à la manière du REM du BASIC. exemple :

    void main(void){
       puts("Bonjour"); // Ceci est un commentaire.
       puts("Tout le monde...");
       }
    

  • -unix : cette option est très utile pour porter sur Amiga un programme du mode Unix. Les noms des fichiers sont convertis à la syntaxe de l'AmigaDOS.

  • -gs : lorsque l'on fait des calculs scientifiques, il est fréquent que les programmes demandent des piles importantes (calculs récursifs), et il est difficile de savoir exactement quelle taille allouer. Grâce à cette option, la pile augmentera automatiquement lorsque ce sera nécessaire.

  • -H : comme chez le Sas C, DICE peut utiliser des "headers" (fichier.h) précompilés pour accélérer les compilations.

  • -no-ctl : option très utile si vous développez votre propre "front-end" pour DICE, car elle dit à DCC d'ignorer un fichier DCCOPTS qui se trouve dans le répertoire courant. Si cette option n'est pas présente, ce fichier a la même fonction que Env:DCCOPTS (variable d'envionnement). A noter que les fonctions contenues dans ce fichier ont priorité sur celles de la variable.

  • -sas, -lattice et -aztec : ces options permettent d'utiliser les exécutables des autres compilateurs au lieu de ceux de DICE.

  • -d1 : malgré ce que j'avais dit la dernière fois, DICE est capable de créer des "hunks debug" grâce à cette option. Je n'ai pas pu tester n'ayant pas de débogueur qui traite ces hunks...
Il y a encore beaucoup d'autres options comme, par exemple, pour créer du code à mettre en ROM, générer du code pour les 68020 ou 68030, les coprocesseurs mathématiques, changer le modèle des données ou du code, l'utilisation des registres...

Les qualificatifs

Ces qualificatifs sont très utiles mais provoquent la perte de la compatibilité avec les autres compilateurs. Voici leur liste (je passe évidemment sous silence ceux qui sont standards au C, ainsi que ceux qui ne sont pas compatibles avec notre machine...) :
  • __autoinit et __autoexit : ces qualificatifs permettent d'appeler des fonctions juste avant _main() ou juste après _exit().

  • __noprof : si le programme est compilé avec l'option prof, les fonctions qui possèdent ce qualificatif ne sont pas examinées par le profiler. Très utile par exemple pour les fonctions des bibliothèques externes dont on ne dispose pas de "glue code" avec le profilage.

  • __shared : permet de conserver la valeur d'une variable lors de plusieurs appels à un programme résident. Prenons l'exemple suivant :

    __shared i=5;
    void main( void ){
        printf("i=%d\n",i);
        i++;
    }
    

    Lors de la première exécution, et après que le programme ait été mis résident, le programme affichera "i=5", alors qu'à la seconde "i=6". Pour faire ceci, DICE a mis "i" dans la section code du programme... Comme je l'avais dit dans le second article de cette série, il est illégal d'agir de la sorte et si l'Arp est utilisée, cela se soldera par une erreur. Rien ne dit qu'un jour le Resident de Commodore ne testera pas l'intégrité des commandes et ce jour-là, cette astuce ne fonctionnera plus. Je déconseille donc d'utiliser ce qualificatif.

  • __config : sans doute le qualificatif le plus intéressant. Au lancement du programme, toutes les variables __config seront chargées et sauvées à la fin. C'est ainsi très facile de créer des fichiers de configuration. Voir les sources de DiceConfig pour un exemple. Notez que si le fichier de configuration n'existe pas, ce qui est le cas à la première exécution, les variables prennent leur valeur par défaut. Exemple : __config i=5, donnera à "i" la valeur "5" si le fichier n'existe pas ou s'il a une mauvaise version...

  • __dynamic : une fonction ou une variable __dynamic n'existe pas dans notre source et sera chargé de manière dynamique lors de l'exécution, un peu à la manière de bibliothèques partageables. Contrairement à celle-ci, la programmation des modules partagés ne demande aucune action particulière, juste quelques précautions évidentes.
La prochaine fois, changement de sujet car nous parlerons des bibliothèques reliables (linkables), et de la compilation séparée.


[Retour en haut] / [Retour aux articles] [Article précédent] / [Article suivant]