Programmer l’amiga 68k bouts de code IDE langages, astuces

15 sujets de 31 à 45 (sur un total de 75)

slack
26 avril 2025 à 20h41 #384506
@GothDevil (カスリン)

Cela n’est pas un livre mais il y a un page consacrée à la programmation sur le site obligement. Je m’en suis inspiré pour coder en assembleur sur amiga. Mais il y a aussi du C.

Le K&R est un excellent livre sur le C. Les Amiga Rom Kernel Manual sont des références sur amigaOS. J’ai le premier traduit en français et les suivants sous forme de PDF. Des heures de lectures instructives.

Bonnes lectures.
kamelito
27 avril 2025 à 13h52 #384510
Il me semble que parler de K&R réfère à la version non ANSI.
Du coup l’Amiga se programme en C ANSI ou pas ? Car la normalisation est arrivée en 89.
GothDevil (カスリン)
27 avril 2025 à 21h01 #384547
Merci @slack !
__sam__
27 avril 2025 à 23h43 #384550
kamelito wrote:

Il me semble que parler de K&R réfère à la version non ANSI.
Du coup l’Amiga se programme en C ANSI ou pas ? Car la normalisation est arrivée en 89.

L’amiga se programme en ce qu’on veut. Il existe des vieux compilos K&R (Dice (DCC), PDC, SmallC) sur aminet ou ailleurs (Aztec-C) , mais cette syntaxe est vraiment désuète et limite pas mal la détection des problèmes par le compilateur et du coup on se retrouve à avoir des messages cryptiques, ou des plantages hasardeux parce que le programme marche un peu par hasard sans que le compilateur n’affiche de warning à propos d’undefined-behavior qui est un concept de la sémantique C plus récente.

Du coup il vaut mieux utiliser un compilateur moderne dont la sémantique du C est mieux formalisé et laisse moins de chance que le programme marche « par hasard ». Parmi les plus connus, il y a GCC de la distribution ADE sur aminet qui est plutôt très gros mais assez complet mais très orienté unix (y compris dans sa syntaxe asm 680×0 pour ceux qui auraient la curiosité de voir la tronche du code machin généré) et aussi VBCC qui est moins gros, et que je trouve plus simple que GCC qui vient avec toute une clique d’outils secondaires gnu.
* https://aminet.net/package/dev/gcc/ADE-repack (ll y a tout gcc dans la grosse archive)
* https://aminet.net/package/dev/c/vbcc_target_m68k-amiga (kick 2.0+)
ou
* https://aminet.net/package/dev/c/vbcc_target_m68k-kick13
et si on veut faire du C à la unix/posix (après tout le C vient de là):
* https://aminet.net/package/dev/c/vbcc_PosixLib

Evidemment gcc et vbcc existent en cross-dev (pour compiler sur une machine plus puissante) ou dev-natif PPC (morphos) ou même x86 (windows) pour s’amuser à programmer du C portable.

Samuel.

Amiga A500 + GVP530 (8Mo/fpu/mmu/scsi) - en panne 🙁
A500 (+ 1Mo PPS), A1200 (Blizzard-IV/fpu/64Mo)
A500 Vampire V2+ ^8^ 🙂
(mais aussi TO8, TO8D, TO9. Groupe PULS.)
Sethghost
28 avril 2025 à 0h36 #384551
kamelito wrote:

Il me semble que parler de K&R réfère à la version non ANSI.
Du coup l’Amiga se programme en C ANSI ou pas ? Car la normalisation est arrivée en 89.

Excellente remarque/question !

La 2eme Edition du K&C est sous titré Norme ANSI.

Il serait utile de résumer ce qu’est « ANSI », « norme ANSI » et les différentes versions du C dans ce sujet de programmation sur amiga 68k, savoir exactement quelle norme tu peux utiliser et avec quel compilateur.
L’American National Standards Institute (ANSI, litt. « Institut national de normalisation américain ») est un organisme privé à but non lucratif qui supervise le développement de normes pour les produits, les services, les procédés, les systèmes et les employés des États-Unis…

ANSI C = C89 = C90
C89 : Nom officiel de la norme établie par ANSI en 1989.
C90 : Nom donné par l’ISO (Organisation internationale de normalisation) lors de son adoption en 1990.
Ils sont identiques : La norme ANSI C correspond donc à la norme C89/ISO C90, qui a mis fin aux incohérences des compilateurs avant les années 1990.

