FutureBASIC

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher

FutureBASIC est un environnement de développement gratuit en BASIC dédié au Macintosh d'Apple, Inc.

FutureBASIC
Logo.

Auteur Staz Software, FBtoC
Dernière version stable FB4/FBtoC 1.0 (le 1er janvier 2008)
Paradigme Programmation procédurale
Typage faible
Système d'exploitation Mac OS, Mac OS X
Site web http://www.stazsoftware.com/futurebasic/

FutureBASIC est un environnement de développement intégré (IDE ou EDI) consistant en un ensemble d'outils logiciels tels que compilateur, éditeur de texte, gestionnaire de projets, débogueur, profileur[1] et outil RAD (Développement rapide d'Applications) qui produit des applications pour la plate-forme Macintosh d'Apple équipée des microprocesseurs Motorola 68000 ou PowerPC. Depuis le 1er janvier 2008, le graticiel FBtoC est venu compléter l'environnement. Ce logiciel convertit les projets FutureBASIC en leur équivalent en langage C, puis fait appel au compilateur GCC (GNU Compiler Collection) pour créer des applications. FutureBASIC permet un accès facile aux procédures et fonctions des bibliothèques de Mac OS. Le compilateur intégré est très efficace (le processus de compilation en une passe est très rapide) et il crée des fichiers exécutables compacts et en pratique aussi rapides à l'exécution que du code créé par le C. À la différence de certaines autres mises en œuvre du langage BASIC, FutureBASIC ne nécessite pas la présence de machine virtuelle, ni d'un interprète, les applications qu'il produit sont autonomes et double-cliquables.

Histoire de FutureBASIC[modifier | modifier le code]

FB est apparu au milieu des années 1980[2] sous le nom de ZBasic. Réalisé par Andrew Gariepy, le logiciel est envisagé à ses débuts comme système de développement multiplate-forme. Assez rapidement, l'aspect multiplate-forme a été abandonné au seul profit de la plate-forme Macintosh. Le logiciel a su attirer bon nombre de programmeurs très dévoués qui encensaient sa facilité d'utilisation et surtout la compacité et la rapidité du code créé par son compilateur très optimisé en assembleur 68K. En 1992, après la version 5 de ZBasic[3], Zedcor Inc., la société des frères Gariepy (Andy, Mike et Peter) basée à Tucson, Arizona présente FutureBASIC (appelé ultérieurement FBI[4]). En 1995, Staz Software[5], société dirigée par Chris Stasny, acquiert les droits de commercialisation de FutureBASIC. Staz Software, inc. sort presque aussitôt une mise à jour baptisée FBII[6], incluant ses propres développements, en l'occurrence Program Generator[7] (PG PRO), un outil RAD réalisé par Chris Stasny en personne.

