MUIbase Support This Project
programmable relational database
with graphical user interface
This page is also available in deutsch english

Documentation

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


[ << ] [ >> ]           [Sommaire] [Table des matières] [Index] [ ? ]

16. Programmation de MUIbase

Ce chapitre (le plus long de ce manuel) décrit le langage de programmation de MUIbase, ainsi que toutes les fonctions disponibles. En revanche, ce chapitre n'est pas conçu comme un guide général sur la 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 - Éditer'. Si vous êtes configuré en code source en interne (voir Code source), cela ouvre la fenêtre `Edition de programme' qui contient :

  • un champ éditeur de texte où vous éditez 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 - Éditer'. 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éussi, 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ée 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 MUIbase depuis votre éditeur. MUIbase 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 MUIbase 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 termine à 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)' afficher `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 fichier

Lit le contenu de fichier (une chaîne encadrée par des guillemets). MUIbase 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 dans des fichiers séparés 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) alors 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 été en effet. 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

MUIbase 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, MUIbase 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 "à la" 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 impérative sur la façon de traiter les choses. 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, une variable ou 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 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

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

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. La saisie d'un programme de requête par l'intermédiaire de l'éditeur de requête (voir Éditeur de requête).

Le troisième type représente les expressions de filtrage. Ici, il uniquement possible de saisir des expressions contenant des appels à des fonctions MUIbase 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 Changer le filtre).


16.4.4 Nomenclature

Dans un programme MUIbase, il est possible de définir des symboles tels que des fonctions et des variables globales ou locales. Les noms de ces symboles doivent suivrent 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 MUIbase, 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 par le fait que leur premier composant est un nom de table, suivi par une liste de champs se terminant par le champ à atteindre. P. ex. 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 à l'attribut `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, l'attribut 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 attribut `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 la `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 MUIbase 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 (NDT: VRAI).

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 MUIbase gère les expressions constantes qui peuvent être saisies en fonction de son 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
            comme des nombres hexadécimaux.

Real        Les constantes réelles dans l'intervalle -3.59e308
            3.59e308 peuvent être spécifiée 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 toute suite de caractères
            encadrée par des guillemets, p. ex. "chaîne exemple".
            Entre les guillemets, 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)
                \\              un caractère backslash
                \"              guillemet
                \e              code échappement 033
                \nnn            caractère ayant le code octal nnn
                \xnn            caractère ayant le code hexa nn

