Gambas, c'est quoi ?

Le logo de Gambas 3

Introduction

Le maître monta en chaire,
et au moment même où il allait
commencer son sermon du jour,
un rossignol se mit à chanter.
Quand l’oiseau eut finit de chanter,
Le maître dit :

"C’est tout ce que j’avais à vous dire."

Puis il prit congé.

Gambas est un langage entièrement orienté objet et un environnement de développement construit sur un interpréteur BASIC.

Il est distribué sous la licence publique générale GNU.

Son architecture s'inspire largement de celle de Java. Ainsi Gambas est constitué :

  • D'un compilateur.

  • D'un interpréteur.

  • D'un archiveur.

  • D'un scripteur.

  • D'un environnement de développement.

  • De nombreux composants d'extension.

Le compilateur est un petit exécutable rapide écrit en C:

  • Il arrive à compiler environ 500000 lignes de codes significatives par seconde sur mon Core2 Duo @2.33GHz. Cette vitesse permet un processus de développement incrémental rapide (coder, compiler, tester).

  • Il n'optimise quasiment pas le code pour le moment, l'optimisation reposant essentiellement sur l'interpréteur lors de l'exécution.

  • Il gère et compile les traductions de chaînes en utilisant les outils GNU gettext.

L'interpréteur est un petit exécutable écrit lui-aussi en C qui pèse environ 320 ko sur un système 64 bits.

  • Il fournit toutes les fonctionnalités natives du langage en permettant un accès indirect à pratiquement toutes les fonctionnalités natives de la glibc POSIX.

  • Il charge les classes à la demande, en optimisant le "bytecode" la première fois qu'il est exécuté.

  • Les liaisons entre classes sont faites entièrement à l'exécution, et le plus tard possible. De cette façon, même un gros exécutable démarre rapidement.

Enfin, l'archiveur est un programme qui crée un exécutable Gambas à partir d'un dossier d'un projet Gambas.

Notez qu'un exécutable Gambas est simplement une archive non compressée d'un projet. Il peut inclure n'importe quel type de fichier, pas seulement du bytecode compilé. L'interpréteur y accède en interne comme à un système de fichier.

Le langage Gambas

Les caractéristiques principales du langage BASIC de Gambas sont :

  • Environ 250 mots-clefs et fonctions natives pour gérer a peu près tout : arithmétique, chaînes de caractères, entrées-sorties, fichiers, gestion du temps...

  • Gestion complète des erreurs.

  • Gestion des processus et des pseudo-terminaux.

  • Support pour surveiller les descripteurs de fichiers d'entrée-sortie.

  • Support des boucles d'évènements avec des timers.

  • Support natif des chaînes codées UTF-8.

  • Internationalisation complète et gestion de la traduction.

  • Possibilité d'appeler les fonctions externes des bibliothèques partagées du système.

Mais Gambas est aussi un véritable langage orienté objet, possédant :

  • Objets et classes.

  • Propriétés, méthodes, constantes et évènements.

  • Des symboles publics et privés.

  • Le polymorphisme, c. à d. une méthode de dispatching virtuel.

  • Un héritage simple.

  • Les constructeurs et destructeurs.

  • Mécanismes d’accès aux tableaux, énumérateurs, et objets triables.

Le mécanisme d'héritage de gambas est entièrement dynamique et vous permet de :

  • Créer une version plus spécialisée d'une classe déjà existante.

  • Ré-implémenter une classe et l'étendre.

  • Surcharger les méthodes ou les propriétés d'une classe.

N'importe quelle classe peut être héritée, ré-implémentée ou surchargée, même les classes natives écrites en C/C++.

Enfin, il existe une classe native appelée Observer, qui vous permet d'intercepter tous les évènements générés par un objet quelconque.

Un langage extensible

Le cœur de Gambas, l'interpréteur, est un programme en ligne de commande. Toutes les autres fonctionnalités sont fournies par des composants, qui sont un ensemble de classes écrites en C/C++, ou bien directement en Gambas.

Ces composants fournissent entre autres :

  • L'interface graphique de programmation utilisateur basée sur les boîtes à outils QT4 ou GTK+.

  • L'accès à de nombreux systèmes de base de données: MySQL, PostgreSQL, SQLite et ODBC.

  • La programmation réseau avec la gestion des protocoles Internet: HTTP, FTP, SMTP, DNS.

  • Les application automation avec D-Bus.

  • La programmation SDL.

  • La programmation OpenGL.

  • La programmation XML.

  • La programmation CGI avec une gestion des sessions.

L'ensemble des fonctionnalités de Gambas est couvert par 405 classes et 5065 symboles seulement. (au jour d'aujourd'hui). Il y a donc un petit nombre de concepts à apprendre lorsque l'on compare avec d'autres langages. De plus, nous essayons de rendre les noms de ces symboles aussi cohérents que possible.

Tout cela rend Gambas relativement simple à apprendre.

Les composants écrits en C/C++ sont stockés dans des bibliothèques partagées, et les composants écrits en Gambas sont simplement des projets Gambas tout ce qu'il y a de normaux.

Ils sont chargés par l'interpréteur au démarrage du programme ou à la demande pendant l'exécution.

Développer un composant en C/C++ est un peu comme développer un pilote matériel pour le noyau Linux :

  • Le code source du composant est situé dans l'arborescence du code source de Gambas.

  • Le composant et l'interpréteur communiquent au moyen d'une interface de programmation (API).

  • Ils sont exécutés dans l'environnement de l'interpréteur et ne peuvent pas faire tout ce qu'ils veulent.