La transition du CPU 68K vers le PowerPC a été un processus coûteux en temps et aussi en utilisateurs impatients. Elle a impliqué une refonte totale du logiciel, la réécriture complète de l'éditeur de texte par Chris Stasny et une adaptation conséquente du compilateur par Andrew Gariepy, un travail entrepris pendant les jours les plus sombres d'Apple où l'avenir du Macintosh et celui de la société-même faisaient l'objet de questionnements réguliers dans la presse spécialisée. En janvier 2000[8], le résultat de leurs efforts est rendu public avec la sortie de FB^3[9], un environnement de développement considérablement amélioré incluant entre autres choses un compilateur séparé, plusieurs runtimes[10] (moteur d'exécution) écrits en BASIC et ainsi modifiables par le programmeur, la possibilité d'injecter du code en mnémoniques assembleur PPC, un accès simplifié aux API (interface de programmation) de la Toolbox du Macintosh (Boîte à outils Macintosh), une bibliothèque étendue de fonctions intégrées. Les versions majeures ultérieures ont introduit le runtime Appearance[11] écrit par Robert Purves et la possibilité de créer des applications compatibles Carbon. Une fois l'environnement lui-même entièrement « carbonisé » pour s'exécuter nativement sous Mac OS X, l'environnement a été appelé FB4.

Basé à Diamondhead, Mississippi, Staz Software a été très sévèrement touché par l'Ouragan Katrina en août 2005. Le développement de FutureBASIC a été ralenti, presque jusqu'à stagner, au moment où un effort supplémentaire était requis pour adapter FutureBASIC aux évolutions du Macintosh vers les microprocesseurs x86 d'Intel. Plus récemment, une équipe de programmeurs volontaires a développé le logiciel passerelle, FBtoC, qui permet à FB de créer des applications en Universal binaries par le truchement du compilateur Open Source GCC qui est livré avec le système d'exploitation Mac OS X. Le 1er janvier 2008, Staz Software annonce que FB4 est devenu graticiel et FBtoC[12] 1.0 est rendu public le même jour.

FutureBASIC 5 (FB5) est mis en circulation en septembre 2008. Le compilateur historique réalisé par Andy Gariepy est définitivement abandonné et l'intégration de FBtoC avec l'éditeur est entamée. Désormais, le mode opératoire de FutureBASIC sera de traduire de manière transparente le code BASIC en son équivalent C, puis de faire appel aux compilateurs libres livrés avec le système sur les machines d'Apple (gcc et clang). Après avoir introduit en juillet 2009 un éditeur amélioré et révisé pour s'exécuter en mode natif sur Intel, l'intégration de FBtoC est achevée en janvier 2011 avec la version 5.5 de FutureBASIC. La version 5.6 sort en juillet de la même année pour assurer la compatibilité avec OS X Lion. Un mois après la sortie de la version 5.7.3 en juin 2012, Robert Purves, programmeur de génie et leader de la petite équipe qui avait pris en charge l'évolution de l'environnement de programmation, décède des suites d'une maladie. Malgré cette incommensurable perte, Brian Stevens reprend le flambeau jusqu'à la version 5.7.6.

En avril 2013, FutureBASIC 5.7.6 et son compagnon FBtoC deviennent "open source" sous licence GPL.

Processeurs et systèmes d'exploitation supportés[modifier | modifier le code]

FutureBASIC a supporté et continue le support de nombreuses versions de Mac OS

Configuration requise pour créer des applications en Universal binaries avec FBtoC : Mac OS X 10.4 ou version ultérieure, GCC 4.0 ou version ultérieure ; les Kits de développement (SDK) multiplate-forme doivent être installés.

Syntaxe[modifier | modifier le code]

FutureBASIC est un langage permettant de mettre en œuvre un style de programmation modulaire et procédurale en incitant fortement le programmeur à utiliser des fonctions et des variables locales.

Flux des programmes et blocs structurels[modifier | modifier le code]

Les fonctions définies par l'utilisateur (alias LOCAL FN dans FutureBASIC) ressemblent à celles des langages Pascal et C. Elles peuvent :

  • être totalement isolées du programme principal (directive LOCAL MODE);
  • permettre la récursivité;
  • être appelées dynamiquement pendant l'exécution du programme (directive DEF FN USING);
  • être appelées automatiquement par les vecteurs d'événements intégrés aux runtimes de FutureBASIC (directive ON EVENT FN);
  • utilisées comme unités de traitement coopératives (commande THREADBEGIN).

Des blocs structurels spéciaux (ENTERPROC/EXITPROC) peuvent être aussi définis pour être utilisés comme procédures et fonctions de rappel lorsque la Toolbox du Macintosh est invoquée.

Le langage dispose d'un ensemble complet de vecteurs pour le développement d'applications pilotées par les événements, tels que ON MENU, ON MOUSE, ON DIALOG, ON APPLEEVENT, ON EDIT, ON TIMER, etc.

D'autres mots-clés plus classiques permettent de définir des blocs d'instructions conditionnels comme :

  • LONG IF .... XELSE ... END IF
  • DO .... UNTIL
  • WHILE ... WEND
  • SELECT ... CASE... CASE ELSE ... END SELECT
  • FOR ... NEXT

Pour la compatibilité avec le BASIC standard FutureBASIC supporte les instructions GOTO, GOSUB/RETURN, les numéros de ligne et les étiquettes.

Un exemple de programme simple qui demande la saisie d'un nombre et affiche le message "Bonjour le monde" est présenté ci-dessous :

// Exemple de programme FutureBASIC très simple

dim i,num,a$                    // déclaration des variables

window 1                        // ouvre une fenêtre standard
input "Nombre de boucles "; a$  // simple saisie au clavier d'une entrée par l'utilisateur
num=val(a$)                     // convertit le texte en nombre
long if num>0                   // bloc conditionnel IF
  for i = 1 to num              // boucle simple
    print "Bonjour le monde"    // affichage du texte à l'écran
  next i                        // fin de boucle
 xelse                          // autrement
  print "Pas aujourd'hui"       // aucun nombre n'a été saisi
end if

do                              // attend que l'utilisateur ait choisi de quitter
  HandleEvents
until ( gFBQuit )               // et permet de voir le résultat affiché

Types de données[modifier | modifier le code]

FutureBASIC supporte les types de données courants tels que les entiers courts ou longs, les nombres réels à Virgule flottante en simple et double précision, les chaînes de caractères (format Pascal), les tableaux, mais aussi les records (structures de données similaires aux struct du C). Le langage dispose de structures moins conventionnelles telles que les tableaux dynamiques (DIM DYNAMIC), les pseudo-tableaux (XREF), les tableaux de chaînes dynamiques (INDEX$), ainsi qu'un type de données appelé container qui permet d'effectuer des calculs et des opérations de chaînes sur des données pouvant aller virtuellement jusqu'à 2Go en taille.

Styles de codage hérités du Pascal et du C[modifier | modifier le code]

FutureBASIC permet d'introduire dans le code source des blocs de commentaires à la manière du C : /* remarque */

Il est possible également de définir des signets pour naviguer rapidement vers diverses sections du code.

Le programmeur peut utiliser alternativement certains opérateurs comme ++ -- == != += -= || &&

Les caractères des chaînes Pascal sont accessibles à la manière des éléments d'un tableau : a$[0] (octet de longueur); a$[1] (premier caractère de la chaîne a$).

Bien que le langage FutureBASIC supporte toujours l'ancien typage des variables au moyen d'un suffixe identificateur de type, il propose une alternative plus moderne au moyen de la clause AS :

Style ancien :

dim b` : dim s% : dim us%`: dim l& : etc.

Style moderne :

dim b as byte : dim s as short : dim us as unsigned short : dim l as long : etc.

Runtimes[modifier | modifier le code]

Grâce à la nature ouverte de ses fichiers de runtime, le langage FutureBASIC peut être amélioré par l'utilisateur avec ses propres routines, altéré par la directive OVERRIDE ou même corrigé en cas de bug qui n'aurait pas été détecté avant la mise en circulation du logiciel. Les runtimes principaux sont :

  • Appearance : ce runtime est recommandé pour la réalisation d'applications complètes et modernes.
  • Console : ce runtime est essentiellement utilisé pour tester des algorithmes, des petits bouts de code ou encore pour exécuter des calculs. Il fournit une interface utilisateur préprogrammée et simplifiée (une fenêtre de texte, une fenêtre graphique et une barre de menus de base).
  • BASIC standard : ce runtime hérité de l'ère 68K du Macintosh est présent pour assurer une meilleure compatibilité avec d'anciens programmes écrits en langage BASIC traditionnel.
  • Toolbox Mac : ce runtime est pratiquement exempt des mots-clés du BASIC, le programmeur doit utiliser exclusivement les fonctions et les procédures de la Toolbox du Macintosh pour créer des applications.

Ponts vers d'autres langages[modifier | modifier le code]

  • Le compilateur permet l'insertion en ligne de mnénoniques assembleur 68K et PPC. Exemples (tirés d'un fichier de runtime)