Dans mon cas, je n’utilise que « ADE » (gcc-2.95.3) et compile exclusivement sur amigaOS 3.2.
ADE permet de compiler du code à la norme C89-C90 mais accepte les commentaires sur une ligne en barres parallèles (C99) :
// ceci est un commentaire
Ce qui fait sortir du C89 strict. (en fait les // sont introduits dans le C99.
En 1999 création de la norme C99 (ISO/IEC 9899:1999).
—
Rappel pour compiler avec ADE :
https://aminet.net/package/dev/gcc/ADE
gcc -noixemul monsource.c
donne un fichier a.out exécutable.

Il faudrait aussi rappeler ce que sont ixemul et la ixemul.library et aussi évoquer « Geek gadgets » :
En gros la ixemul.library associé à ADE crée un pont (ajoute), permet d’utiliser des commandes unix sur amigaOS.
Heureusement, il y a obligement :
http://obligement.free.fr/articles/installation_geek_gadgets.php

Pour faire fonctionner ADE, ajouter ceci à la user-startup ou vérifier que le script d’installation l’a fait :
;BEGIN ADE
CD Coding:ADE
Execute ADE-Startup ; le starter (script dos) du monstre appelé ADE
;END ADE

Vite, un panneau solaire et un PiStorm.
Sethghost
3 juin 2025 à 22h14 #385251
A noter pour ceux que ça intéresse que ce dinosaure de ADE permet de programmer en C++.
https://aminet.net/package/dev/gcc/ADE

Ca, ça ne passera pas avec ADE :
```
#include <iostream>

class Exemple {
public:
    void afficher() {
        std::cout << "Bonjour, C++ !" << std::endl;
    }
};

int main() {
    Exemple ex;
    ex.afficher();
    return 0;
}
```
Mais ça c’est OK : Une early version du C++ catégorisée comme C++98 avec les instructions du C mais avec « classes » disponibles !
```
#include <cstdio> // Inclusion de la bibliothèque standard C pour printf

class Exemple {
public:
    void afficher() {
        printf("Bonjour, C++ !\n"); /* Utilisation de printf pour afficher un message */
    }
};

int main() {
    Exemple ex;
    ex.afficher();
    return 0;
}
```
Vite, un panneau solaire et un PiStorm.
Sethghost
26 juin 2025 à 23h52 #385680
Rappel : Le topic des débutants qui débutent depuis plusieurs décennies.

ARexx, parfait pour apprendre l’algorithmique !
– distribué à partir des versions 2.x d’amigaOS.
– très faiblement typé
– pas si simple
– extensible avec des bibliothèques externes.

Description du code ci dessous : Enrobage de la commande SHOW(‘P’) dans un tableau.
SHOW(‘P’) permet de lister les ports ARexx disponibles.
```
/* ListPortArexx.rexx - Stocker les ports ARexx dans un tableau */

say "Liste des ports ARexx ouverts :"

show_result = SHOW('P') /* Récupère la liste des ports sous forme d'une chaîne */
n_ports     = WORDS(show_result)  /* Compte le nombre de mots (ports), ca devient compliqué hein ?  */

do i = 1 to n_ports               /* Boucle sur chaque port */
    ports.i = WORD(show_result, i) /* Stocke le i-ème mot (port) dans ports.i */
end

/* Affichage du tableau */
do i = 1 to n_ports
    say 'Port #'i': ' ports.i /* plus joli que show('P') qui affiche une ligne */
end

exit 
```
Fonctions et instructions :
SAY : le print « toto » d’ARexx et plus
Exemples, dans le shell :
rx "say toto est un petit rigolo
rx "say 7+7

Remarque : une seule guillemet suffit pour que le shell interprète une commande arexx. (bug ?)
Sous forme de fichier texte, un source arexx commence toujours par une ligne de commentaire :
/* code.rexx */ ou /* */

fonctions internes SHOW(), WORD(), WORDS(), boucle DO… (par de FOR… dans arexx)
Remarque : ARexx faisait (un peu) doublon avec le shell tout en étant plus complet
.
A propos d’ARexx : les descriptions qui revenaient sans arrêt dans les années 90 étaient :
« ARexx permet d’interfacer vos logiciels et d’automatiser certaines taches bla bla bla… »

En réalité ARexx est un langage complet dont la spécialité est le traitement des chaines de caractères mais pas uniquement.
ARexx était le successeur du Basic de Microsoft qu’on trouvait sur les 1,2, 1.3…
[SNIP]
N’hésitez pas à critiquer si un propos semble inexact ou erreur quelconque avant que le forum ne disparaisse, hé hé.
https://aminet.net/package/docs/help/ArexxReference

La fonction SHOWLIST() existe en tant que fonction externe associée à la Rexxsupport.library.

Avec rexxsupport.library activé et SHOWLIST(‘P’), le résultat est identique à celui de SHOW() :
```
/* ListPortArexx2.rexx - Stocker les ports ARexx dans un tableau avec showlist() et rexxsupport.library */

addlib('rexxsupport.library',0,-30,0) /* très important ! */

say "Liste des ports ARexx ouverts :"

show_result = SHOWLIST('P') /* Recupere la liste des ports sous forme d'une chaine */
n_ports     = WORDS(show_result)  /* Compte le nombre de mots (ports) */

do i = 1 to n_ports               /* Boucle sur chaque port */
    ports.i = WORD(show_result, i) /* Stocke le i-eme mot (port) dans ports.i */
end

/* Affichage du tableau */
do i = 1 to n_ports
    say 'Port #'i': ' ports.i
end

exit 
```
Maintenant que rexxsupport.library est en mémoire :
Dans le shell :
rx "say SHOWLIST('L')" /* Avec deux guillemets c'est mieux */
pour voir la liste des librairies en mémoire.
Deux fonctions supplémentaires addlib() et showlist()

Vite, un panneau solaire et un PiStorm.
Counia
22 septembre 2025 à 18h40 #388480
Pour Sethghost
petit déterrage sur ton code du 24/4/2025 « CHAMP D’ETOILES ANIMÉ »
« Testé uniquement sur mon 1200 mais en principe ça peut fonctionner en OCS, ECS, 2 bits, haute résolution. »

Je suis étonné que ça passe sur ton 1200, même que le compilateur ne peste pas.
Les index du tableau « stars » ne sont pas présent (le « i » des boucles « for »).
« stars.x » –> « stars [ i ] .x » etc…
Je n’utilise pas les compilateurs que tu cites, mais si ça passe !!! , l’adresse du tableau vaudra probablement celle de la première structure « stars[0] », ce qui fait qu’on utiliserait qu’une seule étoile sur les 100 allouées.
Sethghost
22 septembre 2025 à 20h04 #388488
Essaye ça Counia. (fichier joint). Possible que ça vienne du copier coller, les commandes forum wordpress font sauter une partie de l’affichage malgré la balise code.
Attachments:

etoiles7.zip
Vite, un panneau solaire et un PiStorm.
Counia
22 septembre 2025 à 22h15 #388493
Oui, le code « .zip » a bien les index au tableau.
En copier-coller comme tu dis ils disparaissent.
Tu les vois sur ton message du 24/4/2025 ou c’est sur mon navigateur que ça merde ?
Sethghost
22 septembre 2025 à 22h34 #388494
Counia wrote:

Tu les vois sur ton message du 24/4/2025 ou c’est sur mon navigateur que ça merde

L’index crochet_ouvrant i crochet_fermant est quel que soit la balise effacé.
Exemple :

Code sans balise :

void drawStars(struct RastPort *rp) {
int i;
int sx, sy;

for (i = 0; i < NUM_STARS; i++) {
sx = stars.x * 256 / (256 – stars.z);
sy = stars.y * 256 / (256 – stars.z);

if (sx >= 0 && sx < SCREEN_WIDTH && sy >= 0 && sy < SCREEN_HEIGHT) {
WritePixel(rp, sx, sy); // Dessine l’etoile en blanc
}

stars.z -= 1;
if (stars.z <= 0) {
stars.z = 255;
stars.x = rand() % SCREEN_WIDTH;
stars.y = rand() % SCREEN_HEIGHT;
}
}

Et le code comme il s’affiche dans l’éditeur du forum et tel qu’il devrait s’afficher sans ce ‘bug’ : (capture d’écran) :

Merci d’avoir détecté le problème ! reste plus qu’à voir si une solution existe.
https://duckduckgo.com/?q=forum+wordpress+balise+pour+le+code&t=h_&ia=web

Vite, un panneau solaire et un PiStorm.
Counia
22 septembre 2025 à 23h55 #388498
Mouai, toute cette puissance de calcul utilisée pour analyser le texte pour au final ne pas l’afficher tel que l’auteur le formate.
Ça doit être ça le progrès !
Sethghost
23 septembre 2025 à 5h16 #388501
Continuons sur la lancée sans tableau cette fois pour voir :
Un simple écran public en 640×256. Simple ? non ! Pas simple du tout. hé hé.
On est pas sous Python mais en C et sur amigaOS 3.x.
La fenetre est vide, donc ne sert à rien à moins d’écrire dedans de faire défiler un truc etc.
```
/*-----------------------------------------------*/
/* pubscreen.c - C ANSI sauf commentaires //     */
/* un ecran public AmigaOS 2.x, 3.x, ferme a la  */
/* demande de l'utilisateur (clic sur le gadget  */
/* de fermeture).                                */
/* Compile avec GCC 2.95 :                       */
/* gcc -noixemul pubscreen.c -o pubscreen        */
/*-----------------------------------------------*/

#include <exec/types.h>
#include <exec/exec.h>
#include <intuition/intuition.h>
#include <graphics/gfx.h>
#include <graphics/view.h> // non utile mais on laisse
#include <stdlib.h>   // rand(), srand(), inutile ici
#include <time.h>     // time() ne sert a rien ici

#define SCREEN_W   640
#define SCREEN_H   256
#define DEPTH      2  // 2bits = 4 couleurs (noir + blanc suffisent)

int main(void)
{
    struct Screen      *screen;
    struct Window      *window;
    struct RastPort    *rp;
    struct IntuiMessage *msg;
    BOOL                done = FALSE;

    /*-------------------------------------------*/
    /*  Declaration de l'ecran public            */
    /*-------------------------------------------*/
    struct NewScreen ns = {
        0, 0,                     /* Left, Top           */
        SCREEN_W, SCREEN_H,       /* Width, Height       */
        DEPTH,                    /* Bitplanes           */
        0, 1,                     /* DetailPen, BlockPen */
        HIRES,                    /* ViewMode (hi-res)   */
        CUSTOMSCREEN,             /* Type = écran public */
        NULL,                     /* Font                */
        "Ecran public AmigaOS",   /* Title               */
        NULL, NULL                /* Gadgets, Extra      */
    };

    srand((unsigned)time(NULL)); //inutile

    screen = (struct Screen *)OpenScreen(&ns);
    if (!screen) return 5;       /* echec d'ouverture d'ecran */

    /* Palette minimale : couleur 0 = noir, couleur 1 = blanc */
    SetRGB4(&(screen->ViewPort), 0, 0, 0, 0);
    SetRGB4(&(screen->ViewPort), 1, 15, 15, 15);

    /* -------------------------------------------------------*/
    /*  Fenetre attachee à l'ecran public                     */
    /* -------------------------------------------------------*/
    window = (struct Window *)OpenWindowTags(
        NULL,
        WA_CustomScreen, (ULONG)screen,
        WA_Title,        (ULONG)"Fermer l'écran", // l'accent
        WA_Width,        SCREEN_W,
        WA_Height,       SCREEN_H,
        WA_Activate,     TRUE,
        WA_CloseGadget,  TRUE,
        WA_DragBar,      TRUE,
        WA_DepthGadget,  FALSE,
        WA_IDCMP,        IDCMP_CLOSEWINDOW,
        TAG_DONE);

    if (!window) {
        CloseScreen(screen);
        return 6;
    }

    rp = window->RPort;          /* RastPort de la fenêtre */

    /* ----------------------------------------------------------------*/
    /* Boucle principale : on attend simplement la fermeture du gadget */
    /* ----------------------------------------------------------------*/
    while (!done) {
        WaitPort(window->UserPort);               /* attend un message */
        while ((msg = (struct IntuiMessage *)GetMsg(window->UserPort))) {
            if (msg->Class == IDCMP_CLOSEWINDOW)
                done = TRUE;
            ReplyMsg((struct Message *)msg);
        }
    }

    /* ----------------------------------------------------------------*/
    /*  Nettoyage                                                      */
    /* ----------------------------------------------------------------*/
    CloseWindow(window);
    CloseScreen(screen);
    return 0;
}
```
AmigaOS 3.x :
. Le RastPort Structure centrale qui décrit le buffer vidéo où l’on dessine (adresse, pitch, palette, etc.). Toutes les fonctions graphiques (WritePixel, RectFill, Text, …) opèrent sur un RastPort. – Chaque fenêtre possède son propre RastPort (window->RPort).- Un écran public a aussi un RastPort via son ViewPort.

. Le ViewPort est la zone de l’écran où un RastPort peut dessiner.
Il appartient à une fenêtre (ou à l’écran complet) et contient les informations suivantes :
coordonnées (x, y) du coin supérieur gauche dans le bitmap de l’écran,
dimensions (largeur × hauteur),
pointeur vers le RastPort qui effectue le rendu,
paramètres de clipping, de couleur et de mode de dessin,
références à la palette et aux plans de bitmaps (planar graphics).

Vite, un panneau solaire et un PiStorm.
Souldream
23 septembre 2025 à 9h01 #388504
Merci SethGhost !! Cela me donne envie de m’y remettre vraiment !

Je termine mon Move … en plein déménagement donc tout est caché dans des cartons actuellement 🙂

...::: Mist - Mister FPGA - FPGA Arcade 060 - ZxUno :::...
...::: A500- A600/Gothek - Amiga 1230 Gotek CF 16GB - A3000 - A4000/30/64Mb/Vlab1.3/Oktagon :::...
...::: Vampire V4 SA :::...
...::: Zx 48/128+2/128+3/QL - Dragon32 - Atari 520STF/1040 :::...
...::: C64 + 1541 / C64 :::...
Sethghost
23 septembre 2025 à 21h41 #388592
Souldream wrote:

Merci…

De rien. L’amiga, avec ses contraintes et ses forces est une machine fabuleuse pour s’initier au C, à l’ASM, à amiblitz…
```
#include <stdio.h>
void main() {
  printf("%d", 1/0);
};  
```
Vite, un panneau solaire et un PiStorm.