|
FutureBASIC
FutureBASIC est un environnement de développement gratuit en BASIC dédié au Macintosh d'Apple. 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 , 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 FutureBASICFutureBASIC 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[8] 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 [9], le résultat de leurs efforts est rendu public avec la sortie de FB^3[10], un environnement de développement considérablement amélioré incluant entre autres choses un compilateur séparé, plusieurs runtimes[11] (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[12] é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 . 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 , Staz Software annonce que FB4 est devenu graticiel et FBtoC[13] 1.0 est rendu public le même jour. FutureBASIC 5 (FB5) est mis en circulation en . 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 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 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 , 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 , FutureBASIC 5.7.6 et son compagnon FBtoC deviennent "open source" sous licence GPL. Processeurs et systèmes d'exploitation supportésFutureBASIC 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. SyntaxeFutureBASIC 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 structurelsLes fonctions définies par l'utilisateur (alias LOCAL FN dans FutureBASIC) ressemblent à celles des langages Pascal et C. Elles peuvent :
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 :
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éesFutureBASIC 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 CFutureBASIC 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. RuntimesGrâ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 :
Ponts vers d'autres langages
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
route _toAppleScript print "return the path to me as string" route _toScreen long if usr ApplescriptRun( message$ ) = _noErr print message$ end if
// 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
/*
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
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ébut 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.
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.
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
Information related to FutureBASIC |
|||||||||||||||||||||