Assembleur 68K (non disponible avec FBtoC) :

#if  cpu68K
runtime "_MovePascalStr"
beginassem
     move.l   (SP)+,D1;Return Address
     move.l   (SP)+,A1       ;Dest Address
     move.l   (SP)+,A0;Src Address
     moveq    #0,D0
     move.b   (A0),D0;Byte Count
mlp1 move.b   (A0)+,(A1)+
     dbra     D0,mlp1
     move.l   D1,A0
     jmp      (a0)
endassem
return'MacsBug Label
end fn
#endif

Assembleur PPC (non disponible avec FBtoC) :

#if cpuPPC
local fn SysMoveString( Src&, Dst& )
beginassem
 lhz    r5,0(r3); len<<8 + 1st str byte
 srawi. r0,r5,9; len/2
 sth    r5,(r4)
 mtspr  ctr,r0
 beq    sysMoveString ; skip loop if len/2 = 0
sysMoveStringLoop
 lhzu   r0,2(r3)
 sthu   r0,2(r4)
 bc     16,0,sysMoveStringLoop ; bdnz
sysMoveString
endassem
end fn
#endif
  • Des scripts AppleScript peuvent être assemblés avec des instructions FutureBASIC, puis exécutés dynamiquement par l'application en cours d'exécution. Exemple :
