This page is also available in

Documentation

La documentation ci-dessous fait partie de la distribution de BeeBase. Elle est également disponible sous forme de PDF.

16. Programmation de BeeBase

Ce chapitre (le plus long de ce manuel) décrit le langage de programmation de BeeBase, ainsi que toutes les fonctions disponibles. En revanche, ce chapitre n'est pas conçu comme un guide général de programmation. Vous devez être familier avec les bases de la programmation et devez avoir déjà écrit quelques programmes simples (et fonctionnant correctement :-)).

16.1 Éditeur de programme

Pour saisir un programme dans un projet, ouvrez l'éditeur de programme en sélectionnant le menu `Programme - Modifier'. Si vous êtes configuré en code source interne (voir Code source), cela ouvre la fenêtre `Édition de programme' qui contient :

• un champ d'édition de texte où vous modifiez le programme du projet.

• un bouton `Compiler & fermer' pour compiler le programme et, en cas de réussite, sortir de l'éditeur de programme.

• un bouton `Compiler' pour compiler le programme. Si votre programme contient une erreur quelque part, alors une description de l'erreur est affichée dans le titre de la fenêtre et le curseur est positionné sur l'emplacement fautif.

• un bouton `Rétablir' qui annule tous les changements effectués depuis la dernière compilation réussie.

L'éditeur de programme est une fenêtre non modale, vous pouvez laisser la fenêtre ouverte et continuer à travailler avec le reste de l'application. Vous pouvez fermer l'éditeur à tout moment en cliquant sur le bouton de fermeture de sa fenêtre, si vous avez fait des changements depuis la dernière compilation réussie, alors une requête de sécurité vous demandera de confirmer la fermeture de la fenêtre.

Si vous avez configuré le menu `Programme - Code Source' sur `Externe' alors l'éditeur externe (voir Éditeur externe) est lancé avec le nom du fichier source externe lors de la sélection du menu `Programme - Modifier'. Cela vous permet d'éditer le programme dans votre éditeur de texte favori (voir Code source externe).

Vous pouvez également compiler le programme d'un projet sans ouvrir l'éditeur de programme en sélectionnant le menu `Programme - Compiler'. Cela peut être utile par exemple si vous avez fait des modifications dans un fichier d'inclusion externe et que vous désirez incorporer ces changements dans le programme du projet.

16.2 Code source externe

En choisissant le menu `Programme - Code Source - Externe' et en saisissant un nom de fichier, il est possible de rendre le code source du programme d'un projet accessible de l'extérieur. Cela vous permet de charger le code source du programme dans votre éditeur de texte favori pour programmer.

Si la compilation réussie, le programme compilé est intégré en tant que programme du projet et est utilisé lors de l'exécution des déclencheurs. Lorsque de la sauvegarde d'un projet, la dernière version du programme compilé avec succès est stockée dans le projet. Du coup, après la sauvegarde et la fermeture d'un projet, le fichier source externe n'est plus nécessaire. Il est possible d'indiquer si les fichiers sources externes inutiles doivent être effacés automatiquement en cochant le menu `Préférences - Nettoyer les sources externes'.

L'état du menu `Programme - Code source' est mémorisé avec le projet, ainsi lors de la réouverture d'un projet utilisant la fonctionnalité du code source externe, le fichier source externe est recréé automatiquement. Si le fichier externe existe déjà et est différent de la version stockée dans le projet, une requête de sécurité demande confirmation avant d'écraser le fichier.

Sur Amiga il est possible d'envoyer la commande compile au port ARexx de BeeBase depuis votre éditeur. BeeBase lit alors le fichier source externe, le compile et retourne le statut de la compilation ainsi qu'un éventuel message d'erreur contenant le nom du fichier, la ligne, la colonne et une description de l'erreur. Cela permet de positionner le curseur à l'emplacement exact où l'erreur de compilation s'est produite. Voir Compilation ARexx, pour plus de détails sur les valeurs de retour et le format des erreurs.

16.3 Préprocesseur

Les programmes BeeBase sont analysés par un préprocesseur de manière similaire à ce qui est fait sur les programmes C. Cette section décrit comment utiliser les directives du préprocesseur.

Toutes les directives débutent par le symbole dièse # qui doit également être le premier caractère de la ligne, des caractères d'espacement ou de tabulation peuvent cependant apparaître après le #.

16.3.1 #define

#define nom chaîne

Définit un nouveau symbole ayant le nom et le contenu spécifiés. La chaîne peut être n'importe quel texte incluant des espaces et se terminant à la fin de la ligne. Dans le cas où chaîne ne pourrait pas tenir sur une seule ligne, il est possible d'utiliser les lignes suivantes en utilisant le caractère anti-slash \ à la fin de chacune des lignes (sauf la dernière). Si le symbole nom apparaît dans la suite du code source il est alors remplacé par la valeur chaîne.

Exemple : `(PRINTF "X vaut %i" X)' affiche `X vaut 1' (Les occurrences de nom dans les chaînes ne sont pas modifiées.)

Le remplacement des symboles définis est réalisé syntaxiquement, ce qui signifie que vous pouvez remplacer des symboles par n'importe quel texte, p. ex. vous pouvez définir votre propre syntaxe comme le montre l'exemple suivant :

#define BEGIN (
#define END )

BEGIN defun test ()
        ...
END

La chaîne de substitution d'une définition peut faire référence à d'autres symboles définis par la directive #define ce qui autorise des définitions imbriquées. Cependant un maximum de 16 définitions imbriquées est autorisé.

Voir aussi #undef, #ifdef, #ifndef.

16.3.2 #undef

#undef nom

Supprime la définition du symbole nom. Si nom n'est pas défini, rien ne se passe.

Voir aussi #define, #ifdef, #ifndef.

16.3.3 #include

#include file

