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

[Sethghost]

Sethghost

#375811

Pas du nouveau, juste une tentative de condenser ce qui a déjà été écrit ici et ailleurs :
sujet mémo ouvert pour les éternels débutants / amateurs même peu doués souhaitant approfondir leurs connaissances ou plus simplement pour nourrir leur cerveau.

Le sujet de 135 lignes ne passe pas, peut-être un filtre anti-spam qui considère que + de 5 url c’est du flood 🙂

Attachments:

1. Programmer_lamiga_bouts_de_code_IDE_langages_astuces.pdf

Vite, un panneau solaire.

[Sethghost]

Sethghost

#375813

On commence avec un bout de code simple en C récupéré on ne sait plus ou et modifié pour produire un effet bizarre à l’écran. Le code n’est pas commenté, à compiler soit même pour les curieux, soit avec ADE soit avec un GCC plus récent ou StormC ou etc…

/* bougefenetre.c - programme qui déplace la fenetre active vers la position 5,5 */
#include <intuition/intuitionbase.h>
#include <proto/exec.h>
#include <proto/intuition.h>
#include <proto/dos.h>

int main(void)
{
int i;

for (i=0; i<=70; i++)
/*    Delay(5*50); */
    MoveWindow(IntuitionBase->ActiveWindow, 5, 5);
return 0;
}

Le programme se lance à partir du workbench.
Notez que le return 0; n’est pas obligatoire pour que le programme compile. Le programme n’a pas d’entête, ce qui n’est pas bien du tout 🙂 /* bougefenetre.c */

Vite, un panneau solaire.

[slack]

slack

#375816

@Sethghost,

Étant autodidacte en programmation, il me manque beaucoup d’informations.

Je suis surpris que la variable IntuitionBase soit utilisée sans être initialisée. Faut-il ajouter une ligne

IntuitionBase = openlibrary( "intuition.library" ; 0 );
au début du main, et ajouter une ligne pour fermer cette bibliothèque avant le return ? Ou bien cette variable est-elle initialisée dans l’un des include ?

[henes]

henes

#375817

IntuitionBase est déclaré et initialisé dans du code qui est automatiquement ajouté au tiens au moment de l’édition de liens. Ce code se trouve dans les « constructeurs ».
Et un « destructeur » se charge d’appeler CloseLibrary() après le return final de ton main().

Mais à partir du moment où tu déclares IntuitionBase dans ton code alors tu dois ouvrir et fermer (avant le return final) intuition.library toi même. C’est par exemple utile si tu veux ouvrir une version minimum d’une bibliothèque.

[Sethghost]

Sethghost

#375818

slack wrote:

Étant autodidacte en programmation, il me manque beaucoup d’informations

On est nombreux dans ce cas ! ce sujet est fait pour ça ! 🙂 On a aussi des bons profs genre Henes ou Sam ou d’autres qui peuvent partager (un peu) leur connaissances

Vite, un panneau solaire.

[stephbb75]

stephbb75

#375819

Salut,

Alors il y a bien longtemps j’avais commencé une partie programmation en C sur mon site 😉
http://sitedesteph.free.fr/amiga/le-c/index.php
Alors c’est fini mais donne 2 ou 3 trucs 😉

https://youtube.com/@stephbb75

[stephbb75]

stephbb75

#375820

Salut,

slack wrote:

Je suis surpris que la variable IntuitionBase soit utilisée sans être initialisée. Faut-il ajouter une ligne

Oui c’est mieux, de toute façon c’est une bonne habitude a prendre.
Les truc fait totomatiquement faut fuir 😉

La partie intuition:
http://sitedesteph.free.fr/amiga/le-c/index.php?page=lib&part=plib&part2=intuition

https://youtube.com/@stephbb75

[Sethghost]

Sethghost

#375822

stephbb75 wrote:

Alors il y a bien longtemps j’avais commencé une partie programmation en C sur mon site
http://sitedesteph.free.fr/amiga/le-c/index.php