Memo        Comme pour les chaînes (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 Typographie utilisée

Le reste de ce chapitre est consacré à la description de toutes les commandes et fonctions disponibles pour programmer dans MUIbase. 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 Commandes de définition

Cette section liste les commandes permettant de définir des fonctions et des variables globales. Ces commandes ne sont disponibles 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 ...

var1 ... sont les noms des arguments. Ces noms doivent suivre les même 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 de la 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 MUIbase 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, 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 MUIbase (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 ...)

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 soit 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'interface et rafraîchit l'affichage. Pour plus d'informations à propos des pointeurs d'enregistrement de programme et d'interface, 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*, 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.Attr 0)' appelle le déclencheur de `Table.Attr' 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, LET, DEFVAR.


16.6.6 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.7 APPLY

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

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

Applique la fonction fonc-expr à une liste créée en associant les arguments expr ... à expr-liste. En d'autres termes : appelle la fonction fonc-expr avec les arguments expr ... et expr-liste é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, expr-liste, 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.8 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.9 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 :

 
case: (valeur [expr ...])

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.10 COND

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

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

COND teste la première expression de chaque liste une à une. Pour la première qui ne renvoie par 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.11 DOTIMES

Pour des boucles simples, la commande DOTIMES est utilisable.

 
(DOTIMES (nom expr-entière [expr-résultat ...]) [expr-boucle ...])

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 fois que la boucle sera exécutée est indiqué par expr-entière. Dans expr-résultat ... il est possible de donner des expressions qui seront exécutées après la dernière boucle. expr-boucle 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 expr-entière pour déterminer le nombre de fois que la boucle sera exécutée. expr-entière 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 à expr-entière-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 expr-entière 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 exécute d'autres boucles.

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.12 DOLIST

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

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

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).

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

Avant d'exécuter la boucle, DOLIST calcule la valeur de expr-liste. 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 exécute d'autres boucles.

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.13 DO

L'expression DO permet de programmer des boucles arbitraires.

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

binding ... are the variable bindings, each of which is either:

  • un nouveau nom de variable (qui sera initialisé à NIL)
  • une liste de la forme : (nom init [pas])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 expr-terminaison est l'expression du test d'arrêt, expr-résultat ... les expressions du résultat (NIL en cas d'absence) et expr-boucle ... 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 si retournent TRUE (NDT: TRUE en anglais) 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, la boucle (expr-loop ...) est exécutée et chaque variable est mise à jour par la valeur de son expression de pas. Ensuite l'exécution au test 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.14 FOR ALL

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

 
(FOR ALL liste-tables [WHERE expr-sélection] [ORDER BY list-ordre] DO expr ...)

Ici, table-list est une liste de tables séparées par des virgules, expr-sélection une expression à valider pour chaque enregistrement, list-ordre 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 attribut 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.15 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.16 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 expr-résultat ...) ...)

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.17 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.18 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.19 ERROR

Pour avorter 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 typage

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é 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é 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é 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 avortée.

Voir aussi REAL, ASC.


16.8.4 REAL

REAL est utilisé 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é pour convertir une expression en une date.

 
(DATE expr)

converti 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 avortée.

Voir aussi DATEDMY.


16.8.6 TIME

TIME est utilisé 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 avortée.


16.9 Fonctions booléennes

Cette section liste les opérateurs booléens.


16.9.1 AND

AND vérifie que tous ses arguments sont vrais (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é 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 MUIbase, il faut utiliser

 
(op expr1 expr2)

op est parmi {=, <>, <, >, >=, <=, =*, <>*, <*, >*, >=*, <=*}. L'étoile est utilisée pour les comparaisons spéciales (p. ex. les chaînes sont comparées en tenant 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 MUIbase.

 
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 ...)]

Returns the maximum value of the arguments expr .... If no arguments are given then NIL is returned. For determining the largest element the simple (non-star) order relation as for relational operators (voir Relational operators) is used.

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


16.10.5 MAX*

MAX* is the star version of MAX. The difference is that MAX* uses the extended ordering as defined for relational operators (voir Relational operators) where strings are compared case insensitive and records are compared using the user defined record order.

Example: `(MAX* "x" "Y")' results to "Y".

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


16.10.6 MIN

MIN retourne l'argument ayant la plus petite valeur.

 
(MIN [expr ...)]

Returns the minimum value of the arguments expr .... If no arguments are given then NIL is returned. For determining the smallest element the simple (non-star) order relation as for relational operators (voir Relational operators) is used.

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


16.10.7 MIN*

MIN* is the star version of MIN. The difference is that MIN* uses the extended ordering as defined for relational operators (voir Relational operators) where strings are compared case insensitive and records are compared using the user defined record order.

Example: `(MIN* "x" "Y")' results to "x".

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


16.11 Fonctions mathématiques

Ici quelques fonctions mathématiques sont listées.


16.11.1 Ajouter des valeurs

Pour ajouter 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 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 la somme de expr2 ... à expr1. Les mêmes règles que pour l'ajout de valeurs (voir +) s'appliquent sauf que les chaînes et les mémos ne peuvent se soustraire.

(- expr) a une signification particulière : cela 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 ou réelle.

 
(1+ expr)

Retourne la valeur de expr (entier ou réel) 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 ou réelle.

 
(1- expr)

Retourne la valeur de expr (entier ou réel) 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 divisez 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 computes the power of values.

 
(POW x y)

Returns the value of real value x raised to the power of real value y. If either x or y are NIL, or if x is negative and y not an integral number, then NIL is returned.

Example: `(POW 2 3)' results to 8.

See also SQRT, EXP.


16.11.14 SQRT

SQRT computes the square root of a number.

 
(SQRT x)

Returns the square root of real value x. If x is NIL or a negative number then NIL is returned.

See also POW.


16.11.15 EXP

EXP computes the exponential function.

 
(EXP x)

Returns the value of the base of the natural logarithm raised to the power of real value x. If x is NIL then NIL is returned.

See also POW, LOG.


16.11.16 LOG

LOG computes the natural logarithm of a number.

 
(LOG x)

Returns the natural logarithm of real value x. If x is NIL or not a positive number then NIL is returned.

See also 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 de la 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 extrait une sous-chaîne de la chaîne.

 
(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 de la 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 partie de la 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 plus supérieure ou égale à la celle de str. Si l'un des arguments est NIL ou si index est hors limite, le résultat est NIL.

Exemple: `(SETMIDSTR "Salut monde !" 6 "Mélanie !")' retourne "Salut Mélanie!".

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 "Salut le monde !" 14 " de MUIbase")' retourne "Salut le monde de MUIbase !".

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 des chaînes 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 "Salut monde !" "monde")' 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 " Salut monde !" "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 de chaîne 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 "Doo 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 "noir c'est blanc" "noir" "blanc" "blanc "noir")' 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 numeme 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 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 returns a field in a string.

 
(FIELD str num [sep [quotes]])

Returns the num-th field (starting with zero) of the given string. Fields in a string are sub strings separated by exactly one separator character. A field may be an empty string. Argument sep contains the characters that separate fields. If sep is NIL or not provided then non-breakable space characters (e.g. space, tab, or newline characters) are used. If quotes is given and not NIL then fields can be surrounded by double quotes and may contain separator characters. The double quotes are stripped when returning the field.

If str or num are NIL, or if num is out of range, that is, less than zero or greater or equal to the number of fields, then NIL is returned.

Example: `(FIELD "My name is \"Darth Vader\"" 3 " " TRUE)' results to "Darth Vader".

See also FIELDS, WORD, LEFTSTR, RIGHTSTR, MIDSTR, STRTOLIST.


16.12.22 FIELDS

FIELDS counts the number of fields in a string.

 
(FIELDS str [sep [quotes]])

Returns the number of fields in the given string or NIL if str is NIL. Fields in a string are sub strings separated by exactly one separator character. A field may be an empty string. Argument sep contains the characters that separate fields. If sep is NIL or not provided then non-breakable space characters (e.g. space, tab, or newline characters) are used. If quotes is given and not NIL then fields can be surrounded by double quotes and may contain separator characters.

See also FIELD, WORDS, LEN.


16.12.23 STRTOLIST

STRTOLIST convertit une chaîne en une liste de sous-chaînes.
 
(STRTOLIST str [sep])

Crée une liste de sous-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". Avoir aussi ADMINPASSWORD, demo `Users.mb'.


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 Linux et Windows, 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 Linux et Windows 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

  • 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. 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'à ce que soit la fin de la chaîne soit atteinte, 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 numieme 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 "Silke" "me prête" "« mon » vélo" "jusqu'au" 01.09.1998)' retourne "Silke\nme prête\n« mon » vélo\njusqu'au\n01.09.1998".

`(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 le 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 moins de longeur caractères. 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 caractères espace. 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 la date et l'heure

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 à partir des données du mois et de l'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é.

Exemples: `(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 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é.

Exemples: `(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 valeur 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.

Exemples: `(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 valeur 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.

Exemples: `(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 en tant que valeur de l'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 établit 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 la 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 la 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 des données de la 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 de la 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 des données de la 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.


16.15.8 APPEND

APPEND enchaîner les 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.9 REVERSE

REVERSE renverse une liste.

 
(REVERSE list)

renvoie la liste renversée.

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


16.15.10 MAPFIRST

MAPFIRST applique une fonction à tous les éléments de la 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 les arguments des éléments d'une liste donnée. 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.11 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 pour le tri. La fonction pour le tri doit prendre deux arguments un pour chaque élément et renvoyer une valeur de nombre entier inférieure à zéro si le premier élément est plus petit que le second, une valeur supérieure à zéro si le premier élément est plus grand que le second, une valeur de zéro si les deux éléments sont égaux.

Exemple pour une chaîne texte comparant la fonction utilisable pour le trie :

 
(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.12 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 et le second élément sont supérieur, et NIL autrement.

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

Voir aussi SORTLIST, MAPFIRST.


16.16 Fonctions de demande de saisie

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


16.16.1 ASKFILE

ASKFILE demande à l'utilisateur d'écrire un nom de fichier.

 
(ASKFILE title oktext default savemode)

Ouvre un sélecteur de fichier pour saisir le nom de 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é pour demander de sauver quelque chose sous un nom de fichier.

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

Voir aussi ASKDIR, ASKSTR.


16.16.2 ASKDIR

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

 
(ASKDIR title oktext default savemode)

Ouvre le sélecteur de fichier pour saisir le nom du répertoire. Les arguments sont utilisés de la même façon ASKFILE (voir ASKFILE).

ASKDIR renvoie le nom du répertoire écrit dans une chaîne texte ou NIL dans le cas où l'utilisateur aurait annulé le sélecteur de fichier.

Voir aussi ASKFILE, ASKSTR.


16.16.3 ASKSTR

ASKSTR demande à l'utilisateur d'écrire une chaîne texte.

 
(ASKSTR title oktext default maxlen [secret])

Ouvre une requête de saisie de chaîne 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 texte 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 rond pour chaque caractère.

ASKSTR renvoie la chaîne texte entrée ou NIL au cas où l'utilisateur l'annulerait.

Voir aussi ASKFILE, ASKDIR, ASKCHOICESTR, ASKINT.


16.16.4 ASKINT

ASKINT incite l'utilisateur à écrire un nombre entier.

 
(ASKINT title oktext default min max)

Ouvre une requête 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 texte 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 placer la gamme des nombres entiers. 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 la requête.

Voir aussi ASKSTR.


16.16.5 ASKCHOICE

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

 
(ASKCHOICE titre oktext choix defaut [titres])

Ouvre une requête 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 texte ou NIL pour des valeurs par défaut). Dans choix vous indiquez une liste de choix sous forme de mémo avec un choix par ligne. Il est possible d'utiliser un format multi-colonnes en séparant les colonnes par le caractère tabulation "\t". 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 titres 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, séparez les titres de colonnes par des tabulations.

choix et titres peuvent tous les deux être représentés par des listes plutôt que par un mémo ou une chaîne. Dans ce cas ils sont convertis au format voulu par un appel automatique à LISTTOMEMO (voir LISTTOMEMO) ou LISTTOSTR (voir LISTTOSTR) respectivement.

ASKCHOICE renvoie l'index de l'article choisi ou NIL si l'utilisateur a annulé la requête.

Exemple

 
(LET ((items (LIST "Première entrée" 2 3.14 "Dernière entrée")) index)
    (SETQ index (ASKCHOICE "Choisissez un article" "Ok" items NIL))
    (IF index
        (PRINTF "l'utilisateur a choisi l'article numérique %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 ((requete (SELECT Article, Nome, Quantite, Prx from Article 
                  WHERE (> Prix 10) ORDER BY Nom))
     (enregs (MAPFIRST FIRST (REST query)))       ; pointeurs d'enregistrement
     (elements (MAPFIRST REST (REST query)))      ; choic
     (titres (REST (FIRST query)))                ; titres
     (index (ASKCHOICE "Sélectionnez" "Ok" items NIL titles))
     (elem (NTH index enregs))) 
     ; maintenant elem contient l'enregistrement choisi (ou NIL si annulation)
)

Voir aussi ASKCHOICESTR, ASKOPTIONS.


16.16.6 ASKCHOICESTR

ASKCHOICESTR Invite l'utilisateur à entrer la valeur d'une chaîne texte parmi celles qui ont été prédéfinies.

 
(ASKCHOICESTR titre oktext chaines defaut [titres])

Ouvre une requête de saisie demandant à l'utilisateur de choisir une chaîne texte 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 texte ou NIL pour des valeurs par défaut). Dans chaines vous indiquez la liste de choix sous forme de mémo avec un choix par ligne. Vous pouvez utiliser un format multi-colonnes en séparant les colonnes par le caractère tabulation "\t". La valeur initiale du champ texte peut être placée dans defaut (chaîne texte ou NIL pour un champ texte vide). Si l'argument optionnel titres 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, séparez les titres de colonnes par des tabulations.

chaines et titres peuvent tous les deux être représentés par des listes plutôt que par un mémo ou une chaîne. Dans ce cas ils sont convertis au format voulu par un appel automatique à LISTTOMEMO (voir LISTTOMEMO) ou LISTTOSTR (voir LISTTOSTR) respectivement.

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

Exemple

 
(LET ((chaines (LIST "Claudia" "Mats" "Ralphie")) prefere)
    (SETQ prefere
        (ASKCHOICESTR "Qui préférez-vous?" "Ok" chaines
        "Mes Colley !"
    )
    )
    (IF prefere (PRINTF "l'utilisateur a choisi <%s>\n" prefere))
)

Voir aussi ASKCHOICE, ASKOPTIONS.


16.16.7 ASKOPTIONS

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

 
(ASKOPTIONS titre oktext options selectionnes [titres])

Ouvre une requête 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 texte ou NIL pour des valeurs par défaut). Dans options vous indiquez la liste d'options sous forme de mémo avec une option par ligne. Vous pouvez utiliser un format multi-colonnes en séparant les colonnes par le caractère tabulation "\t". L'état initial peut être spécifié dans selectionnes sous forme de liste de nombres entiers spécifiant l'index dont la ligne correspondante dans options qui doit être sélectionnée au début. Utilisez NIL pour tous les éléments ne devant pas être présélectionnés.

Si l'argument optionnel titres 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, séparez les titres de colonnes par des tabulations.

options et titres peuvent tous les deux être représentés par des listes plutôt que par un mémo ou une chaîne. Dans ce cas ils sont convertis au format voulu par un appel automatique à LISTTOMEMO (voir LISTTOMEMO) ou LISTTOSTR (voir LISTTOSTR) 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é la requête ou n'aurait pas choisi d'élément.

Exemple

 
(LET ((options (LIST "Salva Mea" "Insomnie" "n'attendez pas" "7 jours & 1 semaine"))
        (choisis (LIST 0 1 3))
    )
    (SETQ choisis (ASKOPTIONS "Titre de musique choisi" "Ok" options choisis))
    (IF choisis
        (
            (PRINTF "L'utilisateur a choisi les articles suivants :\n")
            (DOLIST (i choisis)
                (PRINTF "\tnum: %i contenu : <%s>\n" i (STR (NTH i options)))
            )
        )
    )
)


16.16.8 ASKBUTTON

ASKBUTTON invite l'utilisateur à appuyer sur un bouton.

 
(ASKBUTTON title text buttons canceltext)

Ouvre une fenêtre de dialogue avec le titre (chaîne texte ou NIL pour un titre par défaut) et une description (chaîne texte ou NIL s'il n'y en a pas). La fonction attend jusqu'à ce que l'utilisateur appuie 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 ici 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 sélectionné (à partir de 0, pour le bouton à l'extrême gauche) ou NIL si l'utilisateur appuie sur le bouton `Annuler'.

Exemples

 
(LET ((boutons (LIST "à la maison" "Dans le lit" "Devant mon ordinateur")) index)
    (SETQ index (ASKBUTTON "répondez s'il vous plaît :"
        "Où vous voulez être demain ?" boutons "ne sait pas")
    )
    (IF index
        (PRINTF "l'utilisateur a choisi : <%s>\n" (NTH index boutons))
    )
)

(ASKBUTTON "Info" "MUIbase est grand !" NIL NIL)

Voir aussi ASKCHOICE.


16.16.9 ASKMULTI

ASKMULTI incite l'utilisateur à écrire divers genres d'informations.

 
(ASKMULTI title oktext itemlist)

ASKMULTI est une requête de saisie à usages multiples. Il ouvre une requête avec le titre indiqué, un ensemble d'objets GUI pour l'édition des 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 texte ou NIL pour le texte de défaut). L'ensemble des objets GUI 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 éditer une ligne de texte,
    (LIST title "Memo" initial [help])     pour éditer plusieurs lignes de texte,
    (LIST title "Integer" initial [help])  pour éditer un nombre entier,
    (LIST title "Real" initial [help])     pour éditer un réel,
    (LIST title "Date" initial [help])     pour éditer une date,
    (LIST title "Time" initial [help])     pour éditer une heure,
    (LIST title "Bool" initial [help])     pour un champ 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 le texte statique

Le titre (chaîne texte ou NIL s'il n'y a pas de titre) sera affiché à la gauche de l'objet GUI. Si la valeur initiale est NIL la valeur par défaut est utilisée (par exemple un champ texte vide). Pour le choix de la valeur initiale des champs, l'index doit être (démarrer avec 0) l'entrée active initiale, parce que la valeur initiale d'une liste de champs peut être NIL (aucun article n'est activé), et pour les options des champs la valeur initiale doit être une liste de nombres entiers représentant les index (démarrant avec 0) des articles qui ont initialement été sélectionnés. Le champ facultatif d'aide (chaîne texte) peut être utilisé pour fournir plus d'information à l'utilisateur au sujet de l'utilisation du champ. Pour les champs texte un paramètre additionnel `secret' peut être spécifié. S'il n'est pas NIL alors le contenu du champ texte est rendu invisible en affichant un symbole rond pour chacun de ses caractères.

ASKMULTI renvoie une liste de résultats que l'utilisateur a édités et validés en appuyant sur le bouton `Ok'. Chaque valeur de résultat 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'article choisi (ou NIL si aucun article n'a été choisi) ou pour une option de champ la valeur résultat est une liste de nombres entiers représentant les index des articles choisis. Pour le texte statique une valeur NIL est retournée.

Par exemple si vous avez indiqué un champ date, un champ texte statique, le choix d'un champ texte, une option de champ et une chaîne champ de 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 article dans l'option champ, et à gauche laissé le champ de la chaîne texte intact alors la fonction renvoie la liste ( 11.11.1999 NIL 2 ( 3 4 ) "world" ).

Si l'utilisateur a annulé la requête, 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 _voiture ?" "Bool" NIL)
    (LIST "_Aime" "Options" (LIST 0 2)
        (LIST "Bière" "Vin" "Whisky" "Wodka" "Schnaps")
    ))
)

Veuillez regarder également le projet `AskDemo.mb' pour d'autres exemples.


16.17 Fonctions d'E/S

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


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 renvoi un descripteur de fichier pour écrire dans le fichier `index.html' selon 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, MUIbase 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 MUIbase. Le nom du fichier de sortie peut être réglé depuis le menu `Programme - fichier de sortie' (voir Program output file).

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 MUIbase, 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 MUIbase 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 converti 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).