route _toAppleScript 
print "return the path to me as string" 
route _toScreen  

long if usr ApplescriptRun( message$ ) = _noErr 
  print message$ 
end if
  • Sous Mac OS X, FutureBASIC permet d'invoquer des commandes UNIX. Exemple :
// affiche un calendrier pour l'année 2008  
open "UNIX",1,"cal 2008" 
dim a$

  do
   line input #1,a$
   print a$
 until eof(1)
  close 1 
  • FBtoC (uniquement) permet d'insérer du code C en ligne. L'exemple suivant de Steve Van Voorst est un petit programme entièrement écrit en C dans l'éditeur de FB5 :
/*
    Written by S.Van Voorst   {20130423}
*/

beginCDeclaration
// **** Globals ***** //
ControlRef pushRef, txtRef;
endC

beginCFunction
OSStatus myControlEventHandler( EventHandlerCallRef nextHandler, EventRef theEvent, void* userData )
{
  ControlRef c;

 GetEventParameter( theEvent, kEventParamDirectObject,  typeControlRef, NULL, sizeof( ControlRef ), NULL, &c );
  
  if ( c == pushRef ) {
   char s[] = "You hit the push button.";
   SetControlData( txtRef, kControlEditTextPart, kControlStaticTextTextTag, sizeof(s), &s[0]);
  }
 return eventNotHandledErr; 
}
endC

beginCFunction
void buildWnd ()
{
  WindowRef  wRef;
  WindowAttributes attributes;
  Rect r;
  ControlRef quitRef, txt2Ref;
  EventTypeSpec events[1];
  EventHandlerUPP handlerUPP;
  EventTargetRef theTarget;
  
  handlerUPP = 0;

  #define _wndL 30
  #define _wndT 100
  #define _wndR 630
  #define _wndB 430

  attributes = kWindowStandardDocumentAttributes | kWindowStandardHandlerAttribute | kWindowCompositingAttribute;

  SetRect( &r, _wndL, _wndT,  _wndR, _wndB );
  CreateNewWindow( kDocumentWindowClass, attributes, &r, &wRef );
  SetWindowTitleWithCFString( wRef, CFSTR("My C Window"));
  ShowWindow( wRef );
  
  // ***** Push Btn **** //
  SetRect( &r, 120, 80, 260, 100 );
  CreatePushButtonControl( wRef, &r, CFSTR("Push Me"), &pushRef );
  
  events[0].eventClass = kEventClassControl;
  events[0].eventKind = kEventControlHit;
  
  handlerUPP = NewEventHandlerUPP( myControlEventHandler );
  theTarget = GetControlEventTarget( pushRef );
  InstallEventHandler( theTarget, handlerUPP, 1, &events[0], NULL, NULL );

  // *** Static Text ***** //
   SetRect( &r, 30, 120, _wndR - 60, 160 );
  CreateStaticTextControl ( wRef, &r, CFSTR("Hello."),  NULL, &txtRef );
  
  // ****** EUTC ***** //
  SetRect( &r, 30, 180, _wndR - 60, 200 );
  CreateEditUnicodeTextControl ( wRef, &r, CFSTR("Welcome to Carbon with event handlers."),  0, NULL, &txt2Ref );

 //***** Quit Btn ***** //
  SetRect( &r, _wndR - _wndL - 160, _wndB - _wndT - 80, _wndR - _wndL - 60, _wndB - _wndT - 60 );
  CreatePushButtonControl( wRef, &r, CFSTR("Quit"), &quitRef );
  SetControlCommandID( quitRef, kHICommandQuit);
}
endC