Merci pour le lien.
—
Jargon qui permet de comprendre le C et donc comment le code fonctionne sur amiga et d’autres systèmes.
https://fr.wikipedia.org/wiki/C_(langage) –

– [SNIP] Trop tôt pour parler des pointeurs. Je mets le paragraphe « pointeur » dans une nouvelle version du pdf en cours d’édition du 1er post qui fait maintenant plus de 100 kb.

– Constructeur, Destructeur : Par rapport au post précédent.

Y a t-il des constructeurs et des destructeurs en lang. C ?
En langage C, contrairement à certains langages de programmation orientée objet tels que C++, il n’y a pas de constructeurs ni de destructeurs intégrés en tant que caractéristiques de la langue.

Un constructeur est généralement une méthode spéciale appelée lorsqu’un nouvel objet est créé pour effectuer des initialisations spécifiques à cet objet. Un destructeur est appelé lorsque l’objet est détruit pour effectuer des nettoyages ou des opérations de libération de ressources.

En C, il est de la responsabilité du programmeur de gérer explicitement l’initialisation et la libération des ressources associées à des structures de données ou à des objets personnalisés. Cela se fait généralement en utilisant des fonctions spéciales pour l’initialisation et la libération, plutôt que par des constructeurs et des destructeurs automatiques.
—

Pour bougefenetre.c
Comme l’a expliqué Henes, par rapport à IntuitionBase
Du code permettant d’ouvrir et fermer des libs spécifiques est appelé automatiquement à partir des includes par le code bougefenetre.c lors de la création de l’exécutable.

– On produit un exécutable avec la commande gcc -noixemul bougefenetre.c qui crée un fichier amiga appelé a.out
Il y a bien sur d’autres façons de faire (compiler).

Vite, un panneau solaire.

[Sethghost]

Sethghost

#375825

Deuxième bout de code toujours en lang. C lié aux posts précédents.
Comme le code est plus long il nécessite un peu plus d’explications :

/* openbase.c - ouverture et fermeture de intuition.library, ne fait strictement rien d'autre */

#include <dos/dos.h>
#include <proto/dos.h>
#include <proto/exec.h> /* Sans cette ligne, le code fait un warning avec gcc 2.95.3 */
#include <stdio.h>

int main(void)
{
    struct Library *IntuitionBase = NULL;

    /* Ouvrir la bibliothèque "intuition.library" */
    IntuitionBase = OpenLibrary("intuition.library", 0);
    if (IntuitionBase == NULL)
    {
        fprintf(stderr, "Erreur lors de l'ouverture de intuition.library\n");
        return 1;
    }

    /* code principal a ajouter ici */

    /* Fermer la bibliothèque "intuition.library" lorsque vous avez terminé */
    if (IntuitionBase != NULL)
    {
        CloseLibrary(IntuitionBase);
    }

    return 0;
}

Ceux qui ont envie peuvent modifier ce code, l’améliorer et commenter leurs modifs. Ce code compile, s’exécute et n’affiche strictement rien à l’écran. Se compile avec : gcc -noixemul openbase.c

Vite, un panneau solaire.

[gordini21]

gordini21

#375826

Pas besoin de retourner quoi que ce soit.
Void main(void)

Pour comprendre le C
Le Langage C Kernighan et Ritchie

Il n’ y a pas mieux l.ideal c est la premiere version noire pas la norme ANSI mais ça c est pour les vrais 🙂

Il n’ y a aucun mal à être autodidacte le C le permet l’Amiga encore plus.
Je suis autodidacte et j’ai été responsable logiciel Temps réel en traction ferroviaire.

Le C reste pour moi le meilleur langage qui existe cela génère du code propre efficace, efficient.
C est d ailleurs le langage le plus « vert » car binaire peu gourmand. Il faut réfléchir en C 🙂

Amuse toi bien avec ce superbe langage.
Le C++ a été inventé pour donner du boulot aux informaticiens si on avait continué à coder en C on aurait plus rien a faire 🙂
Et je parle pas de Java et consort.

Après une IHM en C ça occupe …

[stephbb75]

stephbb75