Voir aussi PRINTF, stdout.


16.17.5 PRINTF

PRINTF imprime une chaîne formater.

 
(PRINTF format [expr ...])

Formate une chaîne texte 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 nombre de caractères en sortie ou NIL en cas d'échec. If format is NIL then NIL is returned.

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

Voir aussi PRINT, FPRINTF, stdout.


16.17.6 FPRINTF

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

 
(FPRINTF file format [expr ...])

Formate une chaîne texte 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 pour les données d'un fichier donné 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 placé. autrement NIL est retourné. Si le `file' est NIL, NIL est retourné.

Voir aussi FERROR, FTELL, FOPEN, FCLOSE.


16.17.9 FSEEK

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

 
(FSEEK file offset whence)

Place 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 de fichier.

En cas de succès, FSEEK renvoie 0. Sinon NIL est retourné et la position dans le fichier reste inchangée. Si lfile, 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 le `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 texte 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 texte 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 texte 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 alors produite, NIL est retourné.

Voir aussi FGETCHAR, FGETSTR.


16.17.13 FGETSTR

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

 
(FGETSTR file)

renvoie la prochaine ligne d'un fichier donné comme une chaîne texte ou NIL si le 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 texte ne contient aucune nouvelle ligne de caractères.

Voir également 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 la 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 la str dans un fichier donné. Si la str est vide, un caractère nul est écrit, si la str ou la file sont NIL, rien ne se produit. Renvoie la str ou NIL au cas où une erreur de sortie se produirait.

Voir aussi FPUTSTR, FGETCHAR.


16.17.16 FPUTSTR

FPUTSTR écrit une chaîne texte dans un fichier.

 
(FPUTSTR str file)

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

Voir aussi FPUTCHAR, FPUTMEMO, FGETSTR.


16.17.17 FPUTMEMO

FPUTMEMO écrit un mémo dans un fichier.

 
(FPUTMEMO memo file)

Imprime la memo dans un fichier donné. Si la memo ou la file sont NIL, rien ne se produit. Renvoie la 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 fichier)

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 la fichier est NIL alors 0 est retourné (aucune erreur).

Voir aussi FOPEN, FCLOSE.


16.18 Les 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 de la 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 les 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 une version amélioré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, si ce n'est pas NIL alors 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 une version amélioré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 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 encours 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 dans 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 dispose 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 place l'état du filtre d'un enregistrement.

 
(SETMATCHFILTER rec on)

Change l'état du filtre de l'enregistrement indiqué dans 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 courante 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 la rec est NIL alors NIL est retourné.

Voir aussi SETISSORTED, GETMATCHFILTER, REORDER, GETORDERSTR, SETORDERSTR, Comparison function.


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 la voir Fonction de comparaison.

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


16.18.10 RECNUM

RECNUM renvoie le numéro d'enregistrement d'un enregistrement.

 
(RECNUM record)

Renvoie le numéro d'enregistrement 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 texte et autres, le compte commence à zéro. Toutefois, pour les enregistrements, il commence par 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 MUIbase, 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, INT.


16.18.11 COPYREC

COPYREC copie les enregistrements.

 
(COPYREC rec source)

Copie le contenu de l'enregistrement source dans l'enregistrer 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 ATTRNAME

ATTRNAME renvoie le nom d'un champ.

 
(ATTRNAME attr)

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-attr)

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

Voir aussi LEN.


16.19.3 GETLABELS

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

 
(GETLABELS attr)

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

Les étiquettes 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 étiquettes `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 étiquettes d'un champ dans une chaîne.

 
(SETLABELS attr str)

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

