Documentation de Gambas - /doc/arch

/doc/arch

# Détails de l'architecture

### Cliquez sur l'image pour obtenir des détails sur l'architecture de Gambas...

Un dessin vaut mieux qu'un long discours. Et j'adore ce genre de diagramme qui font penser qu'un programme a été conçu de manière propre et pensé avec soin ;-).

L'environnement de développement cache toute cette machinerie derrière une interface graphique agréable.

### Projet

Un projet est un ensemble de fichier stockés dans un même répertoire.

Un projet peut contenir des fichiers sources (formulaires, classes, modules) ou bien tout type de fichier de données.

- La configuration du projet est stockée dans un fichier appelé `".project"`.

- Les fichiers sources sont stockés dans un sous-répertoire appelé `".src."`.

- Les fichiers de donnée sont stockés à la racine du répertoire du projet ou bien dans tout sous-répertoire visible.

### Archiveur

L'Archiveur est un programme appelé `gba3`.

Il transforme votre projet, fichier compilés inclus, en un unique fichier exécutable.

### Compilateur

Le Compilateur est un programme appelé `gbc3`.

Il transforme les formulaires, classes et modules de votre projet en fichiers binaires compilés qui peuvent être compris et exécutés par l'interpréteur.

### Fichiers exécutables

Un fichier exécutable Gambas est une archive non-compressé du projet, fichiers compilés inclus.

Le fichier archive est marqué comme script à l'aide de l'entête magique `#!/usr/bin/gbx3`, de telle sorte que Linux l'exécute en appelant l'interpréteur de manière transparente.

### Fichiers Compilés

Un fichier compilé est une représentation binaire d'une classe qui contient l'ensemble des informations nécessaires à l'interpréteur : fonctions transformés en "bytecode", constantes, définitions des variables, information de débogage, etc.

### Utilisation de l'appel système mmap()

Si votre projet est compilé en tant qu'exécutable, c'est-à-dire en tant que fichier archive, l'interpréteur effectuera une projection en mémoire du fichier plutôt que de le charger. Cela vaut le coup !

### Interpréteur

L'Interpréteur est un programme appelé `gbx3`.

Il exécute le "bytecode" contenu dans les fichiers compilés générés par le compilateur.

### Chargeur de classe

Le Chargeur de classe charge les formulaire, classes et modules compilés dans l'interpréteur.

### Unité d'exécution

L'Unité d'exécution est le cœur de l'interpréteur.

Il répartit et exécute chaque instruction contenu dans le "bytecode" généré par le compilateur.

### Débogueur

Le Débogueur est un outil en ligne de commande embarqué dans l'interpréteur.

Il permet à l'environnement de développement de déboguer un programme Gambas en l'exécutant pas à pas, en surveillant le contenu de la pile, en évaluant n'importe quelle expression dans le contexte d'exécution courant, etc.

### Sous-routines

Les Sous-routines sont les fonctions de l'interpréteurs associées aux fonctions de Gambas telles que `Sin`, `Left`, `Stat`, etc. et aux opérateur tels que `+`, `-`, `*`, `&`, etc.

### Interface Composants

L'Interface Composants est un ensemble de routines et de services utilisés par les composants pour communiquer avec l'interpréteur.

L'intimité de l'interpréteur est préservé de cette façon.

### Chargeur de composants

Le Chargeur de composants est la partie de l'interpréteur qui charge les librairies partagées des composant, qui leur donne accès à l'Interface Composants, et qui publie leur propre interface aux autres composants.

### Classes natives

Les Classes natives sont les classes qui peuvent être utilisées en ayant besoin de charger aucun composant.

Elles sont intégrées à l'interpréteur, et peuvent être considérées comme faisant partie du langage Gambas.

### Composants

Les Composants sont les librairies partagées qui sont chargées par l'interpréteur pendant l'exécutino d'un programme.

Ils peuvent contenir de nouvelles classes, des routines d'extensions telle qu'une routine gérant la boucle d'évènements, une routine analysant les arguments provenant de la ligne de commande, etc. Ils pevent publier un ensemble de routines sous forme d'interface disponible pour les autres composants.

Les composants peuvent aussi être écrits en Gambas. Ils sont générés par l'archiveur sous forme d'exécutables Gambas à partir de projets marqués comme "projets composant".