La documentation traitant de l'écriture des composants n'est pas encore terminée, mais toute l'aide nécessaire sera apportée sur la liste de distribution des développeurs.

Un langage de script

Gambas est utilisable en tant que langage de script. Cette fonctionnalité est fournie par le générateur de script, un petit exécutable Gambas qui vous permet d’envoyer n'importe quel code Gambas dans un fichier texte.

Voici un petit exemple de script :

#!/usr/bin/env gbs3

' Ce script retourne la mémoire réellement utilisée par le système ; le cache et le swap sont exclus.

Function GetUsedMemory() As Integer

  Dim sRes As String
  Dim aRes As String[]
  Dim cVal As New Collection
  Dim sVal As String

  Exec ["cat", "/proc/meminfo"] To sRes

  For Each sVal In Split(sRes, "\n", "", True)
    aRes = Split(sVal, " ", "", True)
    cVal[Left$(aRes[0], -1)] = CInt(aRes[1])
  Next

  Return cVal!MemTotal - cVal!MemFree - cVal!Buffers - cVal!Cached + cVal!SwapTotal - cVal!SwapFree - cVal!SwapCached

End

Print Subst("Mémoire utilisée: &1 Kb", GetUsedMemory())

Indépendance vis-à-vis des bases de données, de l'interface graphique et du bureau

Les composants de Gambas ne se contentent pas d'être de simples "bindings". Ils fournissent autant que possible une abstraction de l'interface des bibliothèques sous-jacentes, afin de gagner en cohérence et en simplicité.

Indépendance vis-à-vis des bases de données

Avec Gambas, vous pouvez écrire des programmes qui sont indépendants du système de base de données sous-jacent : toutes les bases de données sont accédées à travers la même API.

Par exemple, le gestionnaire de base de données intégré dans l’IDE utilise le même code pour gérer les bases MySQL, PostgreSQL, SQLite ou ODBC.

Le gestionnaire de base de données de l’IDE

Indépendance vis-à-vis de l’interface graphique utilisateur

Avec Gambas, vous pouvez écrire des programmes indépendants de la boîte à outils graphique : le composant QT4 et le composant GTK+ ont la même interface.

Voici un exemple Gambas exécuté avec les boîtes à outils QT4 et GTK+.

The Printing example using Qt4 The Printing example using GTK+

Indépendance vis-à-vis du bureau

Nous essayons en outre, de favoriser l’indépendance vis-à-vis du bureau par :

  • L’utilisation de thèmes d’icônes en accord avec l’environnement de bureau en cours (KDE, Gnome ou XFCE).

  • Le composant gb.desktop, basé sur les scripts shell du projet Portland.

Voilà l’IDE Gambas utilisant les thèmes d’icônes KDE et Gnome.

L’environnement de développement utilisant le thème KDE L’environnement de développement utilisant le thème Gnome

L’environnement de développement

Gambas fournit un IDE complet, lui-même écrit en Gambas.

Vous pouvez créer des formulaires, insérer des contrôles juste en les dessinant, éditer votre code et faire des tas d’autres choses semblables aux autres systèmes de développement rapide d’applications.

L’éditeur de code source Le débogueur

L'environnement de développement de Gambas offre les fonctionnalités suivantes :

  • Coloration syntaxique du code Gambas, de l'HTML et des CSS.

  • Auto-complétion.

  • Éditeur de formulaires.

  • Débogueur intégré.

  • Éditeur d'icônes.

  • Traducteur de chaînes de caractère.

L'éditeur d'icônes La boîte de dialogue de traduction

  • Support de Subversion.

  • Gestionnaire de base de données

  • Documentation en ligne provenant directement de la documentation wiki.

  • De nombreux programmes d'exemple.

De plus, il peut faire des paquetages d’installation pour de nombreuses distributions, et aussi des paquetages d’installation tar.gz basés sur GNU autotools.

Les distributions GNU/Linux suivantes sont gérées :

  • Archlinux.

  • Debian.

  • Fedora.

  • Mandriva.

  • SuSE.

  • Slackware.

  • Ubuntu.

     

Le gestionnaire de paquets de l’IDE

Les paquets générés par l'IDE fonctionnent seulement si la distribution cible a correctement empaqueté Gambas comme indiqué sur la page How To Package Gambas du wiki.

Nous essayons, dans la mesure du possible, d’inciter les distributions à réaliser des paquets Gambas corrects. Ce n’est pas toujours facile !

Vous pouvez nous aider en soumettant des rapports de bogues aux distributions qui échouent dans cette tâche essentielle.

Enfin, même si l'environnement de développement est très lié au langage Gambas, il n'est formellement pas nécessaire de l'utiliser pour créer des programmes Gambas. Tous les outils Gambas (compilateur, interpréteur...) peuvent être invoqués en ligne de commande.

Téléchargement de Gambas et autres liens.

Vous pouvez télécharger Gambas sur http://gambas.sourceforge.net depuis le menu "Télécharger".

Pour plus d’informations à propos de Gambas, voici quelques liens :

Vous pouvez transmettre les problèmes et bogues soit sur la liste de distribution, soit sur bugtracker.

Nous espérons que vous apprécierez Gambas autant que nous ! :-)

Benoît Minisini