beginCCode
  buildWnd();
  RunApplicationEventLoop();
endC

Limitations[modifier | modifier le code]

  • Outil RAD manquant

Le développement de PG PRO a été arrêté sur la route des évolutions successives du logiciel vers OS X. Bien qu'il soit toujours possible de créer des applications 68K et PPC (y compris compatibles Carbon) avec cet outil, son utilisation est hautement découragée. Les programmeurs doivent utiliser le logiciel Interface Builder d'Apple pour construire l'interface graphique de leurs applications.

Au débuts des années 2000, le CD livré avec les versions FB^3 de FutureBASIC contenait un runtime expérimental pour la programmation orientée objet; c'était un nouveau paradigme intéressant pour les programmeurs FB, toutefois ce runtime a disparu soudainement sans aucune explication.

  • Pas de support 64 bits

FutureBASIC ne supporte pas nativement le type de données sur 64 bits. Il y a néanmoins des techniques de programmation pour émuler cette caractéristique.

  • Compilation pour la plate-forme Macintosh uniquement

FutureBASIC supporte les architectures Macintosh sur Motorola 68000, PPC et Intel mais ne compile pas pour les systèmes d'exploitation Windows de Microsoft.

Références[modifier | modifier le code]

  1. Le profileur de FutureBASIC est un module d'analyse logiciel qui est compilé en même temps que le code source écrit par le programmeur et qui permet de tester les performances et l'efficacité du code exécutable créé par le compilateur pour éventuellement optimiser le code source afin d'en éliminer les goulets d'étranglement.
  2. Une brève histoire de la guerre des Basic sur la plate-forme Mac par Jonathan Hoyle pour MacCompanion.
  3. ZBasic 5 passé en revue par Dave Kelly pour MacTech magazine.
  4. FBI a apporté des améliorations importantes au langage BASIC, en encourageant les développeurs à utiliser les constantes nommées et les fonctions locales au lieu de sous-routines pour une meilleure structuration des programmes et l'écriture de code source réutilisable.
  5. Site Web de Staz Software,inc.
  6. FBII était dit 32bit-clean et il pouvait donc fonctionner depuis le Mac 128 jusqu'au Macintosh G5 en mode émulé.
  7. Program Generator est suffisamment souple pour permettre la création d'applications sophistiquées très rapidement pour les Macintosh prédatant Mac OS X. Sous Mac OS X, les programmeurs utiliseront à défaut le logiciel Interface Builder d'Apple.
  8. Une semaine plus tard l'édition européenne est sortie en France, elle contenait les versions anglaise (US), italienne, allemande (interrompue par la suite) et française. Il y existe aussi une édition en japonais.
  9. FB^3 se prononce en anglais FB cubed.
  10. Depuis FB^3, un runtime est constitué de fichiers inclus écrits en FutureBASIC qui sont compilés en même temps que les fichiers de code source écrits par le programmeur. Les runtimes contiennent diverses déclarations pour les structures, les constantes, les variables globales, les ressources, les fonctions et procédures qui constituent le langage FutureBASIC. Les principaux runtimes sont : BASIC standard, Appearance et Toolbox Mac.
  11. Le runtime Appearance permet un accès simplifié et quasi-intégral aux caractéristiques et fonctions de l'Appearance Manager de la Toolbox d'Apple.
  12. Site de base pour les graticiels FBtoC et FutureBASIC.