#375829

Salut,

gordini21 wrote:

Pas besoin de retourner quoi que ce soit.

Bas si il retourne si erreur ou pas 😉

Sur toutes les machines ce n’est pas le C qui est le plus compliqué, mais les lib de la machine, et sur Amiga il nous on pas gâter 🙂

https://youtube.com/@stephbb75

[Sethghost]

Sethghost

#375833

Explication de texte détaillée du code plus haut : openbase.c.

1 – Le commentaire au début du code explique que ce fichier source (openbase.c) traite de l’ouverture et de la fermeture de la bibliothèque Intuition. A noter que le code principal doit encore être ajouté.

2 – Les directives #include sont utilisées pour inclure les fichiers d’en-tête nécessaires pour ce programme. Ils comprennent <dos/dos.h>, <proto/dos.h>, <proto/exec.h>, et <stdio.h>.

3 – La fonction main() est la fonction principale du programme. Elle ne prend pas d’arguments. Enfin si, il y a void 🙂

4 – Une variable struct Library *IntuitionBase est déclarée. Cette variable sera utilisée pour stocker un pointeur vers la bibliothèque Intuition une fois qu’elle sera ouverte.

5 – Le code utilise la fonction OpenLibrary() pour ouvrir la bibliothèque « intuition.library ». Cette fonction prend le nom de la bibliothèque en tant que premier argument et un drapeau en tant que deuxième argument. Ici, le drapeau est défini à 0, ce qui signifie une ouverture standard. Si l’ouverture réussit, un pointeur vers la bibliothèque est retourné et stocké dans IntuitionBase. Si l’ouverture échoue, le code affiche un message d’erreur sur la sortie d’erreur standard (stderr) et retourne 1 pour indiquer une erreur.

6 – Du code avec l’utilisation de la bibliothèque Intuition doit être ajouté à la place des commentaires. pour faire de cet exemple un programme utile. Pour le moment c’est vide.

7 – Après l’exécution du code principal ou même sans ajout, la bibliothèque Intuition est fermée en utilisant CloseLibrary(). Cela libère les ressources associées à la bibliothèque. Il faut vérifier si IntuitionBase n’est pas NULL avant d’appeler CloseLibrary(), car si l’ouverture a échoué, IntuitionBase serait NULL, et appeler CloseLibrary(NULL) entraînerait des erreurs.

8 – Dernier point : la fonction main() retourne 0 pour indiquer que le programme s’est terminé normalement.

Vite, un panneau solaire.

[Sethghost]

Sethghost

#375834

Nouveau source C à compiler pour notre machine infernale préférée l’amiga.
C’est une modification d’un code produit en 1998 sur un site disparu et ne pouvant compiler à cause de la fonction d’origine getchar().
Ce programme n’est pas spécifique à l’amiga, c’est du C « pur » sans utilisation des includes amiga.
On peut ajouter que contrairement aux 2 exemples plus haut, ce code a une certaine utilité et pourrait être une source d’inspiration pour un programme plus conséquent. Ce code n’utilise pas d’interface autre que le shell. (Pas d’intuition, de reaction, de mui, etc.)

 /* structs2.c v1.1 (06/29/98---10-06-2023) */
#include <stdio.h>
#include <stdlib.h>

struct MyRecord {
   char first_name[25];
   char middle_initial;
   char last_name[25];
   unsigned char age;
};

int main(int argc, char *argv[])
{
   struct MyRecord employee[3];
   unsigned char x;
   char temp_age[4];

   for(x = 0; x < 3; x++ ) {
      printf("Employee #%d\n", x);
      printf("Enter the first name of the employee : ");
      gets(employee[x].first_name);
      printf("Enter the middle initial of the employee : ");
      employee[x].middle_initial = getchar();
      printf("Enter the last name of the employee : ");
      gets(employee[x].last_name);
      printf("Enter the age of the employee : ");
      gets(temp_age);
      employee[x].age = atoi(temp_age);
   }
   for(x = 0; x < 3; x++ ) {
      printf("Employee #%d\n", x);
      printf("name : %s, %s %c\n", employee[x].last_name, employee[x].first_name, employee[x].middle_initial);
      printf("age : %d\n", employee[x].age);
   }
   return 0;
}