SETLABELS renvoie la valeur de l'argument str.

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

Note: vous pouvez facilement convertir une liste d'étiquettes dans le format requit par une chaîne texte 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 texte contenant le nom de la table indiquée.

Voir aussi ATTRNAME


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 texte 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 texte "+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 ATTRNAME (voir voir ATTRNAME) 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" (ATTRNAME 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 la 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 là, 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 recommander 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 dans une table.

 
(RECORDS table)

Renvoie le nombre d'enregistrements dans 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 se produit 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 nombres 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 les Voir exemples de questions, pour quelques exemples utilisant la fonction SELECT .

Voir aussi FOR ALL.


16.21 Les fonctions GUI

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 attr-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

SETBGPEN sets the background pen of a GUI element.

 
(SETBGPEN attr pen)

Sets the pen for drawing the background of the GUI object given by attr. For pen a hexadecimal integer value holding a color in RBG (red, green, blue) format, or one of the PEN_* constants can be used. If pen is NIL then a default background is set.

SETBGPEN returns the value of the new background pen.

Example: `(SETBGPEN Control.Status 0xFF0000)' sets a red background for the GUI element of attribute `Status' in table `Table'. The same effect can be achieved by `(SETBGPEN Control.Status PEN_RED)'.

See also Pre-defined constants.


16.21.3 GETWINDOWOPEN

GETWINDOWOPEN renvoie l'état d'ouverture d'une fenêtre.

 
(GETWINDOWOPEN attr-or-table)

Renvoie l'état d'ouverture d'une fenêtre où réside le champ/table.

Voir aussi SETWINDOWOPEN.


16.21.4 SETWINDOWOPEN

SETWINDOWOPEN ouvre ou ferme une fenêtre.

 
(SETWINDOWOPEN attr-or-table open)

Ouvre ou ferme la fenêtre dans laquelle réside le champ/table. Si open n'est pas NIL alors la fenêtre est ouverte, sinon elle est fermée. Vous ne pouvez pas fermer la fenêtre principale d'un projet.

SETWINDOWOPEN renvoie le nouvel état d'ouverture de la fenêtre.

Voir aussi GETWINDOWOPEN.


16.21.5 GETVIRTUALLISTACTIVE

GETVIRTUALLISTACTIVE renvoie l'index de la ligne active d'un champ virtuel utilisant une `Liste' son affichage.

 
(GETVIRTUALLISTACTIVE virtual-attr)

Renvoie l'index (commençant par 1) de la ligne active courante avec le champ virtuel spécifié. Si l'élément GUI de virtual-attr n'est pas visible, s'il n'emploie pas de `Liste' pour son affichage, ou si aucune ligne n'est activée, alors NIL est retourné.

Voir aussi SETVIRTUALLISTACTIVE.


16.21.6 SETVIRTUALLISTACTIVE

SETVIRTUALLISTACTIVE Modifie la ligne active d'un champ virtuel utilisant une `Liste' pour son affichage.

 
(SETVIRTUALLISTACTIVE virtual-attr num)

Modifie la ligne active du champ virtuel sur la numeme ligne (commençant à 1). Renvoie num, ou NIL si l'élément GUI de virtual-attr n'est pas visible, n'utilise pas de `Liste' pour son affichage ou si num est hors limite (inférieure à 1 ou plus grand que le nombre de lignes).

SETVIRTUALLISTACTIVE ne place pas le curseur sur l'élément graphique du champ, utilisez pour cela SETCURSOR (voir voir SETCURSOR).

Voir aussi GETVIRTUALLISTACTIVE, SETCURSOR.


16.22 Les fonctions projets

Cette section énumère les fonctions traitant des projets.


16.22.1 PROJECTNAME

PROJECTNAME renvoie le nom de projet.

 
(PROJECTNAME)

PROJECTNAME renvoie le nom du projet en cours dans une chaîne ou NIL si aucun nom n'a encore été défini. Le nom du project est le chemin du répertoire-projet du système de fichier.

Voir aussi CHANGES.


16.22.2 PREPARECHANGE

PREPARECHANGE prepares the project for a change.

 
(PREPARECHANGE)

This command obtains a change lock on the project. This is useful when accessing a project with several MUIbase instances possibly running on different computers. Once a change lock has been obtained, no other MUIbase instance can obtain one until the lock is released. The change lock is released if the project program returns without actually performing a change, or after the project has been saved. For more information on sharing of a project, voir File format.

PREPARECHANGE returns NIL on success. If obtaining the change lock fails, the program quits with an appropriate error message.

See also CHANGES.


16.22.3 CHANGES

CHANGES renvoie le nombre de changements du projet en cours.

 
(CHANGES)

Renvoie un nombre entier contenant le nombre de changement depuis la dernière opération de sauvegarde du projet en cours.

Voir aussi PROJECTNAME.


16.22.4 GETADMINMODE

GETADMINMODE tells whether the current project is in admin mode GETADMINMODE indique si le projet courant est en mode administrateur ou utilisateur.
 
(GETADMINMODE)

Retourne TRUE si le projet courant est en mode administrateur, NIL sinon. Voir aussi SETADMINMODE, ADMINPASSWORD, onAdminMode.


16.22.5 SETADMINMODE

SETADMINMODE bascule le projet courant vers le mode administrateur ou utilisateur.

 
(SETADMINMODE admin) 

Si admin est NIL alors le projet courant est basculé en mode utilisateur, dans le cas contraire il passe en mode administrateur. Notez qu'il n'y a pas de fenêtre d'identification lors du passage du mode utilisateur vers le mode administrateur en utilisant cette fonction.

Retourne TRUE si le projet a été basculé en mode administrateur, ou NIL s'il est basculé en mode utilisateur.

Voir aussi GETADMINMODE, ADMINPASSWORD, onAdminMode, démo `Users.mb'.


16.22.6 ADMINPASSWORD

ADMINPASSWORD obtient le mot de passe administrateur sous forme de chaîne de hachage SHA1.

 
(ADMINPASSWORD) 

Retourne une chaîne représentant la valeur de hachage SHA1 du mode de passe administrateur du projet courant. Si aucun mode de passe administrateur n'a été configuré, NIL est retourné.

Voir aussi GETADMINMODE, SETADMINMODE, SHA1SUM, démo `Users.mb'.


16.23 Les fonctions système

Cette section énumère les fonctions faisant appel au système d'exploitation.


16.23.1 EDIT

EDIT Lancement d'un éditeur externe.

 
(EDIT filename)

Démarrez un éditeur externe pour éditer un fichier spécifié. L'éditeur externe peut être placé dans le menu `Préférences - Configurer l'éditeur externe' (voir voir Éditeur externe). EDIT démarre l'éditeur externe synchroniquement, ce qui veut dire qu'il attend jusqu'à ce que l'utilisateur sorte de l'éditeur.

EDIT renvoie le code return de l'éditeur externe comme nombre entier.

Voir aussi EDIT*, VIEW, SYSTEM.


16.23.2 EDIT*

EDIT* est la version étoilée de EDIT et a le même effet que EDIT (voir voir EDIT). La seule différence est que EDIT* démarre un éditeur externe de façon asynchrone, ainsi la fonction rend la main immédiatement.

EDIT* renvoie 0 en cas de succès lors du démarrage de l'éditeur, sinon il renvoie la valeur d'un nombre entier différent de zéro représentant un code d'erreur système spécifique.

Voir aussi EDIT, VIEW*, SYSTEM*.


16.23.3 VIEW

VIEW lance la visionneuse externe.

 
(VIEW filename)

Démarre la visionneuse externe pour afficher le fichier spécifié. La visionneuse externe peut être placée dans menu `Préférences - Configurer la visionneuse' (voir voir Visionneuse externe). VIEW démarre la visionneuse externe synchroniquement, c'est-à-dire qu'elle attend jusqu'à ce que l'utilisateur sorte de la visionneuse. Notez que sur quelques systèmes, l'appel pourrait immédiatement être renvoyé si un exemple de la visionneuse fonctionne déjà.

VIEW* renvoie le code renvoyé par la visionneuse externe comme un nombre entier.

Voir aussi VIEW*, EDIT, SYSTEM.


16.23.4 VIEW*

VIEW* est la version étoilée de VIEW et a les mêmes effets que VIEW (voir VIEW). La seule différence est que VIEW* démarre la visionneuse externe de façon asynchrone, ainsi la fonction rend la main immédiatement.

VIEW* renvoie 0 s'il réussi à démarrer la visionneuse, sinon il renvoie la valeur d'un nombre entier différent de zéro représentant un code d'erreur système spécifique.

Voir aussi VIEW, EDIT*, SYSTEM*.


16.23.5 SYSTEM

SYSTEM appelle un programme externe.

 
(SYSTEM fmt [arg ...])

Appelle un programme externe. La ligne de commande pour appeler le programme est spécifiée par fmt et des arguments facultatifs comme dans la fonction SPRINTF (voir SPRINTF). Pour interpréter la ligne de commande, le shell du système est utilisé (/bin/sh sur Linux, ShellExecute sur Windows, le shell utilisateur sur Amiga). SYSTEM attend jusqu'à ce que le programme appelé soit terminé.

SYSTEM renvoie le code retour de la commande exécutée sous forme de nombre entier.

Voir aussi SYSTEM*, EDIT, VIEW.


16.23.6 SYSTEM*

SYSTEM* est la version étoilée de SYSTEM et a les mêmes effets que SYSTEM (voir SYSTEM). La seule différence est que SYSTEM* exécute la ligne de commande de façon asynchrone, ainsi la fonction rend la main immédiatement.

SYSTEM* renvoie 0 s'il réussi à lancer l'exécution de la ligne de commande, sinon il renvoie un nombre entier différent de zéro représentant un code d'erreur spécifique au système.

Voir aussi SYSTEM, EDIT*, VIEW*.


16.23.7 STAT

STAT examine un nom de fichier.

 
(STAT filename)

Vérifie si le fichier dont le nom a été indiqué existe dans le système. STAT renvoie NIL si le fichier ne peut pas être trouvé, 0 si le fichier existe et est un répertoire, et un nombre entier supérieur à 0 si le fichier existe et est un fichier normal.


16.23.8 TACKON

TACKON crée le chemin d'accès.

 
(TACKON dirname [component ...])

Fusionne dirname et tous les composants de [component ...] pour obtenir un chemin d'accès. TACKON sait traiter les caractères spéciaux utilisés comme séparateurs à la fin de chaque élément. Il renvoie le chemin d'accès dans un champ ou NIL si aucun des arguments est NIL. Notez que TACKON n'effectue aucun contrôle sur l'existence ou non du chemin d'accès résultant.

Exemple: `(TACKON "Sys:System" "CLI")' donne "Sys:System/CLI".

Voir aussi FILENAME, DIRNAME.


16.23.9 FILENAME

FILENAME extrait le nom de fichier à partir du chemin d'accès.

 
(FILENAME path)

Extrait le dernier composant du chemin d'accès spécifié. Aucune vérification n'est faite si le path spécifié se rapporte réellement à un fichier, ainsi il est également possible d'utiliser FILENAME pour obtenir le nom d'un sous-répertoire. FILENAME renvoie son résultat sous forme de chaîne ou NIL si path est NIL.

Exemple: `(FILENAME "Sys:System/CLI")' donne "CLI".

Voir aussi DIRNAME, TACKON.


16.23.10 DIRNAME

DIRNAME extrait une partie correspondant au répertoire depuis un chemin d'accès.

 
(DIRNAME path)

Extrait la partie correspondant au répertoire du chemin d'accès spécifié. Aucune vérification n'est faite si path se rapporte effectivement à un fichier, ainsi il est également possible d'utiliser DIRNAME pour obtenir le répertoire parent. DIRNAME renvoie son résultat sous forme de chaîne ou NIL si path est NIL.

Exemple: `(DIRNAME "Sys:System/CLI")' donne "Sys:System".

Voir aussi FILENAME, TACKON.


16.23.11 MESSAGE

MESSAGE affiche un message à l'utilisateur.

 
(MESSAGE fmt [arg ...])

Positionne le titre de la fenêtre pause/abort (si elle est ouverte). Le titre est créé à partir de fmt et des arguments facultatifs comme dans la fonction SPRINTF (voir SPRINTF).

MESSAGE renvoie le champ titre formaté.

Exemple: `(MESSAGE "6 * 7 = %i" (* 6 7))'.

Voir aussi PRINT, PRINTF.


16.23.12 COMPLETEMAX

COMPLETEMAX spécifie le nombre maximum d'étapes de progression.

 
(COMPLETEMAX steps)

Spécifie le nombre maximum d'étapes pour montrer à l'utilisateur la progression de votre programme MUIbase. Le nombre d'étapes par défaut (si vous n'appelez pas cette fonction) est de 100. La valeur de l'argument steps doit être un nombre entier. Si steps est NIL ou 0 alors aucune barre de progression n'est affichée. La barre de progression fait partie de la fenêtre pause/arrêt et surgit après un bref délai en exécutant un programme MUIbase.

COMPLETEMAX renvoie son argument steps.

Voir aussi COMPLETEADD, COMPLETE.


16.23.13 COMPLETEADD

COMPLETEADD incrémente l'état de progression.

 
(COMPLETEADD add)

Ajoute le nombre entier contenu dans add à la valeur courante de la progression. La valeur initiale de progression est placée sur 0. Si add est NIL alors la valeur de progression est remise à 0 et aucune barre de progression n'est montrée.

COMPLETEADD renvoie son argument add.

Exemple :

 
    (SETQ num ...)
    (COMPLETEMAX num)
    (DOTIMES (i num)
        (COMPLETEADD 1)
    )

Voir aussi COMPLETEMAX, COMPLETE.


16.23.14 COMPLETE

COMPLETE modifie l'état de progression.

 
(COMPLETE cur)

Positionne la valeur courante de progression sur la valeur entière cur. Si cur est NIL ou 0 alors aucune barre de progression n'est montrée.

COMPLETE renvoie son argument cur.

Exemple :

 
    (COMPLETE 10)
    ...
    (COMPLETE 50)
    ...
    (COMPLETE 100)

Voir aussi COMPLETEMAX, COMPLETEADD.


16.23.15 GC

GC force le passage du « ramasse-miettes ».

 
(GC)

Force le passage du « ramasse-miettes » et renvoie NIL. Normalement le « ramasse-miettes » est exécuté automatiquement de manière régulière.


16.23.16 PUBSCREEN

PUBSCREEN retourne le nom de l'écran publique.

 
(PUBSCREEN)

Sur Amiga, PUBSCREEN retourne le nom de l'écran public sur lequel est affiché MUIbase, ou NIL si l'écran n'est pas publique.

Sur tous les autres systèmes, PUBSCREEN retourne NIL.


16.24 Les variables prédéfinies

MUIbase connaît quelques variables globales prédéfinies.

Dans la version en cours il existe seulement une variable globale : stdout (voir stdout).


16.25 Les constantes prédéfinies

Les constantes prédéfinies suivantes peuvent être employées dans toute expression pour la programmation.

 
Nom             Type            Valeur          Commentaire
-------------------------------------------------------------------------
NIL             tous            NIL
TRUE            booléen         TRUE
RESET           texte           "\33c"
NORMAL          texte           "\33[0m"
ITON            texte           "\33[3m"
ITOFF           texte           "\33[23m"
ULON            texte           "\33[4m"
ULOFF           texte           "\33[24m"
BFON            texte           "\33[1m"
BFOFF           texte           "\33[22m"
ELITEON         texte           "\33[2w"
ELITEOFF        texte           "\33[1w"
CONDON          texte           "\33[4w"
CONDOFF         texte           "\33[3w"
WIDEON          texte           "\33[6w"
WIDEOFF         texte           "\33[5w"
NLQON           texte           "\33[2\"z"
NLQOFF          texte           "\33[1\"z"
INT_MAX         entier          2147483647      Valeur entière maximum
INT_MIN         entier          -2147483648     Valeur entière minimum
HUGE_VAL        réel            1.797693e+308   Valeur réelle absolue maximum
PI              réel            3.14159265359
OSTYPE          texte           <Type OS>       "Unix", "Windows" ou "Amiga"
OSVER           entier          <Version OS>
OSREV           entier          <Révision OS>
MBVER           entier          <Version MUIbase>
MBREV           entier          <Révision MUIbase>
LANGUAGE        texte           dépendant       Langue par défaut
SEEK_SET        entier          cf. stdio.h     Seek depuis début de fichier
SEEK_CUR        entier          cf. stdio.h     Seek depuis position courante
SEEK_END        entier          cf. stdio.h     Seek depuis fin de fichier

Voir constantes, pour plus d'informations sur les constantes. Pour définir vos propres constantes, utilisez l'instruction du préprocesseur #define (voir #define).


16.26 Paramètres fonctionnels

Vous pouvez passer une fonction comme argument à une autre fonction. C'est utile pour définir des fonctions évoluées, comme par exemple pour trier ou construire une liste.

Pour appeler une fonction qui a été passée dans un argument vous devez utiliser la fonction FUNCALL (voir FUNCALL).

Exemple :

 
(DEFUN map (l fun)              # arguments: list and function
    (LET (res)                  # local variable res, initialized with NIL
        (DOLIST (i l)           # for all items one by one
            (SETQ res
                (CONS (FUNCALL fun i) res)       # calls function and
            )                                    # build new list
        )
        (REVERSE res)           # we need to reverse the new list
    )
)

Vous pouvez maintenant employer la fonction map par exemple pour incrémenter tous les articles d'une liste de nombres entiers :

`(map (LIST 1 2 3 4) 1+)' donne ( 2 3 4 5 ).

Voir aussi FUNCALL, APPLY, MAPFIRST.


16.27 Spécificateurs de type

Il est possible d'indiquer le type d'une variable en ajoutant un spécificateurs de type derrière son nom. Les spécificateurs de type suivants existent :

 
Spécificateur   Description

:INT        pour les entiers
:REAL       pour les réels
:STR        pour les chaînes
:MEMO       pour les mémos
:DATE       pour les dates
:TIME       pour les heures
:LIST       pour les listes
:FILE       pour les descripteurs de fichier
:FUNC       pour les fonctions de n'importe quel type
:table      pour les pointeurs d'enregistrement sur table

un spécificateur de type s'accole au nom de variable comme dans l'exemple suivant :

 
(LET (x:INT (y:REAL 0.0) z) ...)

L'exemple définit trois nouvelles variables `x', `y' et `z', où `x' est de type entier et initialisé avec NIL, `y' est de type réel et initialisé avec 0.0, et `z' est une variable sans type initialisé avec NIL.

L'avantage des spécificateurs de type est que le compilateur peut détecter plus d'erreurs de typage, p. ex. si vous avez une fonction :

 
(DEFUN foo (x:INT) ...)

et que vous l'appelez avec `(foo "bar")', le compilateur produira un message d'erreur. Cependant, si vous appelez `foo' avec une valeur non typée, p. ex. `(foo (FIRST list))' alors aucune vérification d'erreur de typage ne peut être faite lors de la compilation puisque le type de `(FIRST list)' est inconnu à ce moment.

Pour des raisons de performance, aucune vérification de typage n'est actuellement faite lors de l'exécution. Cela pourrait être implémenté, mais ajouterait une légère surcharge inutile puisque de toute façon un mauvais type produira tôt ou tard une erreur de typage.

Les spécificateurs de type pour les pointeurs d'enregistrements ont une autre fonction utile. Si vous étiquetez une variable comme pointeur d'enregistrement vers une table alors vous pourrez accéder à tous les champs de cette table en employant le nom de la variable au lieu de celui de la table dans le chemin d'accès au champ. Par exemple si vous avez une table `Foo' avec un champ `Bar', et que vous définissez une variable `foo' comme :

 
(LET (foo:Foo))

alors vous pourrez afficher le champ `Bar' du troisième enregistrement en utilisant :

 
(SETQ foo (RECORD Foo 3)) (PRINT foo.Bar)

Notez que dans une expression select-from-where, les variables définies dans la liste ont automatiquement un type pointeur d'enregistrement vers la table correspondante.


16.28 Sémantique des expressions

La sémantique des expressions est très importante pour la compréhension des programmes. Cette section énumère la sémantique selon des expressions syntaxiques.

(func [expr ...])

Évalue expr ... puis appelle la fonction func (appel par valeur). Renvoie la valeur de retour de la fonction appelée. Dans MUIbase il existe quelques fonctions non strictes, par exemple. AND, OR et IF. Ces fonctions peuvent ne pas évaluer toutes les expressions. Pour plus d'informations sur les fonctions non strictes, voir Lisp syntax, AND, OR, et IF.

([expr ...])

Évalue expr ... et renvoie la valeur de la dernière expression (voir PROGN). Une expression vide () s'évalue en NIL.

Table

Renvoie le pointeur d'enregistrement du programme pour la table.

Table*

Renvoie le pointeur d'enregistrement de l'interface pour la table de données.

AttrPath

Renvoie le contenu du champ spécifié. Le chemin du champ spécifie quel enregistrement est utilisé pour extraire la valeur du champ. Par exemple `Table.Champ' utilise l'enregistrement du programme `Table' pour extraire la valeur du champ, `Table.ChampRéférence.Champ' utilise l'enregistrement du programme `Table' pour extraire la valeur du champ de référence (qui est un pointeur d'enregistrement) et utilise alors cet enregistrement pour extraire la valeur `Champ'.

var

Renvoie le contenu de la variable globale ou locale var. Les variables globales peuvent être définies avec DEFVAR (voir DEFVAR), et les variables locales par exemple avec LET (voir LET).

var.AttrPath
Utilise le pointeur d'enregistrement var pour déterminer la valeur du champ spécifié.


16.29 Déclenchement de fonction

Pour exécuter automatiquement des programmes MUIbase vous pouvez spécifier des fonctions « déclencheurs » sur les projets, les tables et les champs qui sont appelés dans des cas spécifiques. Cette section énumère toutes les possibilités de déclenchement.


16.29.1 onOpen

Après l'ouverture d'un projet, MUIbase recherche dans le programme du projet une fonction appelée onOpen. Si une telle fonction existe alors elle est appelée sans aucun argument.

Exemple

 
(DEFUN onOpen ()
    (ASKBUTTON NIL "Merci de m'ouvrir !" NIL NIL)
)

Voir aussi onClose, onAdminMode, onChange, la démo `Trigger.mb'.


16.29.2 onReload

Similar to onOpen (voir onOpen) MUIbase calls the function onReload when reloading a project, e.g. by selecting menu item `Project - Reload'. The function is called without any arguments.

However, onReload is only called in case there are no structural changes to the project, i.e. no tables or attributes were changed, added or deleted, no changes to the project program were made, and no other changes are present that qualify as a structural change. In such a case, a reload is considered a re-opening of the project, and the function onOpen is called instead.

See also onOpen, onClose, onAdminMode, onChange.


16.29.3 onClose

Avant la fermeture d'un projet, MUIbase recherche dans le programme du projet une fonction appelée onClose. Si une telle fonction existe alors elle est appelée sans argument. Dans la version courante le résultat de ce déclencheur est ignoré et le projet est fermé sans se soucier de sa valeur de retour.

Si vous effectuez des modifications du projet dans la fonction onClose, alors MUIbase vous demandera d'abord de sauvegarder le projet avant de le fermer réellement. Si vous utilisez le menu `Projet - Sauver & Fermer' pour la fermeture d'un projet, le déclenchement sera appelé avant de sauver le projet, ainsi les changements seront sauvés automatiquement.

Exemple

 
(DEFUN onClose ()
    (ASKBUTTON NIL "Au revoir !" NIL NIL)
)

Voir aussi onOpen, onChange, demo `Trigger.mb'.


16.29.4 onAdminMode

À chaque fois qu'un projet passe en mode administrateur ou utilisateur et qu'une fonction appelle onAdminMode existe dans un programme projet alors cette fonction est appellée. La fonction reçoit un argument admin indiquant si le projet est en mode administrateur (admin n'est pas NIL) ou en mode utilisateur (admin est NIL).

Exemple

 
(DEFUN onAdminMode (admin)
    (IF admin
        (ASKBUTTON NIL "Maintenant en mode administrateur" NIL NIL)
        (ASKBUTTON NIL "Revenu en mode utilisateur" NIL NIL)
    )
)

Voir aussi onOpen, onChange, SETADMINMODE, la démo `Users.mb'.


16.29.5 onChange

À chaque fois que l'utilisateur fait des changements sur un projet ou après avoir enregistré un projet, MUIbase recherche dans le programme du projet une fonction appelée onChange. Si une telle fonction existe, elle est exécutée sans argument. Ce qui peut être utilisé pour compter les changements faits par l'utilisateur sur un projet.

Exemple

 
(DEFUN onChange ()
    (SETQ Control.NumChanges (CHANGES))
)

Dans l'exemple ci-dessus `Control.NumChanges' pourrait être un champ virtuel quelque part dans une table de type `Exactement un enregistrement' pour afficher le nombre de modifications du projet.

Voir aussi onOpen, onClose, onAdminMode, la démo `Trigger.mb'.


16.29.6 logLabel

When creating a new entry for the project's log, MUIbase searches the project's program for a function with the name logLabel. If it exists, it calls this function without any arguments. The returned expression is converted to a string and used for the `_Label' field of the new log entry (voir Set log label).

Example

 
(DEFUN logLabel ()
    Control.CurrentUser.Name
)

The above example has been taken from the `Users.mb' project. Here the label is the name of the current user who opened the project. This means that all changes by the current user are tagged with his or her name. Thus, it is later possible to identify which user performed which change.

See also onChange, demo `Users.mb'.


16.29.7 mainWindowTitle

If a project's program contains a function with the name mainWindowTitle then the result of this function is used for setting the window title of the project's main window. The function is called without any arguments and should return a string value. The window title is automatically re-computed whenever an attribute used in the function changes.

In case mainWindowTitle does not exist, the window title shows the project's name.

Note that, in any case, MUIbase prepends the title with a `*' character whenever the project has any unsaved changes.

See also demo `Trigger.mb'.


16.29.8 Déclencheur de création

Quand l'utilisateur veut allouer un nouvel enregistrement en sélectionnant l'un des éléments du menu `Nouvel enregistrement' ou `Dupliquer l'enregistrement' et qu'un déclencheur de `Création' a été spécifié pour cette table, cette fonction de déclenchement est exécutée. Le déclencheur de `Création' peut être spécifié dans la fenêtre de saisie des tables (voir Création de tables).

Le déclencheur reçoit NIL ou un pointeur d'enregistrement en tant que premier et seul argument. NIL signifie que l'utilisateur veut allouer un nouvel enregistrement tandis qu'un pointeur d'enregistrement signifie que l'utilisateur veut dupliquer cet enregistrement. Si le déclencheur possède plus d'un argument alors ceux-ci seront initialisés avec NIL. Le déclencheur doit allouer le nouvel enregistrement en appelant la fonction NEW (voir NEW). Le résultat retourné par le déclencheur sera examiné et s'il renvoie un pointeur d'enregistrement alors l'enregistrement sera affiché.

Le déclencheur de `Création' est également exécuté lorsqu'un programme MUIbase appelle la fonction NEW* (voir NEW*).

Exemple de déclencheur de création

 
(DEFUN nouvelEnregistrement (init)
    (PROG1                      ; pour renvoyer le résultat de NEW
        (NEW Table init)
        ...
    )
)

Voir aussi NEW, NEW*, Delete trigger.


16.29.9 Déclencheur de suppression

Lorsque l'utilisateur veut supprimer un enregistrement en sélectionnant l'élément du menu `Supprimer l'enregistrement' et qu'un déclencheur de `Suppression' a été spécifié pour cette table, alors cette fonction de déclenchement est exécutée. Le déclencheur de `Suppression' peut être spécifié dans la fenêtre de saisie des tables (voir Création de tables).

Le déclencheur reçoit un argument booléen comme seul argument. Si l'argument est différent de NIL alors la fonction demande à l'utilisateur s'il veut vraiment supprimer l'enregistrement. Si c'est le cas, le déclencheur doit appeler DELETE (voir DELETE) pour supprimer l'enregistrement.

Le déclencheur de `Suppression' est également appelé lorsqu'un programme MUIbase appelle la fonction DELETE* (voir DELETE*).

Exemple de déclencheur de suppression

 
(DEFUN supprimerEnregistrement (confirmation)
    (DELETE Table confirmation)
)

Voir aussi DELETE, DELETE*, New trigger.


16.29.10 Fonction de comparaison

Pour trier les enregistrements d'une table vous pouvez utiliser une fonction de comparaison. Voir Voir Changer le tri, pour savoir comment doit être spécifiée une telle fonction pour une table. La fonction prend deux pointeurs d'enregistrements en arguments et renvoie une valeur entière reflétant l'ordre de tri des deux enregistrements. La fonction de comparaison doit renvoyer une valeur inférieure à 0 si son premier argument est plus petit que le second, 0 s'ils sont équivalents et une valeur supérieure à 0 si le premier argument est plus grand que le second.

Par exemple, si vous avez une table `Personnes' avec un champ de type chaîne `Nom' alors vous pourriez utiliser la fonction suivante pour comparer deux enregistrements :

 
(DEFUN cmpPersonnes (rec1:Personnes rec2:Personnes)
    (CMP rec1.Nom rec2.Nom)
)

Ceci triera tous les enregistrements selon le champ `Nom' en utilisant la comparaison de chaîne sensible à la casse. Notez qu'en utilisant une liste de champs vous ne pourriez pas obtenir le même tri car, dans le cas des listes de champs, une comparaison de chaînes sensible à la casse est effectuée.

En utilisant une fonction de comparaison vous pouvez définir des relations d'ordre très complexes. Faîtes attention à ne pas créer de fonctions récursives qui s'appelleraient elles-mêmes. MUIbase arrêtera l'exécution du programme et vous affichera un message d'erreur si vous essayez de faire cela. En outre, vous ne devez pas utiliser de commandes à effets de bord, par exemple positionner la valeur d'un champ.

En utilisant une fonction de comparaison, MUIbase ne sait pas toujours lorsqu'il doit réordonner les enregistrements. Par exemple si l'on considère dans l'exemple précédent une nouvelle table `Jouets' possédant un champ de type chaîne `Nom' et une référence `Propriétaire' vers `Personnes' et la fonction suivante pour comparer les enregistrements :

 
(DEFUN cmpJouets (rec1:Jouets rec2:Jouets)
    (CMP* rec1.Proprietaire rec2.Propriétaire)
)

Cette fonction utilise le tri des `Personnes' pour déterminer l'ordre de tri des enregistrements, par conséquent les enregistrements de `Jouets' sont classés selon le tri des `Personnes'.

Maintenant si l'utilisateur modifie un enregistrement de la table `Personnes' et que la position (dans le tri) de cet enregistrement change, alors tous les enregistrements de dans `Jouets' se rapportant à cet enregistrement ont besoin d'être réordonnés. Cependant, MUIbase ne connaît pas cette dépendance.

En plus d'utiliser le menu `Table - Réordonner tous les enregistrements' pour retrier les enregistrements de la table `Jouets', vous pouvez mettre en place une réorganisation automatique en spécifiant le déclencheur de champ suivant sur le champ `Nom' de la table `Personnes':

 
(DEFUN setNom (nouvelleValeur)
    (SETQ Personnes.Nom nouvelleValeur)
    (FOR ALL Jouets WHERE (= Jouets.Proprietaire Personnes) DO
        (SETISSORTED Jouets NIL)
    )
    (REORDER Jouets)
)

La fonction supprime l'information de tri pour tous les enregistrements se rapportant à l'enregistrement courant de la table `Personnes' et réordonné alors tous les enregistrements non triés de la table `Jouets'.

Voir aussi Order, CMP, GETISSORTED, SETISSORTED, REORDER, REORDERALL, GETORDERSTR, SETORDERSTR, la démo `Order.mb'.


16.29.11 Déclencheur de champ

Dans la fenêtre de création de champs (voir Création de champs) vous pouvez définir une fonction qui sera déclenchée toutes les fois que l'utilisateur voudra modifier le contenu d'un champ : le déclencheur de champ.

Si vous avez défini une telle fonction pour un champ et que l'utilisateur modifie la valeur de ce champ alors le contenu de l'enregistrement ne sera pas automatiquement mis à jour avec la nouvelle valeur. Au lieu de cela la valeur est passée en paramètre au déclencheur. Le déclencheur peut alors vérifier la valeur et éventuellement la refuser. Pour stocker la valeur dans un enregistrement vous devez utiliser la fonction SETQ.

Le déclencheur doit renvoyer le résultat de l'appel à SETQ ou l'ancienne valeur du champ s'il décide de refuser la nouvelle.

Le déclencheur est également appelé lorsqu'un programme MUIbase fait appel à la fonction SETQ* (voir SETQ*) pour positionner la valeur d'un champ.

Exemple de déclencheur de champ

 
(DEFUN setMontant (montant)
    (IF une-expression
        (SETQ Table.Montant montant)
        (ASKBUTTON NIL "Valeur Invalide !" NIL NIL)
    )
    Table.Montant                       ; retourne la valeur courante
)

Voir aussi SETQ*


16.29.12 Programmation de champs virtuels

Dans MUIbase les champs virtuels sont des champs spéciaux qui calculent leur valeur à chaque fois que c'est nécessaire. Par exemple si vous passez à un autre enregistrement en cliquant sur le bouton flèche dans le panneau de contrôle d'une table. Le champ virtuel de cette table sera alors automatiquement recalculé et affiché (les réglages appropriés pour le champ virtuel étant fournis, voir éditeur d'objet champ). Pour calculer la valeur du champ, le déclencheur de `Calcul' est appelé. Ce déclencheur peut être spécifié dans la fenêtre de saisie de champ (voir Réglages liés au type). La valeur renvoyée par ce déclencheur définit la valeur du champ virtuel. Si vous ne spécifiez aucun déclencheur de `Calcul' pour un champ virtuel, alors la valeur du champ est NIL

Vous pouvez également déclencher le calcul d'un champ virtuel en y accédant simplement à partir d'un programme MUIbase. Ainsi par exemple, si vous avez un bouton qui doit calculer la valeur d'un champ virtuel, vous devrez seulement spécifier une fonction pour le bouton comme celle qui suit :

 
(DEFUN buttonHook ()
    champ-virtuel
)

Vous pouvez également donner à un champ virtuel n'importe quelle valeur en utilisant la fonction SETQ :

 
(SETQ champ-virtuel expr)

Cependant si vous accédez au champ virtuel après l'appel de SETQ, la valeur du champ virtuel sera recalculée.

Il n'y a pas de mécanisme de cache de la valeur d'un champ virtuel parce qu'il n'est pas facile de savoir quand la valeur doit ou ne doit pas être recalculée. Par conséquent, il est préférable d'accéder rarement aux champs virtuels et d'en mémoriser la valeur dans des variables locales pour un usage ultérieur.

Pour un exemple sur la façon d'utiliser les champs virtuels veuillez consulter la démo `Movie.mb' .

Voir aussi Champs virtuels, la démo `Movie.mb'.


16.29.13 Fonction de calcul d'activation

Pour les objects champs et les boutons de fenêtre il est possible de spécifier une fonction pour calculer l'état d'activation de l'objet. Voir Éditeur d'objet champ et Éditeur de fenêtre, pour savoir comment spécifier ce déclencheur.

La fonction déclencheur est appelée sans argument. Elle doit renvoyer NIL pour désactiver l'objet et toute autre valeur pour l'activer.

Par exemple la fonction d'activation d'un objet qui est activé lorsqu'un champ virtuel de type `Liste' a un élément sélectionné ressemblerait à :

 
(DEFUN activeObjet ()
    (GETVIRTUALLISTACTIVE champ-liste-virtuel)
)

Voir aussi Éditeur d'objet champ, Éditeur de fenêtre, la démo `Users.mb'.


16.29.14 Calculer la description de l'enregistrement

For table objects and attribute objects of type reference, a tigger function can be entered for computing a record description (voir Table object editor and Attribute object editor).

The trigger function is called without any arguments. It should return a single expression or a list of expressions.

For example, in a table `Person' with attributes `Name' and `Birthday', the function could look like this:

 
(DEFUN personDescription ()
(LIST Person.Name Person.Birthday)
)

See also Table object editor, Attribute object editor.


16.29.15 Déclencheur de double-clic

Pour les champs virtuels utilisant un affichage de type liste pour leurs contenus, il est possible de spécifier une fonction exécutée toutes les fois que l'utilisateur double clique sur un élément de la liste. Voir Éditeur d'objet champ, pour savoir comment spécifier ce déclencheur sur un objet champ virtuel.

Ces déclencheurs sont appelés avec trois arguments. Le premier argument contient le numéro de ligne du champ cliqué, commençant par 1 pour la première ligne (la ligne 0 se rapporte à l'en-tête de la liste). Le deuxième argument contient le numéro de colonne en commençant par 0. Le troisième argument est un pointeur d'enregistrement à partir auquel correspond l'élément de la liste ou NIL s'il n'a pas été produit directement à partir d'un enregistrement. Le code retour de la fonction est ignoré.

L'exemple typique de déclencheur de double-clic est le suivant :

 
(DEFUN declencheurDoubleClic (lig col enr:Table)
    ...
)

Ici enr est déclaré en tant que pointeur d'enregistrement vers la table Table. De cette manière il est possible d'accéder aux champs de Table à partir de enr.

Au cas où l'argument enregistrement pourrait appartenir à plusieurs tables, la construction suivante utilisant les prédicats de typage pour différencier les tables peut être utile.

 
(DEFUN doubleClickTrigger (lig col enr)
    (COND
        ((RECP Table1 enr) (SETQ Table1 enr) ...)
        ((RECP Table2 enr) (SETQ Table2 enr) ...)
        ...
    )
)

L'élément de la liste sur lequel l'utilisateur a cliqué peut ne se rapporter à aucun enregistrement. Dans ce cas-là, le troisième argument peut être ignoré et l'accès à l'élément de la liste se fait comme dans l'exemple suivant :

 
(DEFUN declencheurDoubleClic (lig col)
    (PRINT (NTH col (NTH lig attr-virtuel)))
)

Voir aussi Éditeur d'objet champ, la démo `Movie.mb'.


16.29.16 Calculer les étiquettes des listes

Pour les champs chaînes, l'objet graphique peut contenir une liste déroulante permetant à l'utilisateur de choisir parmi une liste de chaînes. Les étiquettes de cette liste peuvent être statiques ou être calculées dynamiquement par un déclencheur. Voir Éditeur d'objet champ, pour avoir des informations sur la façon de choisir entre des étiquettes statiques ou dynamiques et de spécifier la fonction déclencheur.

Le déclencheur pour le calcul des étiquettes ne requiert aucun argument. Elle doit retourner un mémo avec une étiquette par ligne ou NIL pour aucune étiquette.

Par exemple la fonction de calcul pourrait ressembler à ceci :

 
(DEFUN calculerEtiquettes ()
    "Tokyo\nMunich\nLos Angeles\nRome"
)

Voir aussi Calculer les enregistrements référencés, Éditeur d'objet champ.


16.29.17 Calculer les enregistrements référencés

Pour les champs référence, l'objet graphique possède généralement un bouton permettant d'ouvrir une liste d'enregistrements parmi lesquels l'utilisateur peut faire son choix. La liste de ces enregistrements peut être calculée par un déclencheur. Voir Éditeur d'objet champ, pour avoir des informations sur la manière de spécifier le déclencheur pour les champs références. on how to specify

La fonction de calcul de la liste d'enregistrements ne requiert aucun argument. Elle doit retourner une liste devant contenir des enregistrements de la table référencée. Tout enregistrement de cette table est ajouté à la liste affichée. Les éléments qui ne sont pas des enregistrements de la table référencée sont ignorés silencieusement.

L'exemple suivant illustre une fonction typique de calcul d'enregistrements référencés. Disons qu'un projet contient une table`Persone' avec un champ booléen `Femme'. Alors la fonction de calcul suivante n'affiche que les personnes féminines dans la liste déroulante :

 
(DEFUN calculerEnregistrementsFemme ()
    (SELECT Personen FROM Personne WHERE Femme)
)

Voir aussi Calculer les étiquettes des listes, Éditeur d'objet champ.


16.30 Liste des fonctions obsolètes

Les fonctions suivantes sont obsolètes depuis la version 2.7 de MUIbase.

  • GETDISABLED
  • SETDISABLED
  • GETWINDOWDISABLED
  • SETWINDOWDISABLED

Les fonctions obsolètes ne fonctionnent plus comme attendu et leur appel est soit ignoré (donnant une non-opération), soit ouvre une fenêtre d'avertissement, soit cause une erreur selon le réglage du menu `Programme - Fonctions obsolètes' (voir Fonctions obsolètes).

Il est recommandé d'enlever ces fonctions des programmes et d'implémenter la fonctionnalité en utilisant le réglage activé/désactivé des objets champ et des boutons de fenêtre (voir Fonction de calcul d'activation).


[ << ] [ >> ]           [Sommaire] [Table des matières] [Index] [ ? ]

Ce document a été généré le 11 Septembre 2016 par texi2html