Lit le contenu de file (une chaîne encadrée par des guillemets doubles). BeeBase recherche le fichier à charger dans le répertoire courant et dans le répertoire indiqué dans les préférences (voir Répertoire d'inclusion). Le contenu du fichier est alors traité par le compilateur comme s'il faisait partie du code source courant.

Un fichier externe peut inclure un ou plusieurs autres fichiers externes, avec cependant une limite maximum de 16 directives #include imbriquées. Pour éviter d'inclure plusieurs fois les fichiers il est possible d'utiliser la compilation conditionnelle.

Lors de l'externalisation de code sources, il convient d'être attentif : le débogage et la localisation des erreurs sont plus difficiles dans les fichiers externes. Il est préférable de n'externaliser que les codes sources bien testés et indépendants du projet.

16.3.4 #if

#if expr-const

Si le résultat de l'expression constante spécifiée est différent de NIL alors le texte présent jusqu'à la directive #else, #elif ou #endif correspondante est utilisé pour la compilation, sinon (c.-à-d. la valeur de l'expression est NIL) le texte jusqu'à la directive #else, #elif ou #endif correspondante est ignoré pour la compilation.

Pour le moment il n'est possible d'utiliser que TRUE et NIL comme expression constante.

Voir aussi #ifdef, #ifndef, #elif, #else, #endif.

16.3.5 #ifdef

#ifdef nom

Si le symbole spécifié a été défini par une directive #define alors le texte suivant jusqu'à la directive #else, #elif ou #endif correspondante est pris en compte dans la compilation, sinon il est ignoré.

Voir aussi #if, #ifndef, #elif, #else, #endif.

16.3.6 #ifndef

#ifndef nom

Si le symbole spécifié n'a pas été défini par une directive #define alors le texte suivant jusqu'à la directive #else, #elif ou #endif correspondante est pris en compte dans la compilation, sinon il est ignoré.

Voir aussi #if, #ifdef, #elif, #else, #endif.

16.3.7 #elif

#elif expr-const

N'importe quel nombre de directives #elif peut apparaître entre une directive #if, #ifdef ou #ifndef et sa directive #else ou #endif correspondante. Les lignes suivant la directive #elif sont prises en compte dans la compilation seulement si toutes les conditions suivantes sont remplies :

• L'expression constante dans la directive #if précédente a été évaluée à NIL, le symbole de la directive #ifdef précédente n'était pas défini ou le symbole de la directive #ifndef précédente était défini.

• L'expression constante de chacune des directives #elif intermédiaires a été évaluée à NIL.

• L'expression constante a été évaluée comme différente de NIL.

Si toutes les conditions précédentes sont remplies alors les directives #elif et #else suivantes sont ignorées jusqu'au #endif correspondant.

Voir aussi #if, #ifdef, #ifndef, #else, #endif.

16.3.8 #else

#else

Inverse le sens de la directive conditionnelle qui était active. Si la directive conditionnelle précédente indiquait que les lignes devaient être prises en compte, alors les lignes entre le #else et le #endif correspondant sont ignorées. Si la directive conditionnelle précédente indiquait que les lignes devaient être ignorées, alors les lignes suivantes sont prises en compte dans la compilation.

Les directives conditionnelles et les directives #else correspondantes peuvent être imbriquées jusqu'à un niveau maximum de 16 directives conditionnelles imbriquées.

Voir aussi #if, #ifdef, #ifndef, #elif, #endif.

16.3.9 #endif

#endif

Termine une section de lignes introduites par l'une des directives de compilation conditionnelle #if, #ifdef ou #ifndef. Chacune de ces directives doit avoir un #endif correspondant.

Voir aussi #if, #ifdef, #ifndef, #elif, #else.

16.4 Langage de programmation

BeeBase utilise un langage de programmation dont la syntaxe est proche du lisp. En fait, plusieurs constructions et fonctions ont été adoptées du lisp standard. Cependant BeeBase n'est pas totalement compatible avec du lisp standard. De nombreuses fonctions manquent (p. ex. les commandes de destruction) et le sens de certaines autres commandes est différent (p. ex. la commande return).

16.4.1 Pourquoi Lisp ?

L'avantage d'un langage dans le style de Lisp est qu'il est possible de programmer à la fois de manière fonctionnelle et impérative. Les langages fonctionnels sont de plus en plus populaires dans les applications mathématiques. Le concept de base des langages fonctionnels est l'utilisation des expressions. Les fonctions sont définies de "manière mathématique" et la récursivité est beaucoup utilisée.

Les langages de programmation impératifs (p. ex. C, Pascal, Modula) utilisent une description pas à pas des instructions exécutées par la machine. Ici, c'est l'état qui est le concept de base (p. ex. variables) et un programme calcule ses sorties en passant d'un état à un autre (p. ex. en assignant des valeurs à des variables).

Lisp combine ces deux techniques et par conséquent permet de choisir la façon dont on souhaite implémenter les choses. On utilise alors la technique qui correspond le mieux à un problème spécifique ou celle que l'on préfère.

16.4.2 Syntaxe Lisp

Une expression lisp est soit une constante, soit une variable, soit une application de fonction. Pour appeler une fonction, lisp utilise une notation préfixée. La fonction et ses paramètres sont encadrés par des parenthèses. Par exemple, pour ajouter deux valeurs a et b, on écrit :

(+ a b)

Toutes les expressions retournent une valeur, ainsi dans l'exemple précédent la somme de a et b est renvoyée. Les expressions peuvent être imbriquées, c'est à dire qu'il est possible de placer une expression en tant que sous expression d'une autre.

L'évaluation des fonctions est effectuée en utilisant le principe d'appel par valeur, cela signifie que les arguments sont évalués avant d'appeler la fonction.

Sauf si indication contraire, toutes les fonctions sont strictes, c'est à dire que tous les arguments de la fonction sont évalués avant que la fonction ne soit appelée. Certaines fonctions cependant sont non strictes, p. ex. IF, AND et OR. Ces fonctions peuvent ne pas évaluer tous leurs arguments.

16.4.3 Types de programmes

BeeBase distingue trois types de programmes. Le premier est le programme du projet. Dans un programme de ce type, il est possible de définir des fonctions et des variables globales. Les fonctions peuvent être utilisées comme déclencheurs pour les champs. La saisie d'un programme de projet est réalisée dans l'éditeur de programme (voir Éditeur de programme).

Le deuxième type correspond aux programmes de requête où il n'est possible de saisir que des expressions. Une expression est autorisée à référencer des variables globales et à appeler des fonctions définies dans le programme du projet. Cependant, il est impossible de définir de nouvelles fonctions ou variables globales dans un tel programme. On saisie un programme de requête par l'intermédiaire de l'éditeur de requête (voir Éditeur de requêtes).

Le troisième type représente les expressions de filtrage. Ici, il est uniquement possible de saisir des expressions contenant des appels à des fonctions BeeBase prédéfinies. Toutes les fonctions prédéfinies ne sont pas disponibles, seules celles n'ayant pas d'effet de bord, p. ex. vous ne pouvez pas utiliser une fonction qui écrit des données dans un fichier. Les expressions de filtrage sont saisies dans la fenêtre de modification de filtrage (voir Modifier les filtres).

16.4.4 Nomenclature

Dans un programme BeeBase, il est possible de définir des symboles tels que des fonctions et des variables globales ou locales. Les noms de ces symboles doivent suivre les conventions suivantes :

• Le premier caractère d'un nom doit être une lettre minuscule, cela différencie les symboles de programme des noms de table et de champs.

• Les caractères suivants peuvent être n'importe quelle lettre, chiffre ou caractère de soulignement. Les autres caractères, comme les umlauts allemands ne sont pas autorisés.

16.4.5 Accéder aux enregistrements

Pour accéder aux tables et aux champs dans un programme BeeBase, vous devez spécifier un chemin pour les atteindre. Un chemin est une liste de composants séparés par des points, où chaque composant est le nom d'une table ou d'un champ.

Les chemins peuvent être soit relatifs, soit absolus. Les chemins absolus sont reconnaissables à la première composante de leur nom qui est le nom de table, suivi par une liste de champs se terminant par le champ à atteindre. Par exemple le chemin absolu `Personne.Nom' accède au champ `Nom' de l'enregistrement courant de la table `Personne', de même le chemin absolu `Personne.Pere.Nom' accède au champ `Nom' de l'enregistrement référencé par le champ `Pere' (un champ de type Référence vers la table `Personne').

Les chemins relatifs possèdent déjà une table courante à laquelle ils se rapportent. Par exemple dans une expression de filtrage, la table courante est la table sur laquelle porte le filtre. Le chemin relatif pour un champ de la table courante est simplement son nom. Pour les champs qui ne sont pas directement accessibles via la table courante, mais indirectement via des champs de référence, les mêmes règles que pour les chemins absolus s'appliquent.

Il n'est pas toujours évident si un chemin donné est relatif ou absolu p. ex. supposons que nous soyons en train d'écrire une expression de filtrage pour la table `Foo' qui dispose d'un champ `Bar' mais qu'il existe également une table `Bar' ; dans ce cas saisir `Bar' est ambigu : de quoi parle t'on, de la table ou du champ ? Pour cette raison, les chemins sont tout d'abord traités comme étant relatifs. Si aucun champ n'est trouvé de cette manière, alors le chemin est traité comme étant absolu, dans notre exemple, le champ sera préféré.

Et si nous désirons accéder à la table dans notre exemple ? Dans ce cas, le chemin doit être considéré comme absolu, pour indiquer qu'un chemin est absolu il faut ajouter deux doubles points devant le chemin. Dans notre exemple il faudrait taper `::Bar' pour accéder à la table.

Pour mieux comprendre les chemins et leur sémantique, considérons dans l'exemple précédent que le champ `Bar' de la table `Foo' est une référence vers la table `Bar' qui contient un champ `Nom'. Maintenant, il est possible d'accéder au champ `Nom' en tapant `Bar.Nom' ou `::Bar.Nom'. Les deux expressions ont une signification différente. `::Bar.Nom' indique de prendre l'enregistrement courant de `Bar' et de retourner la valeur du champ `Nom' de cet enregistrement, tandis que `Bar.Nom' prend l'enregistrement courant de la table `Foo', extrait du champ `Bar', l'enregistrement référencé, et récupère la valeur de son champ `Nom'.

Pour donner un exemple encore plus complet, considérons que la table `Bar' dispose de deux enregistrements. L'un contient `Ralph' et l'autre contient `Steffen' dans le champ `Nom'. Le premier enregistrement est l'enregistrement courant. De plus, la table `Foo' dispose d'un enregistrement (que l'on considère comme étant le courant) dont le champ `Bar' référence le deuxième enregistrement de la table `Bar'. Maintenant `::Bar.Nom' est évalué en `Ralph' et `Bar.Nom' en `Steffen'.

16.4.6 Types de données pour programmer

Le langage de programmation de BeeBase connaît les types de données suivants :

Type        Description

Bool        toutes les expressions, les expressions différentes de NIL
            sont considérées comme TRUE.

Integer     entier long sur 32 bits, les valeurs de choix sont converties
            automatiquement en entiers

Real        double sur 64 bits

String      chaîne de caractères de longueur arbitraire

Memo        comme une chaîne, mais répartie sur plusieurs lignes

Date        valeur de date

Time        valeur horaire

Record      pointeur sur un enregistrement

File        descripteur de fichier pour la lecture / écriture

List        liste d'éléments, NIL est la liste vide.

Tous les types de données supportent la valeur NIL.

16.4.7 Constantes

Le langage de programmation de BeeBase gère les expressions constantes qui peuvent être saisies en fonction de leur type :

Type        Description

Integer     Les constantes entières dans l'intervalle -2147483648
            2147483647 peuvent être indiquées telles quelles. Les
            valeurs débutant par 0 sont interprétées comme des
            nombres octaux, tandis que celles débutant par 0x
            sont des nombres hexadécimaux.

Real        Les constantes réelles dans l'intervalle -3.59e308
            3.59e308 peuvent être spécifiées comme habituellement,
            au format scientifique ou non. En l'absence de point
            décimal le nombre peut être traité comme un entier
            au lieu d'un réel.

String      Les chaînes constantes sont une suite arbitraire de caractères
            encadrée par des guillemets doubles. Par ex. "chaîne exemple".
            Entre les guillemets doubles, tout caractère peut apparaître
            hormis les caractères de contrôle et les retours à la ligne. 
            Cependant des codes d'échappement spéciaux
            permettent de saisir ces caractères :

                \n              retour à la ligne (nl)
                \t              tabulation horizontale (ht)
                \v              tabulation verticale (vt)
                \b              retour arrière (bs)
                \r              retour chariot (cr)
                \f              saut de page (ff)
                \\              antislash
                \"              guillemet double
                \e              code d'échappement 033
                \nnn            caractère ayant le code octal nnn
                \xnn            caractère ayant le code hexa nn

Memo        Comme pour les chaînes constantes (String).

Date        Les valeurs constantes de date peuvent être spécifiées dans l'un des
            formats `JJ.MM.AAAA', `MM/JJ/AAAA' ou `AAAA-MM-JJ', où
            `JJ', `MM' et `AAAA' sont des valeurs de deux ou
            quatre chiffres représentant respectivement le jour, le mois et
            l'année de la date.

Time        Les valeurs constantes horaires peuvent être spécifiées au format
            `HH:MM:SS', où `HH' représente les heures, `MM'
            les minutes et `SS' les secondes.

Pour quelques autres valeurs constantes prédéfinies, voir Constantes prédéfinies.

16.4.8 Convention typographique

Le reste de ce chapitre est consacré à la description de toutes les commandes et fonctions disponibles pour programmer dans BeeBase. La syntaxe suivante est utilisée pour la description des commandes :

• le texte entre crochets [] est optionnel. Si vous omettez le texte entre crochet, une valeur par défaut est utilisée.

• du texte séparé par une barre verticale | indique plusieurs options, p. ex. `a | b' signifie que vous pouvez spécifier soit `a' soit `b'.

• le texte écrit dans une police telle que var indique un paramètre qui est remplacé par une autre expression.

• les points de suspension ... indiquent que d'autres expressions peuvent suivre.

• tout autre texte est obligatoire.

16.5 Définition de commandes

Cette section liste les commandes permettant de définir des fonctions et des variables globales. Ces commandes ne sont disponibles que dans les programmes de projet.

16.5.1 DEFUN

DEFUN définit une fonction ayant le nom spécifié, une liste d'arguments passés à la fonction et une liste d'expressions à évaluer.

(DEFUN nom (liste-var) expr ...)

Le nom de la fonction doit commencer par une lettre minuscule, suivi d'autres lettres, chiffres ou caractères de soulignement (voir Nomenclature).

Les paramètres liste-var spécifient les arguments de la fonction :

liste-var: var1 ...

où var1 ... sont les noms des arguments. Ces noms doivent suivre les mêmes règles de nommage que ceux des fonctions.

Il est également possible de spécifier les type des arguments (voir Spécificateurs de type).

La fonction exécute les expressions expr, ... une par une et retourne la valeur de la dernière. La fonction peut appeler d'autres fonctions y compris elle-même. L'appel d'une fonction définie par l'utilisateur est identique à l'appel d'une fonction prédéfinie.

Par exemple pour compter le nombre d'arguments d'une liste, vous pouvez définir la fonction suivante :

(DEFUN len (l)
    (IF (= l NIL)
        0
        (+ 1 (len (REST l)))
    )
)

Les fonctions définies par DEFUN sont affichées dans les listes déroulantes des fenêtres liées aux tables et aux champs (voir Créer des tables) et Créer des champs).

Cette commande n'est disponible que dans les programmes de projet.

Voir aussi DEFUN*, DEFVAR.

16.5.2 DEFUN*

DEFUN* est la version étoilée de DEFUN et a le même effet que DEFUN (voir DEFUN). La seule différence réside dans le fait que les fonctions définies avec DEFUN* ne sont pas affichées dans les listes déroulantes de création et de modification de table et de champ. Cependant, il est toujours possible d'entrer le nom de la fonction dans les champs texte correspondants.

Cette commande est uniquement disponible dans les programmes de projet.

Voir aussi DEFUN, DEFVAR.

16.5.3 DEFVAR

(DEFVAR var [expr])

Définit une variable globale ayant comme valeur initiale expr ou NIL si expr est absent. Les noms des variables doivent commencer par une lettre minuscule suivie de lettres, chiffres ou caractères souligné (voir Nomenclature).

Il est également possible d'ajouter un spécificateur de type au nom de la variable (voir Spécificateurs de type).

DEFVAR est uniquement disponible dans les programmes de projet. Toutes les commandes DEFVAR doivent être placées avant la définition de toutes les fonctions.

Après l'exécution d'un déclencheur (lorsque BeeBase rend la main à l'interface graphique), toutes les variables globales perdent leur contenu. Elles sont réinitialisées avec leur valeur initiale expr lors de la prochaine invocation d'un déclencheur. Si ce n'est pas voulu, il faut utiliser la commande DEFVAR* (voir DEFVAR*) qui permet de préserver la valeur des variables globales entre les appels de programme.

Il est conseillé de limiter (ou d'éviter complètement) l'utilisation des variables globales, car chacune doit être initialisée (et expr doit être évalué s'il est fourni) à chaque fois qu'un déclencheur est appelé de l'extérieur.

Exemple: `(DEFVAR x 42)' définit une variable globale `x' ayant la valeur 42.

Il existe quelques variables globales prédéfinies dans BeeBase (voir Variables prédéfinies).

Voir aussi DEFVAR*, DEFUN, DEFUN*, LET.

16.5.4 DEFVAR*

(DEFVAR* var [expr])

DEFVAR* a le même effet que la commande DEFVAR (voir DEFVAR) sauf qu'une variable définie avec DEFVAR* ne perd pas sa valeur à la fin du programme.

Lors de la première invocation du programme, var est initialisée avec expr ou NIL si expr est omis. Les appels suivants du programme ne réévalueront pas expr, mais utiliseront la valeur de var de l'appel précédent. De cette manière, il est possible de transférer l'information d'un appel de programme à un autre sans avoir à stocker les données dans un fichier externe ou une table de la base de données. Il faut cependant noter que toutes les variables globales définies avec DEFVAR* perdent leur valeur lorsque le programme du projet est recompilé. Pour conserver de manière permanente des informations, il est préférable d'utiliser un champ (éventuellement caché) d'une table.

Voir aussi DEFVAR, DEFUN, DEFUN*, LET.

16.6 Structures de contrôle

Cette section liste les fonctions contrôlant le programme, p. ex. les fonctions définissant les variables locales, les fonctions de boucle, les fonctions d'exécution conditionnelle, et d'autres.

16.6.1 PROGN

Pour évaluer plusieurs expressions l'une à la suite de l'autre, il est possible d'utiliser la construction PROGN.

([expr ...])

exécute expr ... une à une. Renvoie le résultat de la dernière expression (ou NIL si aucune expression n'a été spécifiée). En Lisp cette construction est connue comme (PROGN [expr ...]).

Exemple : `(1 2 3 4)' retourne 4.

Voir aussi PROG1.

16.6.2 PROG1

Une autre manière, hormis la fonction PROGN, pour évaluer plusieurs expressions séquentiellement est l'expression PROG1.

(PROG1 [expr ...])

exécute expr ... et renvoie la valeur de la première expression (ou NIL si aucune expression n'a été spécifiée).

Exemple : `(PROG1 1 2 3 4)' retourne 1.

Voir aussi PROGN.

16.6.3 LET

LET définit un nouveau bloc de variables locales. Ceci est utile, p. ex. pour définir les variables locales d'une fonction. La syntaxe est

(LET (liste-var) expr ...)

où liste-var est une liste de variables locales.

liste-var : varspec ...

varspec : (var expr) | var

Ici var est le nom d'une variable et doit commencer par une lettre minuscule, suivie d'autres lettres, chiffres ou caractères soulignés (voir Nomenclature).

Dans le cas de l'utilisation de (var expr), la nouvelle variable est initialisée par l'expression spécifiée. Dans le cas contraire, la nouvelle variable est positionnée à NIL.

Il est également possible d'ajouter des spécificateurs de type aux variables (voir Spécificateurs de type).

Après l'initialisation de toutes les variables les expressions de la liste expr ... sont évaluées et la valeur de la dernière est renvoyée.

Par exemple, l'expression LET suivante

(LET ((x 0) y (z (+ x 1)))
    (+ x z)
)

renvoie 1.

Voir aussi DOTIMES, DOLIST, DO, DEFVAR.

16.6.4 SETQ

La fonction SETQ affecte des valeurs à des variables, des champs et des tables.

(SETQ lvalue1 expr ...)

Affecte à lvalue1 la valeur de l'expression expr. Les points de suspension indiquent la possibilité d'affecter d'autres parties gauches (NDT: en anglais lvalue est l'abréviation de left value, c'est à dire littéralement valeur de gauche on utilise plutôt partie gauche). Une partie gauche est une variable, un champ d'une table ou une table. Dans le cas d'une variable, elle doit avoir été préalablement définie (p. ex. en utilisant l'expression LET).

Affecter la valeur à une table correspond à positionner son pointeur de programme ou d'interface : `(SETQ Table expr)' positionne le pointeur d'enregistrement du programme de Table à la valeur expr, `(SETQ Table* expr)' positionne son pointeur d'enregistrement de l'IHM et rafraîchit l'affichage. Pour plus d'informations à propos des pointeurs d'enregistrement de programme et d'IHM, voir Tables.

SETQ retourne la valeur de la dernière expression.

Exemple : `(SETQ a 1 b 2)' affecte 1 à la variable `a', 2 à la variable `b' et renvoie 2.

Voir aussi SETQ*, SETQLIST, LET, DEFVAR, Tables, Sémantique des expressions.

16.6.5 SETQ*

SETQ* est la version étoilée de SETQ (voir SETQ) et a les mêmes effets. La différence réside dans le fait que lors de l'affectation à un champ, SETQ* appelle le déclencheur de ce champ (voir Déclencheur de champ) au lieu de lui affecter directement la valeur. Dans le cas où aucun déclencheur ne serait associé à un champ, SETQ* se comporte comme SETQ et affecte simplement la valeur au champ.

Exemple : `(SETQ* Table.Field 0)' appelle le déclencheur de `Table.Field' avec un argument à 0.

Attention : Avec cette fonction il est possible d'écrire des boucles infinies, p. ex. si un déclencheur est défini pour un champ et que ce déclencheur utilise SETQ* pour affecter la valeur.

Voir aussi SETQ, SETQLIST*, LET, DEFVAR.

16.6.6 SETQLIST

SETQLIST est similaire à SETQ (voir SETQ) mais utiliser une liste pour définir plusieurs parties gauches pour les éléments de la liste.

(SETQLIST lvalue1 ... list-expr)

Sets lvalue1 to the first element of list-expr. The dots indicate assignments for further lvalues to the corresponding elements in the list. The number of lvalues must be equal to the length of the list, otherwise program execution terminates with an error message.

Définit lvalue1 sur le premier élément de list-expr. Les points indiquent les affectations pour d'autres parties gauches aux éléments de la liste correspondants. Le nombre de partie gauche doit être égal à la longueur de la liste, sinon l'exécution du programme se termine par un message d'erreur.

Les mêmes règles s'appliquent comme pour SETQ (voir SETQ). Par exemple, les deux versions suivantes des variables de réglage sont équivalentes :

(SETQLIST a b c (LIST 1 2 3))

(SETQ a 1 b 2 c 3)

SETQLIST retourne la valeur de list-expr.

Voir aussi SETQLIST*, SETQ.

16.6.7 SETQLIST*

SETQLIST* est la version étoilée de SETQLIST (voir SETQLIST) et a les mêmes effets.

La différence est que lors de l'attribution d'une valeur à un champ, SETQLIST* appelle le déclencheur de ce champ (voir Déclencheur de champ) au lieu d'attribuer directement la valeur. Dans le cas où aucun déclencheur n'a été spécifié pour un champ, SETQLIST* se comporte comme SETQLIST et attribue simplement la valeur au champ.

Voir aussi SETQLIST, SETQ*.

16.6.8 FUNCALL

FUNCALL est utilisé pour appeler une fonction avec des arguments.

(FUNCALL fonc-expr [expr ...])

Appelle la fonction fonc-expr avec les arguments spécifiés. L'expression fonc-expr peut être n'importe quelle expression dont la valeur est une fonction utilisateur ou prédéfinie, p. ex. une variable contenant la fonction à appeler. Si le nombre d'argument est incorrect, un message d'erreur est généré.

FUNCALL renvoie la valeur de retour de l'appel à la fonction ou NIL si fonc-expr est NIL.

Pour plus d'informations à propos des expressions fonctionnelles, voir Paramètres fonctionnels.

Voir aussi APPLY.

16.6.9 APPLY

APPLY est utilisé pour appliquer une fonction à une liste d'arguments.

(APPLY fonc-expr [expr ...] liste-expr)

Applique la fonction fonc-expr à une liste créée en associant les arguments expr ... à liste-expr. En d'autres termes : appelle la fonction fonc-expr avec les arguments expr ... et liste-expr étendue à ses éléments de liste.

L'expression fonc-expr peut être n'importe quelle expression dont la valeur est une fonction utilisateur ou prédéfinie, p. ex. une variable contenant la fonction à appeler. Le dernier argument, liste-expr, doit être une liste valide ou NIL, dans le cas contraire un message d'erreur est généré. Si le nombre d'arguments n'est pas correct, une erreur survient.

APPLY renvoie la valeur de retour de l'appel de la fonction ou NIL si fonc-expr est NIL.

Pour plus d'informations à propos des expressions fonctionnelles, voir Paramètres fonctionnels.

Exemple : `(APPLY + 4 (LIST 1 2 3))' renvoie 10.

Voir aussi FUNCALL.

16.6.10 IF

IF est un opérateur conditionnel.

(IF expr1 expr2 [expr3])

L'expression expr1 est évaluée. Si son résultat n'est pas NIL, alors la valeur de expr2 est retournée, sinon c'est la valeur de expr3 (ou NIL en cas d'absence).

Cette fonction n'est pas stricte, c'est à dire qu'une seule des expressions expr2 ou expr3 est évaluée.

Voir aussi CASE, COND.

16.6.11 CASE

CASE est similaire à l'instruction switch du langage C.

(CASE expr [choix ...])

Ici expr est l'expression de sélection et choix ... des paires composées de :

choix: (valeur [expr ...])

où valeur est une instruction ou une liste d'instructions et expr ... les expressions à exécuter si l'une des expressions du choix est remplie.

L'expression CASE évalue d'abord expr. Puis chaque paire de choix est testée pour vérifier si elle (ou l'une des expressions de la liste) correspond à l'expression évaluée. Si une expression de choix valide est trouvée, alors les expressions correspondantes sont exécutées et la valeur de la dernière expression est renvoyée. Si aucun choix ne convient, NIL est retourné.

Exemple : `(CASE 1 ((2 3 4) 1) (1 2))' retourne 2.

Voir aussi IF, COND.

16.6.12 COND

COND est, comme IF, un opérateur conditionnel.

(COND [(test-expr [expr ...]) ...])

COND teste la première expression de chaque liste une à une. Pour la première qui ne renvoie pas NIL, les expressions associées expr ... sont évaluées et la valeur de la dernière est retournée.

Si toutes les expressions testées retournent NIL, alors la valeur de retour de COND sera également NIL.

Exemple

(COND ((> 1 2) "1 > 2")
      ((= 1 2) "1 = 2")
      ((< 1 2) "1 < 2")
)

retourne "1 < 2".

Voir aussi IF, CASE.

16.6.13 DOTIMES

Pour des boucles simples, la commande DOTIMES est utilisable.

(DOTIMES (nom entier-expr [résultat-expr ...]) [boucle-expr ...])

Ici, nom est le nom d'une nouvelle variable qui sera utilisée dans la boucle. Le nom doit commencer par une lettre minuscule, suivie par d'autres lettres, chiffres ou caractères souligné (voir Nomenclature).

Le nombre d'exécution de la boucle est indiqué par entier-expr. Dans résultat-expr ... il est possible de donner des expressions qui seront exécutées après la dernière boucle. boucle-expr correspond au corps de la boucle, c'est à dire les expressions qui sont évaluées dans chaque exécution de la boucle.

Avant d'exécuter la boucle, DOTIMES calcule la valeur de entier-expr pour déterminer le nombre d'exécution de la boucle. entier-expr n'est évaluée qu'une seule fois au début de la boucle et doit retourner une valeur entière. Ensuite, DOTIMES modifiera la valeur de la variable de boucle à chaque exécution de la boucle de 0 à entier-expr-1. Tout d'abord, la variable est initialisée à zéro puis comparée à la valeur de expr pour voir si elle est déjà supérieure ou égale. Si entier-expr est négative ou NIL ou si elle est supérieure ou égale à la valeur de expr alors la boucle se termine et les expressions de résultat sont évaluées. Dans le cas contraire, les expressions de la boucle sont évaluées et la variable est incrémentée de un, puis l'exécution revient au test d'arrêt et, éventuellement continue l'exécution de la boucle.

L'expression DOTIMES retourne la valeur de la dernière expression de résultat ou NIL si aucune expression de résultat n'a été donnée.

Exemple

(DOTIMES (i 50 i) (PRINT i))

Affiche les nombres de 0 à 49 et retourne la valeur 50.

Voir aussi DOLIST, DO, FOR ALL, LET.

16.6.14 DOLIST

Pour boucler sur des listes, l'expression DOLIST peut être utilisée.

(DOLIST (nom liste-expr [résultat-expr ...]) [boucle-expr ...])

Ici, nom est le nom d'une nouvelle variable qui sera utilisée dans la boucle. Le nom doit commencer par une lettre minuscule, suivie par d'autres lettres, chiffres ou caractères souligné (voir Nomenclature).

liste-expr spécifie la liste sur laquelle la boucle doit s'exécuter, résultat-expr ... sont des expressions qui seront évaluées après la dernière boucle, et boucle-expr ... correspond au corps de la boucle.

Avant d'exécuter la boucle, DOLIST calcule la valeur de liste-expr. Cette expression n'est évaluée qu'une seule fois au démarrage de la boucle et doit retourner une valeur de type liste. Ensuite, DOTIMES positionnera la variable de boucle à chacun des noeuds de la liste, un à chaque exécution de la boucle. Tout d'abord, la variable est initialisée au premier noeud de la liste. Si la liste est vide (NIL) alors la boucle se termine et les expressions de résultat sont évaluées. Dans le cas contraire, les expressions de la boucle sont évaluées et la variable est positionnée sur le noeud suivant de la liste, puis l'exécution revient au test d'arrêt et, éventuellement coutinue l'exécution de la boucle.

L'expression DOLIST retourne la valeur de la dernière expression de résultat ou NIL si aucune expression de résultat n'a été donnée.

Exemple

(DOLIST (i (SELECT * FROM Comptes)) (PRINT i))

Affiche tous les enregistrements de la table `Comptes' et retourne NIL.

Voir aussi DOTIMES, DO, FOR ALL, LET.

16.6.15 DO

L'expression DO permet de programmer des boucles arbitraires.

(DO ([binding ...]) (terminaison-expr [résultat-expr ...]) [boucle-expr ...])

où binding ... est une déclaration de variable locale à la boucle, each of chacune ayant :

• un nouveau nom de variable (qui sera initialisé à NIL)

• une liste de la forme : (nom init [pas]) où nom est le nom de la nouvelle variable, init est la valeur initiale de cette variable et pas est l'expression de pas (NDT: c'est à dire que c'est elle qui modifie la valeur de la variable d'une exécution de boucle à une autre).

De plus terminaison-expr est l'expression du test d'arrêt, résultat-expr ... les expressions du résultat (NIL en cas d'absence) et boucle-expr ... correspond au corps de la boucle.

L'expression DO commence par initialiser toutes les variables locales avec leur valeur initiale, ensuite elle examine les expressions de terminaison. Si celles-ci retournent TRUE la boucle est arrêtée et les expressions de résultat sont évaluées, et la valeur de la dernière est retournée. Dans le cas contraire, le corps de la boucle (boucle-expr ...) est exécutée et chaque variable est mise à jour par la valeur de son expression de pas. Ensuite l'exécution teste la condition d'arrêt et ainsi de suite.

Exemple

(DO ((i 0 (+ i 1))) ((>= i 5) i) (PRINT i))

Affiche les valeurs 0, 1, 2, 3 et 4 et renvoie la valeur 5. Bien sûr c'est une façon un peu compliquée d'écrire une simple boucle FOR. Par ailleurs il existe une version plus simple, l'expression DOTIMES.

Voir aussi DOTIMES, DOLIST, FOR ALL, LET.

16.6.16 FOR ALL

L'expression FOR ALL est utilisée pour boucler sur une liste d'enregistrements.

(FOR ALL table-liste [WHERE cond-expr] [ORDER BY ordre-liste] DO expr ...)

Ici, table-liste est une liste de tables séparées par des virgules, cond-expr une expression à valider pour chaque enregistrement, ordre-liste une liste d'expressions séparées par des virgules pour ordonner les enregistrements, et expr ... les expressions à exécuter pour chaque enregistrement.

FOR ALL commence par générer la liste de tous les enregistrements pour lesquels le corps de la boucle devra être exécuté. C'est réalisé de la même manière que dans l'expression SELECT. voir SELECT pour plus d'informations sur la façon dont cette liste est générée. Pour chacun des éléments de cette liste, le corps de la boucle expr ... est exécuté.

Par exemple, faire la somme d'un champ d'une table peut être réalisé de la manière suivante :

(SETQ sum 0)
(FOR ALL Comptes DO
    (SETQ sum (+ sum Comptes.Solde))
)

L'expression FOR ALL renvoie NIL.

Voir aussi SELECT, DOTIMES, DOLIST, DO.

16.6.17 NEXT

NEXT peut être utilisé pour contrôler les boucles DOTIMES, DOLIST, DO et FOR ALL.

Un appel à NEXT dans le corps d'une boucle fera passer à la prochaine itération de la boucle. Cela peut être utilisé pour sauter des itérations de boucle sans intérêt, comme dans l'exemple suivant :

(FOR ALL Table DO
    (IF pas-intéressé-par-enregistrement-courant (NEXT))
    ...
)

Voir aussi EXIT, DOTIMES, DOLIST, DO, FOR ALL.

16.6.18 EXIT

EXIT peut être utilisé pour terminer une boucle.

(EXIT [expr ...])

À l'intérieur du corps d'une boucle, EXIT termine la boucle, exécute les éventuelles expressions expr ..., et renvoie la valeur de la dernière expression (ou NIL en cas d'absence) comme valeur de retour pour la boucle. Les éventuelles expressions de résultat de la boucle comme par exemple dans

(DOTIMES (x 10 résultat-expr ...) ...)

ne sont pas exécutées.

Il est par exemple possible d'utiliser la fonction EXIT pour terminer une boucle FOR ALL lorsque l'enregistrement recherché a été trouvé :

(FOR ALL Table DO
    (IF intéressé-par-enregistrement-courant (EXIT Table))
    ...
)

Voir aussi NEXT, RETURN, HALT, DOTIMES, DOLIST, DO, FOR ALL.

16.6.19 RETURN

Lors de la définition d'une fonction, il est possible de rendre la main à l'appelant en utilisant la commande RETURN.

(RETURN [expr ...])

arrête l'exécution de la fonction, exécute les expressions expr ... optionnelles, et renvoie la valeur de la dernière (ou NIL en cas d'absence).

Exemple

(DEFUN find-record (nom)
    (FOR ALL Table DO
        (IF (= Nom nom) (RETURN Table))
    )
)

Cet exemple recherche un enregistrement dont le champ Nom correspond au nom spécifié. La fonction renvoie le premier enregistrement correspondant ou NIL si aucun enregistrement n'est trouvé.

Voir aussi HALT, EXIT.

16.6.20 HALT

HALT peut être utilisé pour terminer l'exécution du programme.

(HALT)

stoppe l'exécution du programme silencieusement.

Voir aussi ERROR, EXIT, RETURN.

16.6.21 ERROR

Pour stopper l'exécution du programme avec un message d'erreur, il est possible d'utiliser la fonction ERROR.

(ERROR fmt [arg ...])

stoppe l'exécution du programme et affiche une fenêtre avec un message d'erreur. Ce message est généré à partir de fmt et des arguments optionnels arg ... comme avec la fonction SPRINTF (voir SPRINTF).

Voir aussi HALT, SPRINTF.

16.7 Prédicats de type

Pour chaque type il existe un prédicat qui retourne TRUE si l'expression fournie est du type spécifié ou NIL dans le cas contraire. Ces prédicats sont :

Prédicat            Description

(STRP expr)        TRUE si expr est de type chaîne, NIL sinon.

(MEMOP expr)       TRUE si expr est de type mémo, NIL sinon.

(INTP expr)        TRUE si expr est de type entier, NIL sinon.

(REALP expr)       TRUE si expr est de type réel, NIL sinon.

(DATEP expr)       TRUE si expr est de type date, NIL sinon.

(TIMEP expr)       TRUE si expr est de type heure, NIL sinon.

(NULL expr)        TRUE si expr est NIL (une liste vide), NIL sinon.

(CONSP expr)       TRUE si expr n'est pas la liste vide, NIL sinon.

(LISTP expr)       TRUE si expr est une liste (peut être NIL), NIL sinon.

(RECP table expr)  TRUE si expr pointe sur un enregistrement de la table spécifiée.
                    Si expr est NIL, TRUE est renvoyé (enregistrement initial).
                    Si table est NIL, vérification si expr est un pointeur
                    d'enregistrement vers l'une des tables.

16.8 Fonctions de conversion de type

Cette section liste les fonctions de conversion d'un type vers un autre.

16.8.1 STR

STR est utilisée pour convertir une expression vers une représentation en chaîne.

(STR expr)

convertit expr en une représentation chaîne. Le type de expr détermine la conversion :

Type            Chaîne retournée

String          La chaîne elle-même.

Memo            Le texte complet du mémo dans une chaîne.

Integer         La représentation de la valeur entière.

Real            La représentation de la valeur réelle.
                Si expr est un champ de table, alors
                le nombre de décimales spécifié pour ce champ
                est utilisé, sinon 2 décimales sont produites.

Choice          Le label associé au choix.

Date            La représentation de la date en chaîne.

Time            La représentation de l'heure en chaîne.

Bool            La chaîne "TRUE"

NIL             La chaîne nil définie par l'utilisateur si expr
                est un champ ; la chaîne "NIL" sinon.

Record          La représentation du numéro d'enregistrement en chaîne.

Autres          La représentation de l'adresse interne du pointeur en chaîne.

Voir aussi MEMO, SPRINTF.

16.8.2 MEMO

MEMO est utilisée pour convertir une expression en mémo.

(MEMO expr)

convertit expr en mémo. Elle traite l'expression de la même manière que la fonction STR (voir STR) mais retourne un mémo plutôt qu'une chaîne.

Voir aussi STR.

16.8.3 INT

INT est utilisée pour convertir une expression en entier.

(INT expr)

convertit expr en valeur entière. Les conversions possibles sont :

Type            Valeur retournée

String          Si la chaîne complète représente une valeur entière valide,
                elle est convertie en entier. Une chaîne débutant par un 0
                est interprétée comme un nombre octal, une débutant par 0x
                comme un nombre hexadécimal.  Les espaces au début et à la
                fin sont ignorés.
                Si la chaîne ne représente pas une valeur entière, NIL est
                retourné.

Memo            Idem que pour le type String.

Integer         La valeur elle-même.

Real            Si la valeur est comprise dans l'intervalle de valeurs autorisé 
                pour les entiers, alors la valeur réelle est arrondie avant
                d'être retournée, sinon NIL est renvoyé.

Choice          Le numéro interne (à partir de 0) du label courant.

Date            Le nombre de jours depuis 01.01.0000.

Time            le nombre de secondes depuis 00:00:00.

Record          Le numéro d'enregistrement.

NIL             NIL

Autre           Un message d'erreur est généré et l'exécution du programme est arrêtée.

Voir aussi REAL, ASC.

16.8.4 REAL

REAL est utilisée pour convertir une expression en une valeur de type réel.

(REAL expr)

convertit expr en un réel. L'expression est traitée de la même manière qu'avec la fonction INT (voir INT) mais renvoie une valeur de type réel au lieu d'un entier.

Voir aussi INT.

16.8.5 DATE

DATE est utilisée pour convertir une expression en une date.

(DATE expr)

convertit l'expression spécifiée en une valeur de type date. Les conversions possibles sont :

Type            Valeur retournée

String          Si la totalité de la chaîne représente une date, alors la
                chaîne est convertie en une valeur de type date. Les espaces
                au début et à la fin sont ignorés.
                Dans le cas contraire, NIL est renvoyé.

Memo            Idem que pour le type String.

Integer         Une date est générée en utilisant l'entier comme étant le nombre
                de jours depuis 01.01.0000. Si la valeur entière est trop grande
                (c.-à-d. la date serait supérieure au 31.12.9999) ou négative alors
                NIL est retourné.

Real            Idem que pour le type Integer.

Date            La date elle-même.

NIL             NIL

Autre           Un message d'erreur est généré et l'exécution du programme est arrêtée.

Voir aussi DATEDMY.

16.8.6 TIME

TIME est utilisée pour convertir une expression en une heure.

(TIME expr)

convertit l'expression spécifiée en une valeur de type date. Les conversions possibles sont :

Type            Valeur retournée

String          Si la totalité de la chaîne représente une heure, alors la
                chaîne est convertie en une valeur de type heure. Les espaces
                au début et à la fin sont ignorés.
                Dans le cas contraire, NIL est renvoyé.

Memo            Idem que pour le type String.

Integer         Une heure est générée en utilisant l'entier comme étant le nombre
                de secondes depuis 00:00:00.

Real            Idem que pour le type Integer.

Time            L'heure elle-même.

NIL             NIL

Autre           Un message d'erreur est généré et l'exécution du programme arrêtée.

16.9 Fonctions sur les booléens

Cette section liste les opérateurs booléens.

16.9.1 AND

AND vérifie que tous ses arguments sont à TRUE.

(AND [expr ...])

vérifie expr ... une à une jusqu'à ce qu'une expression retourne NIL. Si toutes les expressions sont différentes de NIL alors la valeur de la dernière expression est renvoyée, sinon NIL est retourné.

Cette fonction n'est pas stricte, ce qui signifie que ses arguments peuvent ne pas être évalués, p. ex. dans `(AND NIL (+ 1 2))' l'expression `(+ 1 2)' n'est pas évaluée puisqu'une valeur NIL a déjà été traitée, en revanche dans `(AND (+ 1 2) NIL)' l'expression `(+ 1 2)' sera bien évaluée.

Voir aussi OR, NOT.

16.9.2 OR

OR vérifie que tous les arguments sont NIL.

(OR [expr ...])

vérifie expr ... une à une jusqu'à ce qu'une expression retourne une valeur différente de NIL. Retourne la valeur de la première expression différente de NIL ou NIL si toutes les expressions sont NIL.

Cette fonction n'est pas stricte, ce qui signifie que ses arguments peuvent ne pas être évalués, p. ex. dans `(OR TRUE (+ 1 2))' l'expression `(+ 1 2)' n'est pas évaluée puisqu'une valeur différente de NIL a déjà été traitée, en revanche dans `(OR (+ 1 2) TRUE)' l'expression `(+ 1 2)' sera effectivement évaluée.

Voir aussi AND, NOT.

16.9.3 NOT

NOT est utilisée pour inverser la valeur d'une expression booléenne.

(NOT expr)

retourne TRUE si expr est NIL, NIL dans le cas contraire.

Voir aussi AND, OR.

16.10 Fonctions de comparaison

Cette section présente les fonctions de comparaison de valeur.

16.10.1 Opérateurs relationnels

Pour comparer deux valeurs dans un programme BeeBase, il faut utiliser

(op expr1 expr2)

où op est parmi {=, <>, <, >, >=, <=, =*, <>*, <*, >*, >=*, <=*}. L'étoile est utilisée pour les comparaisons spéciales (les chaînes sont comparées sans tenir compte de la casse, les enregistrements en utilisant l'ordre défini par l'utilisateur).

Le tableau suivant indique les règles utilisées pour comparer deux valeurs dans un programme BeeBase.

Type           Relation d'ordre

Entier         NIL < MIN_INT < ... < -1 < 0 < 1 < ... < MAX_INT

Réel           NIL < -HUGE_VAL < ... < -1.0 < 0.0 < 1.0 < ... < HUGE_VAL

Chaîne         NIL <  "" <  "Z" <  "a"  <  "aa" <  "b" < ... (sensible à la casse)
               NIL <* "" <* "a" <* "AA" <* "b" < ...       (insensible à la casse)

Mémo           Identique aux chaînes

Date           NIL < 1.1.0000 < ... < 31.12.9999

Heure          NIL < 00:00:00 < ... < 596523:14:07 

Booléen        NIL < TRUE

Enregistrement NIL < un_enregistrement                (les enregistrements ne sont pas
                                                                   comparables avec <)
               NIL <* rec1 <* rec2                 (l'ordre définit par l'utilisateur)

Voir aussi CMP, CMP*, LIKE.

16.10.2 CMP

CMP retourne un entier représentant l'ordre de ses arguments.

(CMP expr1 expr2)

retourne une valeur inférieure à 0 si expr1 est plus petite que expr2, 0 si expr1 est égale à expr2, et une valeur supérieure à 0 si expr1 est plus grand que expr2. Pour déterminer l'ordre, la relation d'ordre simple (non étoilée) est utilisée comme dans les opérateurs relationnels (voir Opérateurs relationnels).

Ne supposez pas que la valeur retournée sera toujours -1, 0 ou 1 !

Exemple : `(CMP "Velo" "vELO")' renvoie -1.

Voir aussi CMP*, Opérateurs relationnels.

16.10.3 CMP*

CMP* est la version étoilée de CMP. La différence est que CMP* utilise un ordre étendu comme défini dans les opérateurs relationnels (voir Opérateurs relationnels) où les chaînes sont comparées sans tenir compte de la casse et les enregistrements sont comparés en utilisant l'ordre défini par l'utilisateur.

Exemple : `(CMP* "Velo" "vELO")' renvoie 0.

Voir aussi CMP, Opérateurs relationnels.

16.10.4 MAX

MAX retourne l'argument ayant la plus grande valeur.

(MAX [expr ...])

Retourne la valeur la plus grande parmi les arguments expr .... Si aucun argument n'est passé, NIL est retouné. Pour identifier l'élément le plus grand, la relation d'ordre simple (non étoilée), comme pour les opérateurs relationnels (voir Opérateurs relationnels), est utilisée.

Voir aussi MAX*, MIN, Opérateurs relationnels.

16.10.5 MAX*

MAX* est la version étoilée de MAX. La différence est que MAX* utilise l'ordre étendu défini pour les opérateurs relationnels (voir Opérateurs relationnels) lorque les chaînes sont comparées sans tenir compte de la casse ou que les enregistrements sont comparés en utilisant l'ordre défini par l'utilisateur.

Exemple : `(MAX* "x" "Y")' retourne "Y".

Voir aussi MAX, MIN*, Opérateurs relationnels.

16.10.6 MIN

MIN retourne l'argument ayant la plus petite valeur.

(MIN [expr ...])

Retourne la valeur la plus petite parmi les arguments expr .... Si aucun argument n'est passé, NIL est retouné. Pour identifier l'élément le plus petit, la relation d'ordre simple (non étoilée), comme pour les opérateurs relationnels (voir Opérateurs relationnels), est utilisée.

Voir aussi MIN*, MAX, Opérateurs relationnels.

16.10.7 MIN*

MIN* est la version étoilée de MIN. La différence est que MIN* utilise l'ordre étendu défini pour les opérateurs relationnels (voir Opérateurs relationnels) lorque les chaînes sont comparées sans tenir compte de la casse ou que les enregistrements sont comparés en utilisant l'ordre défini par l'utilisateur.

Exemple : `(MIN* "x" "Y")' retourne "x".

Voir aussi MIN, MAX*, Opérateurs relationnels.

16.11 Fonctions mathématiques

Ici quelques fonctions mathématiques sont listées.

16.11.1 Additionner des valeurs

Pour additionner des valeurs, utilisez

(+ expr ...)

Renvoie la somme des arguments expr .... Si l'un des arguments est NIL alors le résultat est NIL. Si les valeurs sont de type réel ou entier, alors la valeur du résultat sera de type réel ou entier.

Il est également possible d'ajouter des chaînes ou des mémos. Dans ce cas le résultat est la concaténation des chaînes ou des mémos.

Si expr est de type date et que le reste des arguments est de type entier / réel alors la somme des entiers / réels est interprétée comme un nombre de jours et est ajoutée à expr. Si la date résultante est hors limite (inférieure à 1.1.0000 ou supérieure à 31.12.9999) alors le résultat est NIL.

Si expr est de type heure et que le reste des arguments est de type entier, réel ou heure, alors la somme des entiers / réels (interprétée comme un nombre de secondes) ainsi que les valeurs horaires sont ajoutées à expr. Si l'heure résultante est hors limite (inférieur à 00:00:00 ou supérieure à 596523:14:07) alors le résultat est NIL.

Exemples

Expression                       Valeur

(+ 1 2 3)                        6
(+ 5 1.0)                        6.0
(+ "Hello" " " "world!")         "Hello world!"
(+ 28.11.1968 +365 -28 -9)       22.10.1969
(+ 07:30:00 3600)                08:30:00
(+ 03:00:00 23:59:59)            26:59:59

Voir aussi -, 1+, *, CONCAT, CONCAT2, ADDMONTH, ADDYEAR.

16.11.2 Soustraire des valeurs

Pour soustraire des valeurs, utilisez

(- expr1 expr2 ...)

Soustrait de expr1 la somme de expr2 .... Les mêmes règles que pour l'addition de valeurs (voir +) s'appliquent sauf que les chaînes et les mémos ne peuvent se soustraire.

(- expr) a une signification particulière : elle retourne la valeur négative de expr (entier ou réel), p. ex. `(- (+ 1 2))' retourne -3.

Voir aussi +, 1-.

16.11.3 1+

1+ incrémente de un une expression entière, réelle ou une date.

(1+ expr)

Retourne la valeur de expr (entier, réel, date) augmentée de un. Si expr est NIL alors le résultat est également NIL.

Voir aussi +, 1-.

16.11.4 1-

1- décrémente de un une expression entière, réelle ou une date.

(1- expr)

Retourne la valeur de expr (entier, réel, date) diminuée de un. Si expr est NIL alors le résultat est également NIL.

Voir aussi -, 1+.

16.11.5 Multiplier des valeurs

Pour multiplier des valeurs entières / réelles, utilisez :

(* expr ...)

Retourne la multiplication des valeurs entières / réelles expr .... Si tous les arguments sont entiers alors un entier est retourné, sinon le résultat est de type réel.

Voir aussi +, /.

16.11.6 Diviser des valeurs

Pour diviser des valeurs entières / réelles, utilisez :

(/ expr1 [expr2 ...])

Divise expr1 par le résultat de la multiplication du reste des arguments. Retourne une valeur réelle, NIL est renvoyé en cas de division par zéro.

Voir aussi *, DIV, MOD.

16.11.7 DIV

DIV permet d'effectuer des divisions entières.

(DIV int1 int2)

Retourne le résultat de la division entière de int1 par int2. Par exemple, `(DIV 5 3)' renvoie 1.

Voir aussi /, MOD.

16.11.8 MOD

MOD permet de calculer le modulo.

(MOD int1 int2)

Retourne int1 modulo int2. Par exemple, `(MOD 5 3)' renvoie 2.

Voir aussi DIV.

16.11.9 ABS

ABS calcule la valeur absolue d'une expression.

(ABS expr)

Retourne la valeur absolue de expr (entier ou réel). Si expr vaut NIL alors le résultat est NIL.

16.11.10 TRUNC

TRUNC tronque les décimales d'une valeur réelle.

(TRUNC reel)

Retourne le plus grand entier (sous forme réelle) qui n'est pas plus grand que le nombre réel spécifié. Si reel vaut NIL, le résultat est NIL.

Exemples : `(TRUNC 26.1)' renvoie 26, `(TRUNC -1.2)' renvoie -2.

Voir aussi ROUND.

16.11.11 ROUND

ROUND arrondit une valeur réelle.

(ROUND reel décimales)

Renvoie le nombre réel spécifié arrondi à décimales chiffres après la virgule. Si reel ou décimales sont NIL, le résultat est NIL.

Exemples : `(ROUND 70.70859 2)' renvoie 70.71, `(ROUND 392.36 -1)' renvoie 390.0.

Voir aussi TRUNC.

16.11.12 RANDOM

RANDOM permet de générer des nombres aléatoires.

(RANDOM expr)

Renvoie un nombre aléatoire. Au premier appel, le générateur de nombre aléatoire est initialisé avec une valeur générée à partir de l'heure courante. RANDOM génère un nombre dans l'intervalle 0 ... expr, en excluant la valeur expr. Le type de retour dépend de celui de expr : entier ou réel. Si expr est NIL, le résultat est NIL.

Exemples :

Exemple                 Signification

(RANDOM 10)             retourne une valeur entre 0 et 9 compris,
(RANDOM 10.0)           retourne une valeur entre 0.0 et 9.99999... compris

16.11.13 POW

POW élève à une puissance un nombre.

(POW x y)

Retourne la valeur du nombre réel x élevé à la puissance du nombre réel y. Si x ou y est NIL, ou si x est négatif et y n'est pas un nombre entier, alors NIL est retourné.

Exemple : `(POW 2 3)' retourne 8.

Voir aussi SQRT, EXP.

16.11.14 SQRT

SQRT extrait la racine carré d'un nombre.

(SQRT x)

Retourner la racine carré d'une nombre réel x. Si x est NIL ou négatif alors NIL est retourné.

Voir aussi POW.

16.11.15 EXP

EXP calcule l'exponentielle d'un nombre.

(EXP x)

Retourne la valeur de la base du logarithme naturel élevé à la puissance du nombre réel x. Si x est NIL alors NIL est retouné.

Voir aussi POW, LOG.

16.11.16 LOG

LOG calcule le logarithme naturel d'un nombre.

(LOG x)

Retourne le logarithme naturel du nombre réel x. Si x est NIL ou n'est pas supérieur à 0 alors NIL est retourné.

Voir aussi EXP.

16.12 Fonctions sur les chaînes

Cette section concerne les fonctions ayant trait aux chaînes de caractères.

16.12.1 LEN

LEN calcule la longueur d'une chaîne.

(LEN str)

Retourne la longueur de la chaîne spécifiée ou NIL si str est NIL.

Voir aussi WORDS, LINES, MAXLEN.

16.12.2 LEFTSTR

LEFTSTR extrait une sous-chaîne d'une chaîne.

(LEFTSTR str long)

Retourne la partie gauche de la chaîne spécifiée avec au plus long caractères. Si str ou long sont NIL ou si long est négatif alors NIL est retourné.

Exemple : `(LEFTSTR "Hello world!" 5)' retourne "Hello".

Voir aussi RIGHTSTR, MIDSTR, WORD, LINE.

16.12.3 RIGHTSTR

(RIGHTSTR str long)

Retourne la partie droite de la chaîne spécifiée avec au plus long caractères. Si str ou long sont NIL ou si long est négatif alors NIL est retourné.

Exemple : `(RIGHTSTR "Hello world!" 6)' retourne "world!".

Voir aussi LEFTSTR, MIDSTR, WORD, LINE.

16.12.4 MIDSTR

MIDSTR extrait une sous-chaîne d'une chaîne.

(MIDSTR str pos long)

Retourne une partie de la chaîne spécifiée avec au plus long caractères. La sous-chaîne débute à la position pos (à partir de zéro). Si long est NIL alors toute la fin de la chaîne à partir de la position pos est retournée. Si str est NIL ou si long est négatif alors NIL est retourné. Si pos est hors limite, c.-à-d. négatif ou supérieur à la longueur de la chaîne, NIL est retourné.

Exemple : `(MIDSTR "Hello world!" 3 5)' retourne "lo wo".

Voir aussi LEFTSTR, RIGHTSTR, WORD, LINE, SETMIDSTR, INSMIDSTR.

16.12.5 SETMIDSTR

SETMIDSTR remplace une sous-chaîne d'une chaîne.

(SETMIDSTR str index set)

Retourne une copie de la chaîne str où la sous-chaîne débutant à index est remplacée par la chaîne set. La longueur de la chaîne retournée est supérieure ou égale à celle de str. Si l'un des arguments est NIL ou si index est hors limite, le résultat est NIL.

Exemple : `(SETMIDSTR "Hello world!" 6 "Melanie!")' retourne "Hello Melanie!".

Voir aussi INSMIDSTR, REPLACESTR.

16.12.6 INSMIDSTR

INSMIDSTR permet d'insérer une chaîne dans une autre.

(INSMIDSTR str index insert)

Retourne une copie de la chaîne str où la chaîne insert a été insérée à l'index spécifié. Si l'un des arguments est NIL ou si index est hors limite, le résultat est NIL.

Exemple : `(INSMIDSTR "Hello world!" 6 "BeeBase-")' retourne "Hello BeeBase-world!".

Voir aussi SETMIDSTR, REPLACESTR.

16.12.7 INDEXSTR

INDEXSTR cherche la première occurrence d'une chaîne dans une autre.

(INDEXSTR str substr)

Recherche la première occurrence de la chaîne substr dans str avec une comparaison sensible à la casse. Retourne un index (à partir de 0) de la première occurrence de la sous-chaîne dans str ou NIL si la sous-chaîne n'est pas présente. Si l'un des arguments est NIL alors le résultat est NIL.

Exemple : `(INDEXSTR "Hello world!" "world")' retourne 6.

Voir aussi INDEXSTR*, RINDEXSTR, RINDEXSTR*, INDEXBRK, INDEXBRK*.

16.12.8 INDEXSTR*

INDEXSTR* a le même effet que INDEXSTR (voir INDEXSTR) sauf que la comparaison de chaîne n'est pas sensible à la casse.

Voir aussi INDEXSTR, RINDEXSTR, RINDEXSTR*, INDEXBRK, INDEXBRK*.

16.12.9 INDEXBRK

INDEXBRK cherche la première occurrence d'un caractère dans une chaîne.

(INDEXBRK str listecar)

Recherche la première occurrence d'un des caractères contenus dans listecar dans la chaîne str avec une comparaison sensible à la casse. Retourne l'index (à partir de 0) du premier caractère trouvé dans str ou NIL si aucun caractère n'est trouvé. Si l'un des arguments est NIL, le résultat est NIL.

Exemple : `(INDEXBRK "Hello world!" "aeiou")' retourne 1.

Voir aussi INDEXBRK*, RINDEXBRK, RINDEXBRK*, INDEXSTR, INDEXSTR*.

16.12.10 INDEXBRK*

INDEXBRK* a le même effet que INDEXBRK (voir INDEXBRK) sauf que la comparaison de chaîne n'est pas sensible à la casse.

Voir aussi INDEXBRK, RINDEXBRK, RINDEXBRK*, INDEXSTR, INDEXSTR*.

16.12.11 RINDEXSTR

RINDEXSTR recherche la dernière occurrence d'une chaîne dans une autre.

(RINDEXSTR str substr)

Recherche la dernière occurrence de substr dans str, avec une comparaison sensible à la casse. Retourne l'index (à partir de 0) de la sous-chaîne dans str ou NIL si la sous-chaîne n'est pas présente. Si l'un des arguments est NIL, le résultat est NIL.

Exemple : `(RINDEXSTR "Do itashimashite." "shi")' returns 11.

Voir aussi RINDEXSTR*, INDEXSTR, INDEXSTR*, RINDEXBRK, RINDEXBRK*.

16.12.12 RINDEXSTR*

RINDEXSTR* a le même effet que RINDEXSTR (voir RINDEXSTR) sauf que la comparaison n'est pas sensible à la casse.

Voir aussi RINDEXSTR, INDEXSTR, INDEXSTR*, RINDEXBRK, RINDEXBRK*.

16.12.13 RINDEXBRK

RINDEXBRK recherche la dernière occurrence d'un caractère dans une chaîne.

(RINDEXBRK str listecar)

Recherche la dernière occurrence de l'un des caractères de listecar dans str avec une comparaison de chaîne sensible à la casse. Retourne l'index (à partir de 0) du dernier caractère trouvé dans str ou NIL si aucun caractère n'a été trouvé. Si l'un des arguments est NIL alors le résultat est NIL.

Exemple : `(RINDEXBRK "Konnichiwa" "chk")' retourne 6.

Voir aussi RINDEXBRK*, INDEXBRK, INDEXBRK*, RINDEXSTR, RINDEXSTR*.

16.12.14 RINDEXBRK*

RINDEXBRK* a le même effet que RINDEXBRK (voir RINDEXBRK) sauf que la comparaison n'est pas sensible à la casse.

Voir aussi RINDEXBRK, INDEXBRK, INDEXBRK*, RINDEXSTR, RINDEXSTR*.

16.12.15 REPLACESTR

REPLACESTR remplace des sous-chaînes par d'autres.

(REPLACESTR str [recherché1 remplaçant1 ...])

Remplace toutes les occurrences de recherché1 dans str par remplaçant1 et poursuit par le remplacement de sous-chaînes dans la nouvelle chaîne en utilisant la paire suivante de chaînes recherchée et remplaçante jusqu'au traitement complet des arguments. Noter que le nombre d'arguments doit être impair et que les arguments aux positions paires spécifient des chaînes recherchées suivies de la chaîne de remplacement correspondante. Du fait que le résultat d'un remplacement est utilisé lors du remplacement suivant, des remplacements multiples peuvent être effectués, ce qui doit être pris en compte lors de l'utilisation de cette fonction. Un ordre différent des arguments peut aider la résolution de conflits puisque les remplacements sont effectués de gauches à droite.

Si l'une des chaînes est NIL ou que l'une des chaînes de recherche est vide, le résultat est NIL.

Exemple : `(REPLACESTR "black is white" "black" "white" "white "black")' retourne "noir c'est noir".

Voir aussi REPLACESTR*, SETMIDSTR, INSMIDSTR, REMCHARS.

16.12.16 REPLACESTR*

REPLACESTR* a le même effet que REPLACESTR (voir REPLACESTR) sauf que la comparaison n'est pas sensible à la casse.

Voir aussi REPLACESTR, SETMIDSTR, INSMIDSTR, REMCHARS.

16.12.17 REMCHARS

REMCHARS supprime des caractères d'une chaîne.

(REMCHARS str car-à-supprimer)

Retourne une copie de str dans laquelle tous les caractères de car-à-supprimer ont été supprimés. Si str ou car-à-supprimer sont NIL, le résultat est NIL.

Exemple : `(REMCHARS votre-chaîne " \t\n")' supprime tous les espaces, tabulations et retour chariot de votre-chaîne.

Voir aussi REPLACESTR, TRIMSTR.

16.12.18 TRIMSTR

TRIMSTR supprime des caractères au début et à la fin d'une chaîne.

(TRIMSTR str [début fin])

Retourne une copie de str où les caractères de début et de fin ont été supprimés. Appelé avec un seul argument, les espaces, sauts de page, sauts de ligne, retours chariot et tabulations horizontales et verticales sont enlevés. Appelé avec trois arguments, début et fin spécifient respectivement les caractères à supprimer au début et à la fin de la chaîne. Il faut remarquer que TRIMSTR ne peut pas être appelé avec deux arguments.

Si l'un des arguments str, début ou fin est NIL alors le résultat est NIL.

Exemple : (TRIMSTR " J'ai cassé le vélo de Selma. ") retourne "J'ai cassé le vélo de Selma.", (TRIMSTR "007 " "0" " \f\n\r\t\v") retourne "7".

Voir aussi REMCHARS.

16.12.19 WORD

WORD retourne un mot contenu dans une chaîne.

(WORD str num)

Retourne le numième mot (à partir de zéro) de la chaîne spécifiée. Les mots d'une chaîne sont des sous-chaînes non vides séparées par des caractères blancs (p. ex. espace, tabulation ou retour à la ligne).

Si str ou num sont NIL ou si num est hors limite, c'est à dire négatif, ou égal ou supérieur au nombre de mots, alors le résultat est NIL.

Exemple : `(WORD "Du coup je prête mon vélo à Selma." 6)' retourne "vélo".

Voir aussi WORDS, LINE, LEFTSTR, RIGHTSTR, MIDSTR.

16.12.20 WORDS

WORDS compte le nombre de mots contenus dans une chaîne.

(WORDS str)

Retourne le nombre de mots contenus dans la chaîne spécifiée ou NIL si str est NIL. Les mots sont des sous-chaînes non vides séparées par des caractères blancs (p. ex. espace, tabulation ou retour à la ligne).

Exemple : `(WORDS "En fait, ce n'était pas vraiment mon vélo.")' retourne 8.

Voir aussi WORD, LINES, LEN.

16.12.21 FIELD

FIELD extrait un champ d'une chaîne.

(FIELD str num [sep [quotes]])

Retourne le numième champ (à partir de zéro) d'une chaîne. Les champs d'une chaîne sont des sous-chaînes séparées par exactement un caractère séparateur. Un champ peut être une chaîne vide. L'argument sep contient les caractères séparateurs de champ. Si sep est NIL ou absent alors un caractères d'espacement (e.g. espace, tab, ou saut de ligne) est utilisé. Si quotes est présent et n'est pas à NIL alors les champs peuvent être encadrés de guillemets double et peuvent contenir des caractères d'espacement. Les guillemets double sont supprimés pendant l'extration des champs.

Si str ou num sont NIL, ou si num est hors limite, c.-à-d., inférieur à 0, ou égale ou supérieur aux nombre de champs, alors NIL est retourné.

Exemple : `(FIELD "My name is \"Darth Vader\"" 3 " " TRUE)' retourne "Darth Vader".

Voir aussi FIELDS, WORD, LEFTSTR, RIGHTSTR, MIDSTR, STRTOLIST.

16.12.22 FIELDS

FIELDS compte le nombre de champs dans une chaîne.

(FIELDS str [sep [quotes]])

Retourne le nombre de champs dans une chaîne ou NIL si str est NIL. Les champs d'une chaîne sont des sous-chaînes séparées par exactement un caractère séparateur. Un champ peut être une chaîne vide. L'argument sep contient les caractères séparateurs de champ. Si sep est NIL ou absent alors un caractères d'espacement (e.g. espace, tab, ou saut de ligne) est utilisé. Si quotes est présent et n'est pas à NIL alors les champs peuvent être encadrés de guillemets double et peuvent contenir des caractères d'espacement. Les guillemets double sont supprimés pendant l'extration des champs.

Voir aussi FIELD, WORDS, LEN.

16.12.23 STRTOLIST

STRTOLIST convertit une chaîne en une liste de chaînes.

(STRTOLIST str [sep])

Crée une liste de chaînes en découpant la chaîne str au niveau des occurrences de la séquence de séparation sep. Si sep n'est pas spécifié alors le caractère tabulation "\t" est utilisé. Si sep est la chaîne vide "" alors la liste de tous les caractères contenus dans la chaîne est retournée.

Si str ou sep sont NIL alors NIL est retourné.

Exemples

`(STRTOLIST "J'aime\tle\tJapon.")' retourne ( "J'aime" "le" "Japon." ).

`(STRTOLIST "Nom|Rue|Ville" "|")' retourne ( "Nom" "Rue" "Ville" ).

`(STRTOLIST "abc" "")' retourne ( "a" "b" "c" ).

Voir aussi MEMOTOLIST, LISTTOSTR.

16.12.24 LISTTOSTR

LISTTOSTR convertit une liste d'éléments en une chaîne.

(LISTTOSTR liste [sep])

Convertit la liste spécifiée d'éléments en une chaîne par concaténation des représentations textuelles de chaque élément de la liste séparées par la séquence sep. Si sep n'est pas spécifié alors le caractère tabulation "\t" est utilisé. Si list ou sep sont NIL alors NIL est retourné.

Exemples

`(LISTTOSTR (LIST "Pierre a" 18 "ans"))' retourne "Pierre a\t18\tans".

`(LISTTOSTR (LIST "Nom" "Rue" "Ville") "|")' retourne "Nom|Rue|Ville".

Voir aussi LISTTOMEMO, CONCAT, CONCAT2, STRTOLIST.

16.12.25 CONCAT

CONCAT concatène des chaînes.

(CONCAT [str ...])

Retourne la concaténation de la liste des chaînes donnée avec des espaces entre chacune. Si l'une des chaînes est NIL ou si la liste est vide, le résultat est NIL.

Exemple : `(CONCAT "Je" "pensais" "que" "c'était" "un" "vélo" "abandonné.")' retourne "Je pensais que c'était un vélo abandonné.".

Voir aussi CONCAT2, +, LISTTOSTR, COPYSTR, SPRINTF.

16.12.26 CONCAT2

CONCAT2 concatène des chaînes.

(CONCAT2 insert [str ...])

Retourne la concaténation de la liste des chaînes donnée avec la chaîne insert entre chacune. Si insert ou l'une des chaînes est NIL ou si la liste est vide, le résultat est NIL.

Exemple : `(CONCAT2 "! " "Mais" "ça" "ne" "l'était" "pas")' retourne "Mais! ça! ne! l'était! pas!".

Voir aussi CONCAT, +, LISTTOSTR, COPYSTR, SPRINTF.

16.12.27 COPYSTR

COPYSTR crée des copies d'une chaîne.

(COPYSTR str num)

Retourne une chaîne constituée de num fois la chaîne str. Si str est NIL, num est NIL ou inférieur à zéro, le résultat est NIL.

Exemple : `(COPYSTR "+-" 5)' retourne "+-+-+-+-+-"

Voir aussi CONCAT CONCAT2, +, SPRINTF.

16.12.28 SHA1SUM

SHA1SUM calcule la valeur de hachage SHA1 d'une chaîne.

(SHA1SUM str)

Retourne une chaîne contenant la valeur de hachage SHA1 de la chaîne spécifiée. Si str est NIL alors NIL est retourné.

Exemple : `(SHA1SUM "flower, sun and beach")' retourne "47b6c496493c512b40e042337c128d85ecf15ba4".

Voir aussi ADMINPASSWORD, démo `Users.bbs'.

16.12.29 UPPER

UPPER convertit une chaîne en majuscules.

(UPPER str)

Retourne une copie de la chaîne donnée où tous les caractères ont été convertis en majuscules. Si str est NIL, le résultat est NIL.

Exemple : `(UPPER "Selma a trouvé une lettre attachée à mon vélo.")' retourne "SELMA A TROUVÉ UNE LETTRE ATTACHÉE à MON VELO.".

Voir aussi LOWER.

16.12.30 LOWER

LOWER convertit en minuscules une chaîne.

(LOWER str)

Retourne une copie de la chaîne donnée où tous les caractères ont été convertis en minuscules. Si str est NIL, le résultat est NIL.

Exemple : `(LOWER "La lettre était de Silke.")' retourne "la lettre était de silke.".

Voir aussi UPPER.

16.12.31 ASC

ASC convertit un caractère en sa représentation interne entière.

(ASC str)

Retourne le code entier interne du premier caractère de str. Sur Windows, Mac OS et Linux il s'agit d'une représentation unicode. Sur Amiga, il s'agit du code entier 8 bits dans le jeu de caractères configuré dans le système. Si str est vide, le résultat est 0. Si str est NIL, le résultat est NIL.

Exemple : (ASC "A") retourne 65.

Voir aussi CHR, INT.

16.12.32 CHR

CHR convertit une valeur entière en caractère.

(CHR entier)

Retourne une chaîne contenant le caractère de code entier entier. Sur Windows, Mac OS et Linux entier est interprété comme un caractère unicode. Sur Amiga, entier est un entier 8 bits dans le jeu de caractères configuré dans le système. Si entier vaut 0, une chaîne vide est renvoyée. Si entier est NIL ou en dehors de l'intervalle des caractères valides, le résultat est NIL.

Exemple : `(CHR 67)' retourne "C".

Voir aussi ASC, STR.

16.12.33 LIKE

LIKE compare des chaînes.

(LIKE str1 str2)

Retourne TRUE si str1 correspond à str2, NIL sinon. La chaîne str2 peut contenir les caractères jokers '?' (pour replacer exactement un caractère) et '*' (pour remplacer une suite quelconque de caractères). La comparaison est sensible à la casse.

Exemple : `(LIKE "Silke est allé en France pendant un an." "*France*")' retourne TRUE.

Voir aussi Fonctions de comparaison.

16.12.34 SPRINTF

SPRINTF formate une chaîne à partir de diverses données.

(SPRINTF fmt [expr ...])

SPRINTF prend une série d'arguments, les convertit en chaîne et retourne l'information formatée dans une seule chaîne. La chaîne fmt détermine exactement ce qui est écrit dans la chaîne retournée et peut contenir deux types d'éléments : des caractères ordinaires qui sont toujours copiés tels quels et des spécificateurs de conversion qui indique à SPRINTF de prendre en compte des arguments depuis la liste et de les formater. Les spécificateurs de conversion débutent toujours par un caractère `%'.

Les spécificateurs de conversion sont toujours de la forme :

%[drapeaux][largeur][.precision]type

où

• Le champ optionnel drapeaux contrôle la justification, le caractère de signe des valeurs numériques, le point décimal et les espaces de fin.

• Le champ optionnel largeur indique le nombre minimum de caractères à afficher (la largeur du champ), avec un bourrage par des blancs ou des zéros.

• Le champ optionnel précision spécifie soit le plus grand nombre de caractères à restituer pour les types chaîne, booléen, date et heure, soit le nombre de décimales à restituer après le séparateur décimal pour le type réel.

• Le champ type indique le type effectif de l'argument que SPRINTF va convertir : texte, entier, réel, etc.

Noter que le tous les champs ci-dessus sont optionnels à l'exception de type. Les tableaux suivants listent les options valides pour ces champs.

Champ drapeaux

- :

Le résultat est justifié à gauche, avec un bourrage par la droite avec des blancs. Par défaut lorsque `-' n'est pas spécifié, le résultat est justifié à droite avec un bourrage à gauche par des `0' ou des blancs.

+ :

Le résultat possède toujours un caractère représentant son signe s'il s'agit d'une conversion numérique.

0 :

Pour les nombres justifiés à gauche, le remplissage est effectué avec des zéros au lieu d'espaces.

espace :

Les nombres positifs débutent par un espace à la place d'un caractère `+', en revanche les valeurs négatives sont toujours préfixées d'un `-'.

Champ largeur

n :

n au minimum sont affichés. Si la conversion dispose de moins de n caractères, un remplissage par des espaces ou des zéros non-significatifs est effectué.

* :

La valeur de la largeur est fournie dans la liste d'arguments en tant que valeur entière ou réelle, avant l'argument à convertir. Cette valeur est limitée à l'intervalle 0 à 999.

Champ précision

.n :

Pour les valeurs de type texte, booléen, date et heure, n est le nombre maximum de caractères de l'élément converti à restituer. Pour les conversions de valeurs réelles, n spécifie le nombre de chiffres après la virgule (conversions `f' et `e') ou le nombre de chiffres significatifs (conversion `g'). Dans les conversions d'entiers, ce champ est ignoré.

.*:

La valeur de la précision est fournie dans la liste des arguments sous forme de valeur entière ou réelle, avant l'argument à convertir. Cette valeur est limitée à l'intervalle 0 à 999.

Champ type

b :

Convertit une valeur booléenne en "TRUE" ou "NIL".

i :

Convertit une valeur entière en une notation décimale signée.

o :

Convertit une valeur entière en une notation octale non signée.

x :

Convertit une valeur entière en une notation hexadécimale non signée, en utilisant les lettres minuscules `abcdef'.

X :

Convertit une valeur entière en une notation hexadécimale non signée, en utilisant les lettres majuscules `ABCDEF'.

e :

Convertit une valeur réelle en utilisant le format [-]d.ddde+dd (NDT : c.-à-d. la notation scientifique). Exactement un chiffre avant le point décimal, suivi d'un `e', suivi d'un exposant. Le nombre de chiffres après le point décimal est déterminé par le champ précision ou est de 2 si aucune précision n'a été spécifiée. Le point décimal n'apparaît pas si la précision est de 0.

f :

Convertit une valeur réelle en utilisant le format [-]ddd.ddd. Le nombre de chiffres après le point décimal est déterminé par le champ précision ou est de 2 si aucune précision n'est spécifiée. Le point décimal n'apparaît pas si la précision est de 0.

g :

Convertit une valeur réelle en utilisant le style `e' ou `f' en fonction du nombre de chiffres représentant la valeur. Si la précision n'est pas précisée, 15 chiffres sont utilisés. Les zéros terminaux sont supprimés de la sortie, à l'exception de celui qui suit directement le point décimal.

s :

Écrit la chaîne jusqu'à sa fin, ou jusqu'à ce que le nombre de caractères spécifié par le champ précision soit atteint.

d :

Convertit une valeur de date.

t :

Convertit une valeur horaire.

% :

Écrit le caractère `%' sans qu'aucun argument ne soit converti.

SPRINTF retourne la chaîne formatée ou NIL si fmt est NIL.

Exemples

Appel                     Résultat

(SPRINTF "Hello")                "Hello"
(SPRINTF "%s" "Hello")           "Hello"
(SPRINTF "%10s" "Hello")         "     Hello"
(SPRINTF "%-10.10s" "Hello")     "Hello     "
(SPRINTF "%010.3s" "Hello")      "       Hel"
(SPRINTF "%-5.3b" TRUE)          "TRU  "
(SPRINTF "%i" 3)                 "3"
(SPRINTF "%03i" 3)               "003"
(SPRINTF "%0- 5.3i" 3)           " 3   "
(SPRINTF "%f" 12)                "12.00"
(SPRINTF "%10e" 12.0)            "  1.20e+01"
(SPRINTF "%+-10.4f" 12.0)        "+12.0000  "
(SPRINTF "%10.5t" 12:30:00)      "     12:30"
(SPRINTF "%d" 28.11.1968)        "28.11.1968"
(SPRINTF "He%s %5.5s!"
   "llo"
   "world champion ship")        "Hello world!"

Voir aussi PRINTF, FPRINTF, STR, +, CONCAT, CONCAT2, COPYSTR.

16.13 Fonctions sur les mémos

Cette section traite des fonctions de manipulation des mémos.

16.13.1 LINE

LINE extrait une ligne d'un mémo.

(LINE memo num)

Retourne la numième ligne (à partir de zéro) du mémo spécifié. La chaîne contenant la ligne ne contient pas de caractère de retour à la ligne à la fin. Si memo ou num sont NIL ou si num est hors limite, c.-à-d. négatif ou supérieur ou égal au nombre de lignes, le résultat est NIL.

Voir aussi LINES, WORD.

16.13.2 LINES

LINES retourne le nombre de lignes dans un mémo.

(LINES memo)

Retourne le nombre de lignes du mémo spécifié ou NIL si memo est NIL.

Voir aussi LINE, WORDS, LEN.

16.13.3 MEMOTOLIST

MEMOTOLIST convertit un mémo en une liste de chaînes.

(MEMOTOLIST memo [expandstr])

Convertit le mémo spécifié en liste. Si memo est NIL, alors le résultat est NIL, sinon, une liste est générée dans laquelle chaque élément contient une ligne du mémo.

Si expandstr est spécifié et n'est pas NIL alors la liste de chaînes retournée est ensuite traitée en appliquant STRTOLIST à chaque élément de la liste. Ce qui donne une liste de listes de chaînes.

Exemples

`(MEMOTOLIST "Mon assurance\nprend en charge\nle vélo cassé.")' retourne ( "Mon assurance" "prend en charge" "le vélo cassé." ).

`(MEMOTOLIST "Voici\tun exemple\nmulti-colonnes." TRUE)' retourne ( ( "Voici" "un exemple" ) ( "multi-colonnes." ) ).

Voir aussi STRTOLIST, LISTTOMEMO.

16.13.4 LISTTOMEMO

LISTTOMEMO convertit une liste en mémo.

(LISTTOMEMO list)

Convertit la liste spécifiée en mémo. Si list est NIL, alors le résultat est NIL, sinon un mémo est généré où chaque ligne est constituée de la conversion textuelle de l'élément correspondant de la liste. Si un élément de la liste est une sous-liste, alors LISTTOSTR (voir LISTTOSTR) lui est appliqué avant d'intégrer la chaîne résultat dans le mémo.

Exemples

`(LISTTOMEMO (LIST (LIST "Nom" "Date naissance") (LIST "Steffen" 28.11.1968)' retourne "Nom\tDate naissance\nSteffen\t28.11.1968".

Voir aussi LISTTOSTR, MEMOTOLIST.

16.13.5 FILLMEMO

FILLMEMO remplit un mémo avec les résultats d'expressions.

(FILLMEMO memo)

Crée une copie du mémo spécifié où toutes les sous-chaînes de la forme `$(expr)' sont remplacées par leur résultat après leur évaluation.

Exemple : `(FILLMEMO "(+ 1 1) donne $(+ 1 1).")' retourne "(+ 1 1) donne 2."

Le débogage et l'identification n'étant pas aisée ici, il est préférable de n'utiliser que des expressions simples dans un mémo.

Voir aussi FORMATMEMO, INDENTMEMO.

16.13.6 FORMATMEMO

FORMATMEMO formate un mémo.

(FORMATMEMO memo longueur [bourrage [secmonoligne]])

Formate memo de manière à ce qu'il devienne un mémo avec des lignes ayant longueur caractères au plus. Si bourrage n'est pas NIL des espaces de bourrage sont utilisés pour remplir les lignes jusqu'à longueur caractères. Le mémo est traité section par section, une section débute au premier caractère non blanc. Si secmonoligne est spécifié et différent de NIL alors tous les caractères jusqu'à la fin de cette ligne sont considérés comme faisant partie de la section. Sinon tous les caractères de cette ligne et des suivantes sont considérés dans la section jusqu'à rencontrer une ligne débutant par un caractère blanc. La section est ensuite formatée mot à mot, c'est à dire qu'autant de mots que possible sont mis dans une ligne. Les mots restants sont insérés dans la ligne suivante etc.

Voir aussi FILLMEMO, INDENTMEMO.

16.13.7 INDENTMEMO

INDENTMEMO indente un mémo en mettant des espaces à gauche.

(INDENTMEMO memo indentation)

Retourne une copie du mémo spécifié où chaque ligne est indentée par indentation espaces. Si memo ou indentation sont NIL, alors le résultat est NIL. Si indentation est négatif, une valeur de 0 est utilisée.

Voir aussi FILLMEMO, FORMATMEMO.

16.14 Fonctions sur les dates et heures

Cette section concerne les fonctions de manipulation de valeurs de type date et heure.

16.14.1 DAY

DAY extrait le jour d'une date.

(DAY date)

Renvoie un nombre entier représentant le jour de la date spécifiée. Si date est NIL alors NIL est retourné.

Voir aussi MONTH, YEAR, DATEDMY.

16.14.2 MONTH

MONTH extrait le mois d'une date.

(MONTH date)

Renvoie un nombre entier représentant le mois de la date spécifiée. Si date est NIL alors NIL est retourné.

Voir aussi DAY, YEAR, DATEDMY, MONTHDAYS.

16.14.3 YEAR

YEAR extrait l'année d'une date.

(YEAR date)

Renvoie un nombre entier représentant l'année de la date spécifiée. Si date est NIL alors NIL est retourné.

Voir aussi DAY, MONTH, DATEDMY, YEARDAYS.

16.14.4 DATEDMY

DATEDMY crée une date à partir du jour, du mois et de l'année.

(DATEDMY jour mois année)

Crée une date à partir des données du jour, du mois et de l'année. Si jour, mois ou année sont NIL, hors limite ou si le résultat de la date n'est pas valide, alors NIL est retourné.

Exemple : `(DATEDMY 28 11 1968)' donne le 28 novembre 1968.

Voir aussi DATE, TODAY, DAY, MONTH, YEAR.

16.14.5 MONTHDAYS

MONTHDAYS donne le nombre de jours d'un mois.

(MONTHDAYS mois année)

Renvoie le nombre de jours d'un mois dans une année. Si mois est NIL ou hors limite (inférieur à 1 ou supérieur à 12) alors NIL est retourné. Si année est NIL alors une année non bissextile est supposée pour calculer le nombre de jours. Si année est invalide (inférieure à 0 ou supérieure à 9999) alors NIL est retourné.

Exemple : `(MONTHDAYS 2 2004)' donne 29, `(MONTHDAYS 2 NIL)' donne 28.

Voir aussi YEARDAYS, MONTH.

16.14.6 YEARDAYS

YEARDAYS donne le nombre de jours d'une année.

(YEARDAYS année)

Renvoie le nombre de jours (Entier) contenus dans l'année spécifiée. Si année est NIL ou hors limite (inférieure à 0 ou supérieure à 9999) alors NIL est retourné.

Exemple : `(YEARDAYS 2004)' donne 366, `(YEARDAYS 2005)' donne 365.

Voir aussi MONTHDAYS, YEAR.

16.14.7 ADDMONTH

ADDMONTH ajoute un certain nombre de mois à une date.

(ADDMONTH date mois)

Renvoie une date où le nombre de mois spécifié a été ajouté à la date initiale. Les valeurs négatives pour mois soustraient les mois. Si date ou mois sont NIL ou si le résultat de la date est invalide, alors NIL est retourné.

ADDMONTH gère le débordement ou l'épuisement du champ mois en ajustant l'année en conséquence. Dans le cas où le champ jour dépasserait le nombre maximum de jours pour le mois résultant, il est décrémenté au nombre maximum de jours autorisé pour ce mois.

Exemple : `(ADDMONTH 30.01.2004 1)' donne 29.02.2004, `(ADDMONTH 30.01.2004 -1)' donne 30.12.2003.

Voir aussi ADDYEAR, +.

16.14.8 ADDYEAR

ADDYEAR ajoute un certain nombre d'années à une date.

(ADDYEAR date années)

Renvoie une date où le nombre d'années spécifié a été ajouté à la date initiale. Les valeurs négatives pour années soustraient des années. Si date ou années sont NIL ou si le résultat de la date est invalide, alors NIL est retourné.

ADDYEAR décrémente le jour de 1 au cas où la date représenterait le 29 février et si l'année résultante n'est pas bissextile.

Exemple : `(ADDYEAR 29.02.2004 1)' donne 28.02.2005, `(ADDMONTH 04.02.2004 -1962)' donne 04.02.0042.

Voir aussi ADDMONTH, +.

16.14.9 TODAY

TODAY renvoie la date du jour.

(TODAY)

Renvoie la date du jour en tant que valeur date.

Voir aussi NOW, DATEDMY.

16.14.10 NOW

NOW renvoie l'heure courante.

(NOW)

Renvoie l'heure courante avec une valeur de type Heure.

Voir aussi TODAY.

16.15 Liste des fonctions

Cette section énumère les fonctions pour le traitement des listes.

16.15.1 CONS

CONS construit une paire d'expressions.

(CONS elem list)

Construit une nouvelle liste. Le premier élément de la nouvelle liste est elem, le reste sont les éléments de list (qui devraient être une liste ou NIL). La liste list n'est pas copiée, seul un pointeur est utilisé pour la référencer !

Exemple : `(CONS 1 (CONS 2 NIL))' donne ( 1 2 ).

Les éléments d'une liste peuvent être de n'importe quel type, par exemple il est également possible d'avoir une liste de listes (par exemple voir voir SELECT). Le constructeur CONS peut également être employé pour établir des paires d'éléments, par exemple `(CONS 1 2)' est une paire avec les deux nombres entiers 1 et 2.

Voir aussi LIST, FIRST, REST.

16.15.2 LIST

LIST produit une liste en dehors de ses arguments.

(LIST [elem ...])

Prend les arguments elem ... pour produire une liste. Ce qui équivaut à appeler (CONS elem (CONS ... NIL)). Notez que NIL reste seul pour une liste vide.

Voir aussi CONS, LENGTH.

16.15.3 LENGTH

LENGTH détermine la longueur d'une liste.

(LENGTH list)

renvoie la longueur des données de la liste.

Exemple : `(LENGTH (LIST "a" 2 42 3))' donne 4.

Voir aussi LIST.

16.15.4 FIRST

FIRST extrait le premier élément dans une liste.

(FIRST list)

renvoie le premier élément d'une liste. Si list est vide (NIL) alors NIL est retourné.

Voir aussi REST, LAST, NTH, CONS.

16.15.5 REST

REST renvoie la sous-liste après le premier élément d'une liste.

(REST list)

renvoie le reste des données d'une liste (la liste sans premier élément). Si list est vide (NIL) alors NIL est retourné.

Exemple : `(REST (LIST 1 2 3))' donne ( 2 3 ).

Voir aussi FIRST, CONS.

16.15.6 LAST

LAST extrait le dernier élément dans une liste.

(LAST list)

Renvoie le dernier élément d'une liste ou NIL si list est NIL.

Voir aussi FIRST, NTH.

16.15.7 NTH

NTH extrait le N ième élément d'une liste.

(NTH n list)

Renvoie n-nième élément des données de la liste (commençant par 0) ou NIL si l'élément n'existe pas.

Voir aussi FIRST, LAST, REPLACENTH.

16.15.8 REPLACENTH

REPLACENTH remplace le N ième élément d'une liste.

(REPLACENTH n elem list)

Retourne une liste où le n-ième élément de la liste (commençant par 0) a été remplacé par elem.

Si n est NIL ou si le n-ième élément n'existe pas, retourne NIL.

Voir aussi NTH, REPLACENTH*, MOVENTH, REMOVENTH.

16.15.9 REPLACENTH*

REPLACENTH* est la version étoilée de REPLACENTH. La seule différence avec REPLACENTH est que REPLACENTH* retourne la liste initiale, si le n-ième élément n'existe pas.

REPLACENTH* peut être implémenter comme ceci

(DEFUN REPLACENTH* (n e l)
    (LET ((r (REPLACENTH n e l)))
        (IF r r l)
    )
)

Voir aussi NTH, REPLACENTH, démo `FileList.bbs'.

16.15.10 MOVENTH

MOVENTH déplace le N-ième élément d'une liste à une nouvelle position.

(MOVENTH n m list)

Renvoie une nouvelle liste où le n-ième élément de la liste (commençant par 0) a été déplacé vers la m-ième position.

Si n ou m est NIL ou si le n-ième ou le m-ième élément n'existe pas, retourne NIL.

Exemple : `(MOVENTH 0 1 (list 1 2 3))' retourne ( 2 1 3 ).

Voir aussi NTH, MOVENTH*, REPLACENTH, REMOVENTH.

16.15.11 MOVENTH*

MOVENTH* est la version étoilée de MOVENTH. La seule différence avec MOVENTH est que MOVENTH* retourne la liste initiale, si le n-ième or le m-ième élément n'existe pas.

MOVENTH* peut être implémentée comme ceci

(DEFUN MOVENTH* (n m l)
    (LET ((r (MOVENTH n m l)))
        (IF r r l)
    )
)

Voir aussi NTH, MOVENTH, démo `FileList.bbs'.

16.15.12 REMOVENTH

REMOVENTH supprime le n-ième élément d'une liste.

(REMOVENTH n list)

Renvoie une nouvelle liste où le n-ième élément de la liste (commençant par 0) a été supprimé.

Si n est NIL ou si le n-ième élément n'existe pas, retourne NIL.

Exemple : `(REMOVENTH 1 (list 1 2 3))' retourne ( 1 3 ).

Voir aussi NTH, REMOVENTH*, REPLACENTH, MOVENTH.

16.15.13 REMOVENTH*

REMOVENTH* est la version étoilée de REMOVENTH. La seule différence avec REMOVENTH est que REMOVENTH* retourne la liste initiale, si le n-ième élément n'existe pas.

REMOVENTH* peut être implémentée comme ceci

(DEFUN REMOVENTH* (n l)
    (LET ((r (REMOVENTH n l)))
        (IF r r l)
    )
)

Voir aussi NTH, REMOVENTH, démo `FileList.bbs'.

16.15.14 APPEND

APPEND concatène des listes.

(APPEND [list ...])

renvoie la concaténation de list ....

Exemple : `(APPEND (list 1 2) (list 3 4) (list 5))' donne ( 1 2 3 4 5 ).

Voir aussi LIST.

16.15.15 REVERSE

REVERSE renverse une liste.

(REVERSE list)

renvoie la liste renversée.

Exemple : `(REVERSE (list 1 2 3))' donne ( 3 2 1 ).

16.15.16 MAPFIRST

MAPFIRST applique une fonction à tous les éléments d'une liste.

(MAPFIRST func list [...])

Établit une liste dont les éléments sont le résultat de l'application d'une fonction appelant un par un en arguments les éléments d'une liste de départ. La longueur de la liste retournée est la longueur de la plus longue liste indiquée. Si une des listes indiquées est trop courte alors la liste est rallongée par des éléments NIL.

Exemples

Expression                                    Value

(MAPFIRST 1+ (LIST 1 2 3))             ( 2 3 4 )
(MAPFIRST + (LIST 1 2 3) (LIST 2 3))   ( 3 5 NIL )

16.15.17 SORTLIST

SORTLIST Trie les éléments d'une liste.

(SORTLIST func list)

Renvoie une copie de la liste indiquée qui a été triée en utilisant la fonction func. La fonction de tri doit prendre deux arguments, un pour chaque élément comparé, et renvoyer un entièr inférieur à zéro si le premier élément est plus petit que le second, un entier supérieur à zéro si le premier élément est plus grand que le second, ou 0 si les deux éléments sont égaux.

Exemple d'une fonction de tri :

(DEFUN cmp_str (x y)
    (COND
        ((< x y) -1)
        ((> x y) 1)
        (TRUE 0)
    )
)

Maintenant vous pouvez trier une liste en appelant :

(SORTLIST cmp_str (LIST "salut" "excellent" "grand" "ok"))

qui retourne ( "excellent" "grand" "ok" "salut" ).

Voir aussi SORTLISTGT, MAPFIRST.

16.15.18 SORTLISTGT

SORTLIST tri les éléments de la liste

(SORTLISTGT gtfunc list)

Comme SORTLIST mais ici vous indiquez une fonction de tri qui renvoie une valeur différente de NIL si le premier élément est plus grand que le second, et NIL autrement.

Exemple : `(SORTLISTGT > (LIST "salut" "excellent" "grand" "ok"))' donne ( "excellent" "grand" "salut" "ok" ).

Voir aussi SORTLIST, MAPFIRST.

16.16 Fonctions de dialogue de saisie

Pour demander des informations à l'utilisateur, les fonctions suivantes peuvent être utilisées :

16.16.1 ASKFILE

ASKFILE demande à l'utilisateur de saisir un nom de fichier.

(ASKFILE title oktext default savemode)

Ouvre un sélecteur de fichier pour saisir le nom d'un fichier. Le titre de la fenêtre peut être placé dans title, le texte du bouton `Ok' dans oktext, et le nom du fichier initial dans default. Vous pouvez spécifier NIL pour l'un d'entre eux afin d'utiliser des valeurs par défauts. Le dernier argument savemode (booléen) permet d'ouvrir le sélecteur de fichier en mode sauvegarde. Ce mode devrait être utilisé lorsque le nom du fichier est destiné à y écrire quelque chose.

ASKFILE renvoie le nom de fichier écrit dans une chaîne ou NIL dans le cas où l'utilisateur aurait annulé l'opération.

Voir aussi ASKDIR, ASKSTR.

16.16.2 ASKDIR

ASKDIR demande à l'utilisateur de saisir le nom d'un répertoire.

(ASKDIR title oktext default savemode)

Ouvre le sélecteur de fichier pour saisir le nom d'un répertoire. Les arguments sont les même que ceux de ASKFILE (voir ASKFILE).

ASKDIR renvoie le nom du répertoire écrit dans une chaîne ou NIL dans le cas où l'utilisateur aurait annulé l'opération.

Voir aussi ASKFILE, ASKSTR.

16.16.3 ASKSTR

ASKSTR demande à l'utilisateur d'écrire un texte.

(ASKSTR title oktext default maxlen [secret])

Ouvre une fenêtre de saisie de texte. Le titre de la fenêtre, le texte du bouton `Ok', et la valeur initiale peuvent être placés dans title, oktext, et default respectivement (chaîne ou NIL pour des valeurs par défaut), maxlen détermine le nombre maximum de caractères que l'utilisateur peut écrire. Si secret est spécifié et n'est pas NIL alors la chaîne saisie est rendue invisible en affichant un symbole indifférencié pour chaque caractère.

ASKSTR renvoie le texte entré ou NIL au cas où l'utilisateur annulerait l'opération.

Voir aussi ASKFILE, ASKDIR, ASKCHOICESTR, ASKINT.

16.16.4 ASKINT

ASKINT demande à l'utilisateur à saisir un nombre entier.

(ASKINT title oktext default min max)

Ouvre une fenêtre de saisie de nombre entier. Le titre de fenêtre et le texte du bouton `Ok' peuvent être spécifiés dans title et oktext (chaîne ou NIL pour des valeurs par défaut). Dans default vous passez la valeur initiale du nombre entier ou NIL pour démarrer avec un champ d'édition vide. Dans min et max vous pouvez indiquer l'intervalle de validité du nombre entier. Les valeurs entrées en dehors de cet intervalle sont automatiquement rejetées. Utilisez NIL pour les valeurs par défaut de min et max.

ASKINT renvoie le nombre entier saisie ou NIL si l'utilisateur annule l'opération.

Voir aussi ASKSTR.

16.16.5 ASKCHOICE

ASKCHOICE demande à l'utilisateur à choisir un élément parmi d'autres.

(ASKCHOICE titre oktext choix defaut [titres])

Ouvre une fenêtre de saisie demandant à l'utilisateur de choisir un élément dans une liste. Vous pouvez placer le titre de la fenêtre et le texte du bouton `Ok' dans titre et oktext (chaîne ou NIL pour des valeurs par défaut). Dans choix vous indiquez une liste de choix. Vous pouvez utiliser un format multi-colonnes pour présenter chaque choix comme une liste de sous-éléments. La valeur initiale peut être placée dans defaut, il s'agit de l'index de la ligne dans le mémo (en commençant par l'index 0 pour le premier élément). Utilisez NIL pour ne pas spécifier de valeur initiale. Si l'argument optionnel titre est spécifié et n'est pas NIL, alors un entête de colonne est affiché dans la liste en utilisant les titres contenus dans titres. Dans le cas de colonnes multiples, spécifiez titles comme une liste de titres de colonne.

choix et titres peuvent tous les deux être aussi représentés par un mémo et une chaîne (au lieu de listes). Dans ce cas ils sont convertis en listes par un appel automatique à (MEMOTOLIST choices TRUE) (voir MEMOTOLIST) et (STRTOLIST titles) (voir STRTOLIST) respectivement.

ASKCHOICE renvoie l'index de l'élément choisi ou NIL si l'utilisateur a annulé l'opération.

Exemple

(LET ((items (LIST "Première entrée" 2 3.14 "Dernière entrée")) index)
    (SETQ index (ASKCHOICE "Choisissez un élément" "Ok" items NIL))
    (IF index
        (PRINTF "L'utilisateur a choisi l'élément numéro %i avec le contenu <%s>\n"
            index (STR (NTH index items))
        )
    )
)

Considérez le cas où vous voulez demander à l'utilisateur de sélectionner un enregistrement particulier dans une table. La table doit se nommer `Article' et posséder les champs `Nom', `Quantite', et `Prix'. Le bout de code suivant montre comment utiliser ASKCHOICE pour sélectionner un enregistrement avec un prix inférieur à 10 et ordonnés par leur Nom :

(LET ((query (SELECT Article, Nom, Quantite, Prix from Article 
	      WHERE (> Prix 10) ORDER BY Nom))
     (recs (MAPFIRST FIRST (REST query)))	; record pointers
     (items (MAPFIRST REST (REST query)))	; choices
     (titles (REST (FIRST query)))		; titles
     (index (ASKCHOICE "Sélection" "Ok" items NIL titles))
     (rec (NTH index recs)))
     ; now rec holds the selected record (or NIL on cancel)
)

Voir aussi ASKCHOICESTR, ASKOPTIONS.

16.16.6 ASKCHOICESTR

ASKCHOICESTR demande à l'utilisateur de choisir un chaîne parmi une liste prédéfinie.

(ASKCHOICESTR titre oktext chaines defaut [titres])

Ouvre une fenêtre de saisie demandant à l'utilisateur de choisir une chaîne dans une liste ou d'en saisir une dans un champ texte séparé. Vous pouvez placer le titre de fenêtre et le texte du bouton `Ok' dans titre et oktext (chaîne ou NIL pour des valeurs par défaut). Dans chaines vous indiquez la liste de choix. Vous pouvez utiliser un format multi-colonnes pour présenter chaque choix comme une liste de sous-éléments. La valeur initiale du champ texte peut être placée dans defaut (chaîne ou NIL pour un champ texte vide). Si l'argument optionnel titre est spécifié et n'est pas NIL, alors un entête de colonne est affiché dans la liste en utilisant les titres contenus dans titres. Dans le cas de colonnes multiples, spécifiez titles comme une liste de titres de colonne.

choix et titres peuvent tous les deux être aussi représentés par un mémo et une chaîne (au lieu de listes). Dans ce cas ils sont convertis en listes par un appel automatique à (MEMOTOLIST choices TRUE) (voir MEMOTOLIST) et (STRTOLIST titles) (voir STRTOLIST) respectivement.

ASKCHOICESTR renvoie la chaîne choisie ou NIL si l'utilisateur a fermé la fenêtre.

Exemple

(LET ((strings (LIST "Claudia" "Mats" "Ralphie")) likebest)
    (SETQ likebest
        (ASKCHOICESTR "Qui aimes-tu le plus ?" "Ok" strings 
	    "Mes chiens!"
	)
    )
    (IF likebest (PRINTF "L'utilisateur a choisi <%s>\n" likebest))
)

Voir aussi ASKCHOICE, ASKOPTIONS.

16.16.7 ASKOPTIONS

ASKOPTIONS demande à l'utilisateur de sélectionner plusieurs éléments dans une liste.

(ASKOPTIONS titre oktext options selectionnes [titres])

Ouvre une fenêtre de saisie demandant à l'utilisateur de sélectionner une ou plusieurs options dans une liste. Vous pouvez placer le titre de la fenêtre et le texte du bouton `Ok' dans titre et oktext (chaîne ou NIL pour des valeurs par défaut). Dans options vous indiquez la liste d'options. Vous pouvez utiliser un format multi-colonnes pour présenter chaque option comme une liste de sous-éléments. La sélection initiale peut être spécifiée dans selectionnes sous forme d'une liste de nombres entiers spécifiant l'index des lignes correspondantes dans options qui doivent être sélectionnées au début. Utilisez NIL pour tous les éléments ne devant pas être présélectionnés. Si l'argument optionnel titre est spécifié et n'est pas NIL, alors un entête de colonne est affiché dans la liste en utilisant les titres contenus dans titres. Dans le cas de colonnes multiples, spécifiez titles comme une liste de titres de colonne.

choix et titres peuvent tous les deux être aussi représentés par un mémo et une chaîne (au lieu de listes). Dans ce cas ils sont convertis en listes par un appel automatique à (MEMOTOLIST choices TRUE) (voir MEMOTOLIST) et (STRTOLIST titles) (voir STRTOLIST) respectivement.

ASKOPTIONS renvoie une liste de nombres entiers correspondant à l'index des éléments sélectionnés ou NIL dans le cas où l'utilisateur aurait annulé l'opération ou n'aurait pas choisi d'élément.

Exemple

(LET ((options (LIST "Salva Mea" "Insomnia" "Don't leave" "7 days & 1 week"))
        (selected (LIST 0 1 3))
    )
    (SETQ selected (ASKOPTIONS "Choisir un titre" "Ok" options selected))
    (IF selected
        (
            (PRINTF "L'utilisateur a choisi les titres suivants :\n")
            (DOLIST (i selected)
                (PRINTF "\tnum: %i contenu : <%s>\n" i (STR (NTH i options)))
            )
        )
    )
)

16.16.8 ASKBUTTON

ASKBUTTON demande à l'utilisateur de cliquer sur un bouton.

(ASKBUTTON title text buttons canceltext)

Ouvre une fenêtre de dialogue avec un titre (chaîne ou NIL pour un titre par défaut) et une description (chaîne ou NIL s'il n'y en a pas). La fonction attend jusqu'à ce que l'utilisateur clique sur un des boutons indiqués dans buttons (liste de chaînes) ou le bouton `Annuler'. Le texte du bouton d'annulation peut être spécifié dans canceltext. Si vous indiquez NIL un texte par défaut basé sur le nombre de boutons que vous avez indiqué est employé.

ASKBUTTON renvoie le numéro du bouton cliqué (à partir de 0, pour le bouton à l'extrême gauche) ou NIL si l'utilisateur clique sur le bouton `Annuler'.

Exemples

(LET ((buttons (LIST "A la maison" "Au lit" "Devant mon ordinateur")) index)
    (SETQ index (ASKBUTTON "Veuillez répondre :"
        "Où voudriez-vous être demain ?" buttons "Je ne sais pas")
    )
    (IF index
        (PRINTF "Choix de l'utilisateur : <%s>\n" (NTH index buttons))
    )
)

(ASKBUTTON "Info" "BeeBase est génial !" NIL NIL)

Voir aussi ASKCHOICE.

16.16.9 ASKMULTI

ASKMULTI demande à l'utilisateur de saisir divers types d'informations.

(ASKMULTI title oktext itemlist)

ASKMULTI est une fonction de dialogue à usages multiples. Elle ouvre une fenêtre avec le titre indiqué, un ensemble d'objets d'IHM pour l'édition de données, et deux boutons (`Ok' et `Annuler') pour fermer la requête. Le texte du bouton `Ok' peut être placé dans oktext (chaîne ou NIL pour le texte de défaut). L'ensemble des objets d'IHM sont spécifiés dans itemlist qui est une liste où chaque élément a l'une des formes suivantes :

    (LIST title "String" initial [help [secret]])   pour une ligne de texte,
    (LIST title "Memo" initial [help])     pour plusieurs lignes de texte,
    (LIST title "Integer" initial [help])  pour un nombre entier,
    (LIST title "Real" initial [help])     pour un réel,
    (LIST title "Date" initial [help])     pour une date,
    (LIST title "Time" initial [help])     pour une heure,
    (LIST title "Bool" initial [help])     pour un booléen,
    (LIST title "Choice" initial
        (LIST choice ...) [help]
    )                                      pour un champ choix.
    (LIST title "ChoiceList" initial
        (LIST choice ...) [help]
    )                                      pour choisir un élément dans une liste.
    (LIST title "Options" initial
        (LIST option ...) [help]
    )                                      pour choisir plusieurs éléments dans une liste.
    non-list-expr                          pour un texte non modifiable

Le titre (chaîne ou NIL s'il n'y a pas de titre) sera affiché à la gauche de l'objet d'IHM. Si la valeur initiale est NIL la valeur par défaut est utilisée (par exemple un champ Texte vide). Pour les champs de choix la valeur initiale doit être l'index (commençant à 0) de l'entrée initialement active. Pour les champs de liste de choix la valeur initiale peut être NUL (pas d'élément actif). Pour les champs d'option la valeur initiale doit être une liste d'entiers représentants les indices (commençant à 0) des éléments sélectionnés au départ. Le champ d'aide optionnel peut être utilisé pour renseigner l'utilisateur sur l'utilisation du champ. Pour les champs text un paramètre supplémentaire `secret' peut être spécifié. S'il n'est pas NIL alors le contenu du champ texte est masqué par des symboles indifférents pour chacun de ses caractères.

ASKMULTI renvoie une liste de valeurs que l'utilisateur a édités et validés en cliquant sur le bouton `Ok'. Chaque valeur d'un champ a le même format que celui de la valeur initiale. Par exemple pour le choix d'une liste de champs la valeur résultat est l'index de l'élément choisi (ou NIL si aucun élément n'a été choisi) ou pour une option, la valeur résultat est une liste de nombres entiers représentant les index des éléments choisis. Pour le ttexte non modifiable une valeur NIL est retournée.

Par exemple si vous avez indiqué un champ date, un champ texte non modifiable, un champ choix, un champ option et une champ texte avec la valeur initiale "world", et que l'utilisateur a écrit 11.11.1999, choisi l'entrée avec l'index numéro 2, choisi le 3ème et 4ème élément dans le champ option, et laissé le champ texte intact alors la fonction renvoie la liste ( 11.11.1999 NIL 2 ( 3 4 ) "world" ).

Si l'utilisateur a annulé l'opération, NIL est retourné.

Exemple

(ASKMULTI "Veuillez répondre :" NIL (LIST
    (LIST "N_om" "String" "")
    (LIST "_Naissance" "Date" NIL)
    (LIST "_Sexe" "Choice" 0 (LIST "homme" "femme"))
    (LIST "Possède une _voiture ?" "Bool" NIL)
    (LIST "_Aime" "Options" (LIST 0 2)
        (LIST "Bière" "Vin" "Whisky" "Wodka" "Schnaps")
    ))
)

Consultez le projet `AskDemo.bbs' pour d'autres exemples.

16.17 Fonctions d'E/S

Cette section liste les fonctions et les variables d'entrées/sortie des données (par exemple l'impression).

16.17.1 FOPEN

FOPEN ouvre un fichier en lecture/écriture.

(FOPEN nomfichier mode [encodage])

Ouvre le fichier spécifié par nomfichier (string). Le paramètre mode (string) contrôle le mode d'accès. Utilisez `"w"' pour ouvrir un fichier en écriture, `"a"' pour y ajouter des données ou `"r"' pour y lire des données. Vous pouvez aussi utiliser d'autres drapeaux (ou combinaison de drapeaux) comme `"r+"' pour lire et écrire. Aucun contrôle de validité des drapeaux n'est effectué. Si le fichier ne peut être ouvert, l'instruction renvoie NIL.

Le paramètre optionnel encodage contrôle l'encodage du fichier et peut prendre l'une des chaînes suivantes pour valeur :

`"none"' :

Aucune interprétation de caractère n'est effectuée. Utilisez ceci pour les fichiers binaires.

`"UTF-8"' :

Le texte est encodé en UTF-8. La lecture et l'écriture convertissent depuis/en UTF-8.

`"locale"' :

Le texte est encodé selon les réglages de votre système. Sur Linux, c'est le contenu des variables d'environnement LANG et LC_*, voir man locale. Sur Windows, c'est la page de code du système. Sur Amiga, c'est l'encodage à 8-bit par défaut.

`"8-bit"' :

Le texte est encodé selon l'encodage 8-bit par défaut. Sur Linux et Windows, il s'agit de l'encodage ISO-8859-1 (latin 1). Sur Amiga, il s'agit de l'encodage 8-bit par défaut du système (comme `locale').

`"auto"' :

L'encodage est détecté automatiquement. Si le fichier est lisible alors l'encodage est déterminé comme suit : Si l'intégralité du contenu est conforme à UTF-8 alors `"UTF-8"' est utilisé. Sinon, si la locale du système n'est pas UTF-8 alors `"locale"' est utilisé. Autrement, c'est `"8-bit"' qui est utilisé. Lors de l'écriture, si l'encodage n'a pas encore été déterminé, alors la première locale du système rencontrée est essayée. Si aucune erreur de conversion ne se produit, c'est `"locale"' qui est utilisé, sinon `"UTF-8"'.

Si aucun paramètre encodage n'est spécifié, c'est `"auto"' qui est utilisé.

En cas de succès, FOPEN renvoie un descripteur de fichier. En cas d'échec, c'est NIL qui est renvoyé. Si nomfichier, mode ou encodage sont à NIL, c'est NIL qui est renvoyé.

Exemples

`(FOPEN "index.html" "w" "utf-8")' ouvre et renvoie un descripteur de fichier pour écrire dans le fichier `index.html' avcec l'encodage UTF-8.

`(FOPEN "output.txt" "a+")' ouvre le fichier `output.txt' pour y ajouter des données dans le même encodage que celui du fichier. Remarquez que si vous spécifiez uniquement `"a"' pour mode, BeeBase peut ne pas être en mesure de lire le fichier et de déterminer son encodage. Dans ce cas, l'encodage sera déterminé au moment de l'écriture (et pourrait être différent de celui de la première partie du fichier).

Voir aussi FCLOSE, stdout, FFLUSH.

16.17.2 FCLOSE

FCLOSE ferme un fichier.

(FCLOSE file)

Ferme le fichier donné. Renvoie 0 en cas de succès, NIL si une erreur s'est produite. Si file est NIL alors 0 est retourné (aucune erreur). Après la fermeture du fichier l'accès au descripteur de fichier est une opération illégale et interrompt l'exécution du programme avec un message d'erreur.

Voir aussi FOPEN, FFLUSH.

16.17.3 stdout

La variable globale stdout conserve le descripteur de fichier vers la sortie standard de BeeBase. Le nom du fichier de sortie peut être réglé depuis le menu `Programme - fichier de sortie' (voir Fichier de sortie du programme).

Le fichier de sortie est ouvert au premier accès à cette variable (par exemple en appelant `(FPRINTF stdout ...)' ou `(PRINTF ...)'). Le fichier n'est ouvert automatiquement au démarrage de BeeBase, afin d'éviter une ouverture si aucune sortie n'est générée. Par exemple lorsque vous voulez seulement effectuer quelques calculs et changer le contenu de certains enregistrements.

Lors de l'ouverture du fichier de sortie, le paramètre de mode peut être soit `"w"', soit `"a+"' en fonction du réglage `Ajouter' du menu `Programme - Fichier de sortie'. L'encodage est réglé à `"auto"'.

Si BeeBase ne peut pas ouvrir le fichier de sortie le programme s'arrête et un message d'erreur est produit.

Voir aussi FOPEN, PRINTF.

16.17.4 PRINT

PRINT convertit une expression en chaîne et l'affiche.

(PRINT elem)

Convertit la valeur de elem en chaîne lisible et l'imprime dans stdout. Cette fonction existe principalement pour le débogage (la mise au point). This function is not considered having a side effect such that it can be used e.g. in debugging a comparison function.

Voir aussi PRINTF, stdout, Fonction de comparaison.

16.17.5 PRINTF

PRINTF imprime une chaîne formater.

(PRINTF format [expr ...])

Formate une chaîne en utilisant les données du format chaîne et arguments pour l'imprimer dans stdout. Le formatage est fait comme dans SPRINTF (voir SPRINTF).

PRINTF renvoie le nombalors NIL est retourné.

Cette fonction n'est pas considérée comme ayant un effet secondaire pour qu'elle puissepeut être utilisée par ex. dans le débogage d'une fonction de comparaison.

Exemple : `(PRINTF "%i jours et %i semaine" 7 1)' imprime la chaîne "7 jours et 1 semaine" dans stdout et renvoie 17.

Voir aussi PRINT, FPRINTF, stdout, Fonction de comparaison.

16.17.6 FPRINTF

FPRINTF imprime une chaîne formatée dans un fichier.

(FPRINTF file format [expr ...])

Formate une chaîne en utilisant les données du format chaîne et arguments pour l'imprimer dans le fichier spécifié. Le formatage est fait comme dans SPRINTF (voir SPRINTF).

FPRINTF renvoie le nombre de caractères en sortie ou NIL en cas d'échec. Si file est NIL alors FPRINTF renvoie toujours le nombre de caractères potentiellement écrits mais rien n'est réellement écrit en sortie. Si format est NIL alors NIL est retourné.

Voir aussi PRINTF, FOPEN.

16.17.7 FERROR

FERROR vérifie si un fichier produit une erreur d'entrée/sortie.

(FERROR file)

renvoie TRUE si une erreur s'est produite, NIL autrement. Si `file' est NIL, NIL est retourné.

Voir aussi FEOF, FOPEN, FCLOSE.

16.17.8 FEOF

FEOF vérifie l'état de fin de fichier.

(FEOF file)

Examine l'indicateur de fin de fichier d'un fichier donné et renvoie TRUE s'il est vrai. Autrement NIL est retourné. Si le `file' est NIL, NIL est retourné.

Voir aussi FERROR, FTELL, FOPEN, FCLOSE.

16.17.9 FSEEK

FSEEK définit la position de lecture/écriture d'un fichier.

(FSEEK file offset whence)

Définit la position de lecture/écriture pour un fichier donné. La nouvelle position, mesurée en octets, est obtenue en ajoutant des offset octets à la position spécifiée par whence. Si whence est placé sur SEEK_SET, SEEK_CUR ou SEEK_END, offset se reporte respectivement au début du fichier, à la position actuelle ou à la fin du fichier.

En cas de succès, FSEEK renvoie 0. Sinon NIL est retourné et la position dans le fichier reste inchangée. Si file, offset ou whence sont NIL ou si whence n'est pas une des constantes SEEK_SET, SEEK_CUR ou SEEK_END, alors NIL est retourné.

Veuillez noter qu'après une lecture l'appel à FSEEK avec une valeur whence pour SEEK_BUR n'est supporté que pour l'encodage `"none"'.

Voir aussi FTELL, FOPEN, Constantes prédéfinies.

16.17.10 FTELL

FTELL renvoie la position de lecture/écriture d'un fichier.

(FTELL file)

Détermine la position de lecture/écriture courante d'un fichier donné par rapport au début du fichier et la renvoie comme un nombre entier. Si une erreur se produit ou si `file' est NIL, alors NIL est retourné.

Veuillez noter qu'après une lecture l'appel à FSEEK avec une valeur whence pour SEEK_BUR n'est supporté que pour l'encodage `"none"'.

Voir aussi FSEEK, FOPEN, FEOF.

16.17.11 FGETCHAR

FGETCHAR lit un caractère à partir d'un fichier.

(FGETCHAR file)

Renvoie le prochain caractère à partir d'un fichier donné de la chaîne ou NIL si file est NIL, si la fin du fichier à été atteinte ou si une erreur s'est produite. Si le prochain caractère est un caractère nul, une chaîne vide est retournée.

Voir aussi FGETCHARS, FGETSTR, FPUTCHAR.

16.17.12 FGETCHARS

FGETCHARS lit des caractères à partir d'un fichier.

(FGETCHARS num file)

renvoie une chaîne contenant les num prochains caractères depuis un fichier donné Si la fin du fichier a été atteinte avant la lecture des num caractères ou si un caractère nul a été lu alors les caractères déjà lus sont retournés. Si num ou file sont NIL, si num est négative, si la fin du fichier a été atteinte avant de lire le premier caractère ou si une erreur de lecture c'est produite, NIL est retourné.

Voir aussi FGETCHAR, FGETSTR.

16.17.13 FGETSTR

FGETSTR lit une chaîne à partir d'un fichier.

(FGETSTR file)

renvoie la prochaine ligne d'un fichier donné comme une chaîne ou NIL si file est NIL, la fin du fichier a été atteint, ou une erreur s'est produite. La fin d'une ligne est détectée soit par une nouvelle ligne de caractères, soit par la lecture d'un caractère nul, soit si la fin du fichier est détectée. Dans l'un ou l'autre cas la chaîne ne contient aucune nouvelle ligne de caractères.

Voir aussi FGETCHAR, FGETCHARS, FGETMEMO, FPUTSTR.

16.17.14 FGETMEMO

FGETMEMO lit un mémo à partir d'un fichier.

(FGETMEMO file)

renvoie un mémo qui contient le contenu d'un fichier donné jusqu'au prochain caractère nul ou jusqu'à la fin du fichier. Si file est NIL, la fin du fichier a été atteinte avant de lire tous les caractères, ou une erreur s'est produite alors NIL est retourné.

Voir aussi FGETSTR, FPUTMEMO.

16.17.15 FPUTCHAR

FPUTCHAR écrit un caractère dans un fichier.

(FPUTCHAR str file)

Écrit le premier caractère de str dans un fichier donné. Si str est vide, un caractère nul est écrit, si str ou file sont NIL, rien ne se produit. Renvoie str ou NIL au cas où une erreur se produirait.

Voir aussi FPUTSTR, FGETCHAR.

16.17.16 FPUTSTR

FPUTSTR écrit une chaîne dans un fichier.

(FPUTSTR str file)

Imprime str ainsi qu'une nouvelle ligne de caractères dans un fichier donné. Si str ou file sont NIL, rien ne se produit. Renvoie str ou NIL au cas où une erreur se produirait.

Voir aussi FPUTCHAR, FPUTMEMO, FGETSTR.

16.17.17 FPUTMEMO

FPUTMEMO écrit un mémo dans un fichier.

(FPUTMEMO memo file)

Imprime memo dans un fichier donné. Si memo ou file sont NIL, rien ne se produit. Renvoie memo ou NIL au cas où une erreur de sortie se produirait.

Voir aussi FPUTSTR, FGETMEMO.

16.17.18 FFLUSH

FFLUSH purge les données en attente vers un fichier.

(FFLUSH file)

Purge toutes les données en attente d'écriture pour le fichier spécifié. Renvoie 0 en cas de succès, NIL si une erreur se produit. Si file est NIL alors 0 est retourné (aucune erreur).

Voir aussi FOPEN, FCLOSE.

16.18 Fonctions sur les enregistrements

Cette section énumère les fonctions qui traitent des enregistrements.

16.18.1 NEW

NEW alloue un nouvel enregistrement pour une table.

(NEW table init)

Alloue un nouvel enregistrement pour une table donnée. Le paramètre init spécifie l'enregistrement qui doit être utilisé pour initialiser le nouvel enregistrement. La valeur NIL représente l'enregistrement initial.

NEW renvoie un indicateur d'enregistrement pour le nouvel enregistrement.

La fonction NEW a un effet secondaire qui initialise le programme pointant les enregistrements d'une table donnée (voir Tables) vers un nouvel enregistrement.

Exemple : `(NEW table NIL)' alloue un nouvel enregistrement dans une table donnée et l'initialise avec l'enregistrement initial.

Voir aussi NEW*, DELETE, Tables.

16.18.2 NEW*

NEW* est la version étoilée de NEW (voir NEW).

(NEW* table init)

NEW* vérifie si vous avez spécifié un déclencheur de `Création' pour la table donnée (voir Déclencheur de création). Si c'est le cas, cette fonction est appelée pour allouer l'enregistrement et son résultat est retourné. Le paramètre init peut être utilisé pour spécifier l'enregistrement avec lequel le nouvel enregistrement devrait être initialisé (utilisez NIL pour un enregistrement initial).

Si aucun déclencheur n'a été spécifié, la fonction se comporte comme la fonction NEW.

Avertissement : Avec cette fonction il est possible d'écrire des boucles sans fin, par exemple si vous avez défini un déclencheur de `Création' pour une table et qu'il appelle NEW* pour allouer les enregistrements.

Voir aussi NEW, DELETE*.

16.18.3 DELETE

DELETE supprime les enregistrements dans une table.

(DELETE table confirm)

Supprime les enregistrements du programme en cours d'une table donnée après une demande de confirmation facultative. Le premier argument indique la table dans laquelle les enregistrements du programme en cours devraient être supprimés, le deuxième argument est une expression booléenne. Si c'est NIL alors l'enregistrement est supprimé sans confirmation, sinon l'état du menu préférences `Confirmer la suppression des enregistrements' est vérifié. S'il n'est pas coché, l'enregistrement est supprimé sans confirmation, autrement une fenêtre de confirmation standard apparaît vous demandant si vous voulez vraiment effacer cet enregistrement. Si l'utilisateur clique sur le bouton annuler, l'enregistrement ne sera pas supprimé.

Le code renvoyé par la fonction DELETE reflète l'action choisie. S'il renvoie TRUE alors l'enregistrement a été supprimé, sinon (l'utilisateur a annulé l'opération) NIL est retourné.

À propos de la suppression, DELETE place le pointeur du programme d'enregistrement (voir les voir Tables) de la table spécifiée sur NIL.

Exemple : `(DELETE table NIL)' supprime, sans confirmation, l'enregistrement dans la table de données courante.

Voir aussi DELETE*, DELETEALL, NEW, Tables.

16.18.4 DELETE*

DELETE* est la version étoilée de DELETE (voir DELETE).

(DELETE* table confirm)

DELETE* vérifie si vous avez spécifié un déclencheur de `Suppression' pour la table donnée (voir Déclencheur de suppression). Si c'est le cas, alors cette fonction est appelée pour supprimer l'enregistrement et son résultat est retourné. Le paramètre confirm peut être utilisé pour indiquer si le déclencheur appelle la fenêtre de confirmation avant de supprimer l'enregistrement.

Si aucun déclencheur n'a été spécifié, la fonction se comporte comme la fonction DELETE.

Avertissement : Avec cette fonction il est possible d'écrire des boucles sans fin, par exemple si vous avez défini un déclencheur de `Suppression' pour une table et qu'il appelle DELETE* pour supprimer l'enregistrement.

Voir aussi DELETE, DELETEALL, NEW*.

16.18.5 DELETEALL

DELETEALL supprime tous les enregistrements d'une table.

(DELETEALL table[*])

Supprime tous les enregistrements de la table indiquée. si vous ajoutez une étoile derrière le nom de la table seul les enregistrements du filtre de la table en cours seront supprimés. Il n'y a pas de fenêtre de confirmation avant de supprimer les enregistrements.

DELETEALL renvoie TRUE en cas de succès pour la suppression de tous les enregistrements, sinon NIL est retourné. Si la table est NIL alors NIL est retourné.

Exemple : `(DELETEALL table*)' supprime, en utilisant le filtre de la table, tous les enregistrements de la table de données.

Voir aussi DELETE, Tables.

16.18.6 GETMATCHFILTER

GETMATCHFILTER renvoie l'état du filtre d'enregistrement.

(GETMATCHFILTER rec)

Renvoie TRUE si les enregistrements disposent d'un filtre dans la table, NIL dans les autres cas. Si le filtre de la table courante n'est pas actif, alors TRUE est retourné. Si rec est NIL (l'enregistrement initial) alors NIL est retourné.

Voir aussi SETMATCHFILTER, GETISSORTED, GETFILTERSTR, SETFILTERSTR.

16.18.7 SETMATCHFILTER

SETMATCHFILTER définit l'état du filtre d'un enregistrement.

(SETMATCHFILTER rec on)

Change l'état du filtre de l'enregistrement indiqué à la valeur on. SETMATCHFILTER renvoie le nouvel état du filtre de l'enregistrement donné. Le nouvel état peut être différent de ce qui était prévu parce que le réglage de l'état du filtre vers NIL fonctionne seulement quand le filtre de la table correspondante est en activité, sinon TRUE est retourné. Appelez SETMATCHFILTER avec la valeur NIL pour rec (l'enregistrement initial) renverra toujours NIL.

Voir aussi GETMATCHFILTER, SETISSORTED, GETFILTERSTR, SETFILTERSTR.

16.18.8 GETISSORTED

GETISSORTED renvoie l'état du type d'enregistrement.

(GETISSORTED rec)

Renvoie TRUE si l'enregistrement spécifie le type de tri qui a été défini pour sa table, NIL dans les autres cas. Si rec est NIL alors NIL est retourné.

Voir aussi SETISSORTED, GETMATCHFILTER, REORDER, GETORDERSTR, SETORDERSTR, Fonction de comparaison.

16.18.9 SETISSORTED

SETISSORTED modifie l'indicateur de tri de l'enregistrement.

(SETISSORTED rec on)

Change l'indicateur de tri de l'enregistrement spécifié par la valeur on. Utilisez cette fonction si vous pensez que certains enregistrements sont dans le bon ordre (on = TRUE) ou s'ils doivent être réordonnés (on = NIL). Le réordonnancement de tous les enregistrements qui ne sont pas triés peut être réalisé en appelant la fonction REORDER (voir voir REORDER).

SETISSORTED renvoie la nouvelle valeur de l'indicateur pour l'enregistrement donné. Appeler SETISSORTED avec la valeur NIL pour rec (l'enregistrement initial) renverra NIL.

Pour un exemple sur la façon d'employer cette fonction, voir Fonction de comparaison.

Voir aussi GETISSORTED, SETMATCHFILTER, REORDER, GETORDERSTR, SETORDERSTR, Fonction de comparaison.

16.18.10 GETREC

GETREC renvoie la référence d'enregistrement d'une expression.

(GETREC expr)

Renvoie l'enregistrement qui a été utilisé lors de la création de expr. Les expressions créées à partir d'un champ dans une table ont l'enregistrement d'où elles proviennent défini comme référence d'enregistrement.

Si expr est une liste et n'a elle-même pas de référence d'enregistrement alors GETREC renvoie l'enregistrement du premier élément de la liste qui a une référence d'enregistrement. GETREC n'examine cependant pas les sous-listes.

Si aucune référence d'enregistrement n'a été trouvée, GETREC renvoie NIL.

La fonctionnalité d'examen des éléments d'une liste est pratique lors de l'obtention de la référence d'enregistrement d'une ligne dans une requête select-from-where. Par exemple, le fragment de code suivant renvoie l'enregistrement qui a été utilisé lors de la création de la 7ème ligne dans une requête select-from-where :

(GETREC (NTH 7 (SELECT field FROM table)))

Cette fonction est utile, par ex. dans une fonction de déclenchement de suppression de tri pour une liste virtuelle, voir Déclencheur de tri-déplacement.

Voir aussi SETREC, RECORD, Déclencheur de tri-déplacement.

16.18.11 SETREC

SETREC définit la référence d'enregistrement d'une expression.

(SETREC expr record)

Renvoie expr avec une référence d'enregistrement définie sur record.

SETREC est utile lorsqu'une expression doit être associée à un certain enregistrement, par ex. lors du calcul d'informations dérivées d'un champ dans une table. Par exemple, dans une table `Person' avec un champ booléen `Female', une requête select-from-where pourrait mapper `Female' aux chaînes "F" et "M" :

SELECT (SETREC (IF Female "F" "M") Person) FROM Person

Avec la commande SETREC, "F" et "M" sont associés à l'enregistrement dont ils sont dérivés, ce qui, par exemple, permet à une liste virtuelle utilisant ce support de requête d'ouvrir l'enregistrement correspondant par un double clic (voir Éditeur de champ)

Voir aussi GETREC.

16.18.12 RECNUM

RECNUM renvoie le numéro d'un enregistrement.

(RECNUM record)

Renvoie le numéro d'un enregistrement donné. Veuillez noter que la numérotation des enregistrements est différente de celle utilisée par exemple pour les listes. Pour les listes, les chaînes et autres, le compte commence à zéro. Toutefois, pour les enregistrements, il commence à 1 pour le premier enregistrement. Le numéro 0 est réservé à l'enregistrement initial. Cela semble être contradictoire avec le reste des fonctions de programmation de BeeBase, mais prend ici vraiment son sens lorsque les numéros d'enregistrement sont également utilisés dans la fenêtre d'affichage.

Voir aussi RECORDS, MOVEREC, INT.

16.18.13 MOVEREC

MOVEREC déplace un enregistrement vers une nouvelle position.

(MOVEREC record pos)

Déplace l'enregistrement donné à la position donnée de la table de sorte que le numéro d'enregistrement devienne pos. Notez que les numéros d'enregistrement commencent par 1 pour la première position. Renvoie le nouveau numéro d'enregistrement ou NIL si le déplacement a échoué, par ex. si pos n'est pas compris entre 1 et le nombre d'enregistrements dans la table.

Si l'enregistrement a été déplacé, efface également l'état trié de l'enregistrement. Notez que si la table a un ordre défini, la réorganisation des enregistrements dans la table remettra l'enregistrement à sa place. Ainsi, cette fonction est principalement utile pour les tables qui n'ont pas d'ordre défini.

Cette fonction est utile dans une fonction de déclenchement de suppression de tri pour une liste virtuelle, voir Sort drop trigger.

Voir aussi RECNUM, GETISSORTED, Déclencheur de tri-déplacement.

16.18.14 COPYREC

COPYREC copie les enregistrements.

(COPYREC rec source)

Copie le contenu de l'enregistrement source dans l'enregistrement rec. Si source est NIL alors rec est initialisé à la valeur de l'enregistrement initial. Si rec est NIL alors, un message d'erreur est généré.

COPYREC renvoie rec.

Voir aussi NEW.

16.19 Fonctions sur les champs

Cette section énumère les fonctions qui travaillent sur les champs d'une table.

16.19.1 FIELDNAME

FIELDNAME renvoie le nom d'un champ.

(FIELDNAME field)

Renvoie une chaîne contenant le nom d'un champ indiqué.

Voir aussi TABLENAME

16.19.2 MAXLEN

MAXLEN renvoie la taille maximum du champ d'une chaîne.

(MAXLEN string-field)

Renvoie le nombre maximum de caractères que le champ d'une chaîne donné peut contenir.

Voir aussi LEN.

16.19.3 GETLABELS

GETLABELS renvoie toutes les entrées d'un choix ou d'une chaîne.

(GETLABELS field)

Renvoie les entrées d'un champ choix ou chaîne donné. Dans le cas d'un champ choix les entrées que vous avez entrées saisies la fenêtre de saisie du champ (voir Réglages liés au type de champ) sont retournées, dans le cas du champ chaîne les entrées statiques saisies dans la liste déroulante (voir Éditeur de champ) sont retournées (notez que cette fonction n'est utile que pour des entrées statiques).

Les entrées sont retournées dans une seule chaîne et sont séparées par un caractère de retour à la ligne.

Par exemple, si vous considérez que vous avez un champ choix avec les entrées `Voiture', `Maison', et `Huile'. En appelant GETLABELS sur ce champ vous obtiendrez le résultat "Voiture\nMaison\nHuile" dans une chaîne.

Note: vous pouvez facilement convertir la chaîne résultat en une liste en appelant MEMOTOLIST (voir MEMOTOLIST) avec cette chaîne.

Voir aussi SETLABELS.

16.19.4 SETLABELS

SETLABELS est utilisé pour placer les entrées d'un champ dans une chaîne.

(SETLABELS field str)

Définit les entrées statiques du champ chaîne field à partir des entrées listées dans l'argument str . L'argument str se compose de lignes qui comportent une entrée. Les entrées remplacent celles que vous avez entrées dans la liste de l'éditeur de champ objet (voir Éditeur de champ). Notez que cette fonction n'est utile que pour des entrées statiques.

SETLABELS renvoie la valeur de l'argument str.

Exemple : `(SETLABELS Table.String "Ma maison\nest\nvotre maison")' définit les entrées statiques dans la liste d'affichage et indique le champ de la chaîne `Ma maison', `est', et `votre maison'.

Note: vous pouvez facilement convertir une liste d'entrées dans le format requit par une chaîne en appelant LISTTOMEMO sur la liste.

Voir aussi GETLABELS.

16.20 Fonctions sur les tables

16.20.1 TABLENAME

TABLENAME renvoie le nom d'une table.

(TABLENAME table)

Renvoie une chaîne contenant le nom de la table indiquée.

Voir aussi FIELDNAME

16.20.2 GETORDERSTR

GETORDERSTR renvoie un enregistrement trié dans une table.

(GETORDERSTR table)

Renvoie l'expression courante de tri pour les données d'une table. Si la table utilise une liste de champs pour le tri, alors la chaîne retournée contiendra les noms des champs séparés par des espaces. Chaque nom de champ est précédé par le signe `+' ou `-' indiquant un tri croissant ou décroissant.

Si la table est triée par une fonction de comparaison alors le nom de cette fonction est retourné.

Une chaîne vide signifie qu'il n'y a aucun tri.

Exemple

Considérez une table `Personne' qui est triée par les champs `Nom' (croissant), `Ville' (croissant), et `Anniversaire' (décroissant). Alors, `(ORDERSTR Personne)' fournira le résultat de la chaîne "+Nom +Ville -Anniversaire".

Voir aussi SETORDERSTR, REORDER, REORDERALL, GETISSORTED, SETISSORTED, Order, Fonction de comparaison.

16.20.3 SETORDERSTR

SETORDERSTR place un enregistrement trié dans une table.

(SETORDERSTR table order)

Place le tri dans les données de la table selon le champ Tri. Le champ Tri peut contenir la liste des noms de champs ou le nom d'une fonction de comparaison.

Pour trier en utilisant une liste de champs, le champ Tri doit contenir les noms des champs séparés par un nombre d'espaces, tabulations ou une nouvelle ligne. Chaque nom de champ peut être précédé par le signe `+' ou a `-' indiquant un tri croissant ou décroissant. Si vous omettez ce signe, alors le tri croissant est assumé.

Pour trier en utilisant une fonction de comparaison, le champ Tri doit contenir le nom de la fonction.

SETORDERSTR renvoie TRUE s'il a pu placer le nouveau tri, NIL autrement, par exemple si un champ inconnu a été indiqué ou si le type du champ n'est pas permis pour le tri. Si vous indiquez NIL pour l'argument Tri alors, rien ne se produit et NIL est retourné.

Note : Pour construire le champ tri vous ne devriez pas écrire directement les noms des champs dans un champ parce que quand vous changerez un nom de champ, le champ tri ne sera pas mis à jour. Il vaut mieux utiliser la fonction FIELDNAME (voir FIELDNAME) qui permet de copier le nom d'un champ dans le champ tri.

Exemple

Si l'on considère une table `Personne' avec les champs `Nom', `Ville', et `Anniversaire'. alors, `(SETORDERSTR Personne (SPRINTF "+%s" (FIELDNAME Personne.Nom)))' placera le tri dans la table `Personne' en utilisant le `Nom' comme champ de tri (croissant).

Voir aussi GETORDERSTR, REORDER, REORDERALL, GETISSORTED, SETISSORTED, Order, Fonction de comparaison.

16.20.4 REORDER

REORDER réordonne tous les enregistrements non triés dans le bon ordre.

(REORDER table)

Examine tous les enregistrements d'une table de données pour les réordonner et les réinsérer à leur bonne position. Après réinsertion d'un enregistrement réordonné l'état de tri de l'enregistrement est placé sur TRUE, par conséquent l'état de tri de tous les enregistrements renvoyés par REORDER est TRUE.

REORDER renvoie NIL.

Habituellement vous devez seulement appeler cette fonction lorsque vous employez une fonction de comparaison pour définir le tri d'une table. Les tris définis par une liste de champs sont automatiques, c'est-à-dire, un enregistrement est réordonné automatiquement lorsque c'est nécessaire.

Pour un exemple sur la façon d'utiliser cette fonction, voir Fonction de comparaison.

Voir aussi REORDERALL, GETORDERSTR, SETORDERSTR, GETISSORTED, SETISSORTED, Order, Fonction de comparaison.

16.20.5 REORDERALL

REORDERALL réordonne tous les enregistrements d'une table.

(REORDERALL table)

Réordonne toutes les données enregistrées d'une table en plaçant l'état de tri de tous les enregistrements sur NIL et en appelant REORDER pour tout réordonner.

REORDERALL renvoie NIL.

Voir aussi REORDER, GETORDERSTR, SETORDERSTR, GETISSORTED, SETISSORTED, Order, Fonction de comparaison.

16.20.6 GETFILTERACTIVE

GETFILTERACTIVE renvoie l'état du filtre de la table.

(GETFILTERACTIVE table)

Renvoie TRUE si le filtre de la table courante spécifiée est activé et NIL dans les autres cas.

Voir aussi SETFILTERACTIVE, GETFILTERSTR, GETMATCHFILTER.

16.20.7 SETFILTERACTIVE

SETFILTERACTIVE Place l'état du filtre de la table.

(SETFILTERACTIVE table bool)

Place l'état du filtre de la table spécifiée. Si bool est différent de NIL alors le filtre est activé, sinon il est désactivé.

SETFILTERACTIVE renvoie le nouvel état du filtre. Si vous activez le filtre, le nouvel état attendu ne sera pas définit, mais une erreur se produit et le filtre ne peut pas être activé. Cependant le filtre se désactive toujours avec succès.

Voir aussi GETFILTERACTIVE, SETFILTERSTR, SETMATCHFILTER.

16.20.8 GETFILTERSTR

GETFILTERSTR renvoie l'expression de l'enregistrement dans le filtre d'une table.

(GETFILTERSTR table)

Renvoie l'expression de l'enregistrement pour le filtre d'une table spécifiée dans champs. Un champ vide signifie qu'aucune expression de filtrage n'a été placé pour cette table.

Voir aussi SETFILTERSTR, GETFILTERACTIVE, GETMATCHFILTER.

16.20.9 SETFILTERSTR

SETFILTERSTR place l'expression de l'enregistrement dans le filtre d'une table.

(SETFILTERSTR table filter-str)

Place l'expression de l'enregistrement pour le filtre d'une table spécifiée par l'expression dans l'argument filter-str (qui doit être un champ et pas l'expression réelle elle-même !). Si le filtre d'une table donnée est actuellement activé alors, la nouvelle expression de filtrage est appliquée directement à tous les enregistrements et l'état du filtre de tous les enregistrements sont recalculés.

SETFILTERSTR renvoie TRUE s'il a pu compiler les données filtrées par le champ de l'expression, sinon NIL est retourné. Notez que vous obtenez seulement le résultat de la compilation. Si le filtre d'une table donnée est actuellement activé et recalculé tous les états du filtre correspondant aux enregistrements échoueront et ne seront donc pas notés dans le résultat de cette fonction. Pour placer une nouvelle expression de filtrage il est recommandé de procéder de la manière suivante :

(SETFILTERACTIVE Table NIL)               ; réussit toujours.
(IF (NOT (SETFILTERSTR Table filter-string))
    (ERROR "ne peut pas placer le champ filtre pour %s!" (TABLENAME Table))
)
(IF (NOT (SETFILTERACTIVE Table TRUE))
    (ERROR "ne peut pas activer le filtre pour %s!" (TABLENAME Table))
)

Si SETFILTERSTR est appelé avec une valeur NIL pour l'argument filter-str et que rien ne se produit, NIL est retourné.

Exemple : `(SETFILTERSTR Table "(> Value 0.0)")'.

Voir aussi GETFILTERSTR, SETFILTERACTIVE, SETMATCHFILTER.

16.20.10 RECORDS

RECORDS renvoie le nombre d'enregistrements d'une table.

(RECORDS table)

Renvoie le nombre d'enregistrements d'une table donnée. Vous pouvez apposer une étoile sur le nom d'une table pour compter le nombre d'enregistrements identique au filtre de la table.

Voir aussi RECORD, RECNUM.

16.20.11 RECORD

RECORD renvoie l'indicateur d'enregistrement pour le nombre de données enregistrées.

(RECORD table num)

renvoie l'indicateur d'enregistrement vers num enregistré dans les données de la table ou NIL si l'enregistrement avec ce nombre n'existe pas. Vous pouvez ajouter une étoile sur le nom d'une table pour obtenir un num enregistrement identique à l'enregistrement filtré de la table.

Veuillez noter que les nombres d'enregistrements commencent par 1 et que le numéro d'enregistrement 0 est utilisé pour l'enregistrement initial.

Voir aussi RECORDS, RECNUM.

16.20.12 SELECT

SELECT extrait et renvoie diverses données à partir des enregistrements.

(SELECT [DISTINCT] exprlist FROM tablelist
        [WHERE where-expr] [ORDER BY orderlist])

Ici exprlist est soit une simple étoile `*' soit une liste d'expressions avec des titres facultatifs séparés par des virgules :

exprlist:     * | expr "titre", ...

et tablelist est une liste de noms de table :

tablelist:      table[*] [ident], ...

Pour chaque table dans la liste de table vous pouvez indiquer une marque. Ce qui peut être très utile si une table apparaît plus d'une fois dans la liste de table (voir l'exemple de comparaison des âges ci-dessous). Si vous ajoutez une étoile à une table alors seul les enregistrements identiques au filtre actuellement défini dans cette table seront examinés.

