FutureBASIC

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é

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.

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.

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.

• 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