gcc -noixemul structs2.c ou gcc -noixemul -o structs2 structs2.c
Libre à chacun de modifier, de commenter, d’ajouter une interface. Evidemment il faut du temps et le temps en ce moment comme l’électricité a un prix.

Vite, un panneau solaire.

[Sethghost]

Sethghost

#375866

lang. C de base compatible gcc Amiga. Ultra simple en apparence mais intéressant pour comprendre les boucles et moins ennuyeux qu’un Hello world. On peut d’ailleurs rester bloqué longtemps sur les boucles infinies imbriquées (éternellement) avant d’attaquer les pointeurs (:peur).

/* vite.c - VITE ! Plus VITE !!! */
#include <stdio.h>

int main() {
    while (1) {
        printf("Vite un panneau solaire, vite ! :)\n");
    }
    return 0;
}

gcc -noixemul -o vite vite.c

On peut faire la même chose en amigaDOS.

Vite, un panneau solaire.

[Sethghost]

Sethghost

#375931

Le C et ses pointeurs… L’amiga et ses fonctions… Rappelons que ce topic s’adresse à des débutants toujours en vie qui ne captent rien à l’assembleur ou autre langage « compliqué » du genre.

INTERRO ECRITE, sortez vos claviers. le source est issu d’un exemple tiré du Amiga ROM Kernel Reference Manual Libraries 3rd Edition »
https://archive.org/details/amiga-rom-kernel-reference-manual-libraries-3rd-edition/mode/2up

/* easy.c : a complete example of how to open an Amiga function library inc.
In this case the function library is Intuition. * function library is open, any Intuition function can be called. Once the Intuition This example uses the DisplayBeep() function of Intuition to flash the screen. 
With SAS/C (Lattice), compile with lc -L easy.c 
*/

/* Declare the return type of the functions we will use. */

/* En premier, ajout des includes qui ne sont pas dans l'exemple */
#include <dos/dos.h>
#include <proto/dos.h>
#include <proto/exec.h> 
#include <stdio.h>
#include <libraries/dos.h> /* il manque un #include <proto/intuition.h>, des includes en trop */

/ * struct Library *OpenLibrary();  These Exec library functions can be called anytime (Exec is always open). 
void CloseLibrary(); Before using this Intuition function, the Intuition library must be opened 
void DisplayBeep();  cette fonction est en fait une fonction d'affichage, cette instruction ne sert à rien, ce qui est un indice pour corriger ce code plantagène hu hu ... 

Toute la partie précédente est en fait un commentaire, sauf les includes, voir le post suivant de Gilloo  */

struct IntuitionBase *IntuitionBase; /* Get storage for the library base. The base name MUST be IntuitionBase */

int main()
{

IntuitionBase=(struct IntuitionBase *)OpenLibrary("intuition.library",33L);

if (IntuitionBase) {  /* Check to see if it actually opened. The Intuition library is now open so. any of its functions may be used. */
    DisplayBeep(OL); /* la fonction simple de la mort, En fait ce n'est pas (OL) mais (0L), (zéro L)  */
    CloseLibrary(IntuitionBase); /* Always close a library if not in use. */
}
else{    /* The library did not open so return an error code. The exit() function is not part of the 0S, it is part of the compiler link library. */
exit(20);
      }
}  

Ce source ouvre et ferme intuition et affiche un « beep » à l’écran, mais il manque un morceau de code pour que ça compile, l’exemple donné dans le bouquin est faux, volontairement ou pas (ptetre parce qu’il s’adresse à des gens expérimentés) comme si les choses n’étaient pas assez difficiles comme ça, hé hé.
Si personne n’est intéressé par un topic sur le code sur amiga, tant pis 🙂
Si un « connaissant » veut corriger ce code avec quelques explications, qu’il n’hésite point.

Vite, un panneau solaire.