orderlist a la syntaxe suivante :

orderlist:    expr [ASC | DESC], ...

Ici, expr, ... peuvent être des expressions arbitraires ou des numéros de champs. Par exemple `(SELECT Nom FROM ... ORDER BY 1)' triera le résultat pour le champ `Nom'. Vous pouvez spécifier ASC ou DESC pour un tri croissant ou décroissant. Si aucun d'eux n'est présent, le tri croissant est assumé.

Comment ça fonctionne

Choisir à partir d'une question construite (mathématique) le résultat produit par toutes les tables dans une liste de table (il examine les séries d'enregistrements dans la table, ...) et contrôle où se trouve l'expression (s'il y en a). Si le pointeur de l'expression renvoie TRUE comme résultat (ou s'il n'y a aucun pointeur sur l'expression) alors la liste est une construction dont les éléments sont calculés par une liste d'expression dans la partie sélectionnée. Si vous avez spécifié une simple étoile pour une liste d'expression alors qu'une liste contient les valeurs de tous les champs appartenant aux tables dans une liste de table (excepté les champs virtuels et les boutons).

Le résultat de la question est une liste de listes. La première entrée d'une liste contient le titre d'une chaîne, les autres contiennent les valeurs à partir de la liste dans les enregistrements correspondant.

Exemples

Voir exemples de requêtes, pour quelques exemples utilisant la fonction SELECT .

Voir aussi FOR ALL.

16.21 Fonctions IHM

Cette section décrit les fonctions pour manipuler les éléments d'une interface graphique.

16.21.1 SETCURSOR

SETCURSOR place le curseur sur un élément graphique.

(SETCURSOR field-or-table)

Place le curseur sur un objet graphique représentant un champ ou une table. La fonction ouvre également la fenêtre où le champ/table réside si la fenêtre n'était pas déjà ouverte.

SETCURSOR renvoie TRUE si tout va bien (la fenêtre a pu être ouverte) ou NIL en cas d'échec.

Voir aussi SETVIRTUALLISTACTIVE.

16.21.2 SETBGPEN