[ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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 :-)).
15.1 Editeur de programme Où saisir un programme MUIbase. 15.2 Code source externe Utiliser son éditeur favori pour programmer. 15.3 Préprocesseur Inclusions, compilation conditionnelle et constantes. 15.4 Langage de programmation La syntaxe des expressions.   Fonctions     15.5 Commandes de définition Définitions de fonction et de variable. 15.6 Structures de contrôle Boucles, expressions conditionnelles et cetera. 15.7 Prédicats de typage Examiner le type d'une expression. 15.8 Fonctions de conversion de type Conversion de type. 15.9 Fonctions booléennes AND, OR, et NOT. 15.10 Fonctions de comparaison Comparer les valeurs des expressions. 15.11 Fonctions mathématiques Ajouter, Multiplier, etc. 15.12 Fonctions sur les chaînes Choses utiles sur les chaînes de caractères. 15.13 Fonctions sur les mémo Choses utiles sur les mémos. 15.14 Fonctions sur la date et l'heure Choses utilies sur les dates et les heures. 15.15 Fonctions sur les listes Commandes de traitement de liste. 15.16 Functions de demande de saisie Demander une saisie à l'utilisateur. 15.17 Function d'E/S Commandes de lecture/écriture de fichier. 15.18 Fonctions sur les enregistrements Choses utiles sur les enregistrements. 15.19 Fonctions sur les champs Manipuler les champs. 15.20 Fonctions sur les tables Manipuler les tables. 15.21 Fonctions d'Interface Manipuler l'interface graphique. 15.22 Fonctions sur les projets Récupérer des informations à propos du projet. 15.23 Fonctions système Fonctions en relation avec le système d'exploitation. 15.24 Variables Variables prédéfinies. 15.25 Constantes Constantes prédéfinies.   Informations utiles     15.26 Paramètres fonctionnels Utiliser des fonctions comme argument dans des appels de fonction. 15.27 Spécificateurs de type Types pour les variables. 15.28 Sémantique des expressions La signification d'une expression. 15.29 Déclenchement de fonction Comment déclencher des fonctions. 15.30 Liste des fonctions obsolètes Les fonctions ayant disparu et devant être remplacées.   Index des fonctions Index de toutes les fonctions.
Pour saisir un programme dans un projet, ouvrez l'éditeur de programme en sélectionnant le menu `Programme - Editer'. Si vous êtes configuré en code source en interne (voir Code source), cela ouvre la fenêtre `Edition de programme' qui contient :
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 Editeur externe) est lancé avec le nom du fichier source externe lors de la sélection du menu `Programme - Editer'. 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.
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.
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 #.
15.3.1 #define Définir des constantes. 15.3.2 #undef Supprimer la définition de constantes. 15.3.3 #include Inclure des fichiers externes. 15.3.4 #if Compilation conditionnelle. 15.3.5 #ifdef Compilation conditionnelle. 15.3.6 #ifndef Compilation conditionnelle. 15.3.7 #elif Compilation conditionnelle. 15.3.8 #else Compilation conditionnelle. 15.3.9 #endif Compilation conditionnelle.
|
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 |
#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.
|
Voir aussi #define, #ifdef, #ifndef.
|
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.
|
#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.
|
#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.
|
#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.
|
#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 :
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.
|
#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.
|
#if
, #ifdef
ou #ifndef
.
Chacune de ces directives doit avoir un #endif
correspondant.
Voir aussi #if, #ifdef, #ifndef, #elif, #else.
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
).
15.4.1 Pourquoi Lisp ? Les avantages de lisp. 15.4.2 Syntaxe Lisp La syntaxe des langages de programmation. 15.4.3 Types de programmes Les différentes types de programmes utilisés dans MUIbase. 15.4.4 Conventions de nommage Conventions de nommage des symboles d'un programme. 15.4.5 Accéder aux enregistrements Utiliser les champs et les tables dans les programmes. 15.4.6 Type de données Types de données disponibles pour programmer. 15.4.7 Constantes Les expressions constantes. 15.4.8 Typographie utilisée La typographie utilisée pour descrire les commandes.
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.
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) |
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.
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 Editeur 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 Editeur 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).
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 :
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'.
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. |
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. |
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 :
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.
15.5.1 DEFUN Définition de fonction. 15.5.2 DEFUN* Définition de fonction avec nom masqué. 15.5.3 DEFVAR Définition de variable globale. 15.5.4 DEFVAR* Variable globale mémorisant sa valeur.
DEFUN
définit une fonction ayant le nom spécifié, une liste d'arguments
passés à la fonction et une liste d'expressions à évaluer.
|
Les paramètres liste-var spécifient les arguments de la fonction :
liste-var: var1 ... |
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))) ) ) |
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.
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.
|
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.
|
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.
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.
15.6.1 PROGN Compound statement, returns last expression. 15.6.2 PROG1 Compound statement, returns first expression. 15.6.3 LET Définit les variables locales. 15.6.4 SETQ Positionne la valeur des variables, champs et tables. 15.6.5 SETQ* Positionne la valeur des variables, champs et tables. 15.6.6 FUNCALL Appelle une fonction avec des arguments. 15.6.7 APPLY Applique une fonction à une liste d'arguments. 15.6.8 IF Si-alors-sinon : exécution conditionnelle de programme. 15.6.9 CASE Selon-cas : exécution conditionnelle de programme. 15.6.10 COND Puissante instruction d'exécution conditionnelle de programme. 15.6.11 DOTIMES Boucle sur un intervalle de valeurs entières. 15.6.12 DOLIST Boucle sur une liste. 15.6.13 DO Boucle générique. 15.6.14 FOR ALL Boucle sur un ensemble d'enregistrements. 15.6.15 NEXT Passe à la prochaine exécution de la boucle. 15.6.16 EXIT Sort de la boucle. 15.6.17 RETURN Quitte une fonction. 15.6.18 HALT Arrête l'exécution du programme. 15.6.19 ERROR Avorte l'exécution du programme avec un message d'erreur.
Pour évaluer plusieurs expressions l'une à la suite de l'autre,
il est possible d'utiliser la construction PROGN
.
|
(PROGN
[expr
...])
.
Exemple: `(1 2 3 4)' retourne 4.
Voir aussi PROG1.
Une autre manière, hormis la fonction PROGN
, pour évaluer plusieurs
expressions séquentiellement est l'expression PROG1
.
|
Exemple: `(PROG1 1 2 3 4)' retourne 1.
Voir aussi PROGN.
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
|
liste-var : varspec ... |
varspec : |
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) ) |
Voir aussi DOTIMES, DOLIST, DO, DEFVAR.
La fonction SETQ
affecte des valeurs à des variables, des champs et des tables.
|
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.
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.
FUNCALL
est utilisé pour appeler une fonction avec des arguments.
|
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.
APPLY
est utilisé pour appliquer une fonction à une liste d'arguments.
|
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.
IF
est un opérateur conditionnel.
|
Cette fonction n'est pas stricte, c'est à dire qu'une seule des expressions expr2 ou expr3 est évaluée.
CASE
est similaire à l'instruction switch
du langage C.
|
case: |
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.
COND
est, comme IF
, un opérateur conditionnel.
|
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.
(COND ((> 1 2) "1 > 2") ((= 1 2) "1 = 2") ((< 1 2) "1 < 2") ) |
Pour des boucles simples, la commande DOTIMES
est utilisable.
|
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.
(DOTIMES (i 50 i) (PRINT i)) |
Voir aussi DOLIST, DO, FOR ALL, LET.
Pour boucler sur des listes, l'expression DOLIST
peut être utilisée.
|
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.
(DOLIST (i (SELECT * FROM Comptes)) (PRINT i)) |
Voir aussi DOTIMES, DO, FOR ALL, LET.
L'expression DO
permet de programmer des boucles arbitraires.
|
(
nom init [pas])
où nom est le nom de la nouvelle variable, init est la valeur initiale
de cette variable et pas est l'expression de pas (NDT: c'est à dire que
c'est elle qui modifie la valeur de la variable d'une exécution de boucle à une
autre).
De plus 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.
(DO ((i 0 (+ i 1))) ((>= i 5) i) (PRINT i)) |
DOTIMES
.
Voir aussi DOTIMES, DOLIST, FOR ALL, LET.
L'expression FOR ALL
est utilisée pour boucler sur une liste d'enregistrements.
|
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)) ) |
FOR ALL
renvoie NIL.
Voir aussi SELECT, DOTIMES, DOLIST, DO.
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)) ... ) |
EXIT
peut être utilisé pour terminer 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 ...) ...) |
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)) ... ) |
Lors de la définition d'une fonction, il est
possible de rendre la main à l'appelant en
utilisant la commande RETURN
.
|
(DEFUN find-record (nom) (FOR ALL Table DO (IF (= Nom nom) (RETURN Table)) ) ) |
HALT
peut être utilisé pour terminer l'exécution du programme.
|
Voir aussi ERROR, EXIT, RETURN.
Pour avorter l'exécution du programme avec un message
d'erreur, il est possible d'utiliser la fonction ERROR
.
|
SPRINTF
(voir SPRINTF).
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 |
Cette section liste les fonctions de conversion d'un type vers un autre.
15.8.1 STR Convertir en chaîne. 15.8.2 MEMO Convertir en mémo. 15.8.3 INT Convertir en entier. 15.8.4 REAL Convertir en réel. 15.8.5 DATE Convertir en date. 15.8.6 TIME Convertir en heure.
STR
est utilisé pour convertir une expression vers une
représentation en chaîne.
|
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. |
MEMO
est utilisé pour convertir une expression en mémo.
|
STR
(voir STR) mais retourne un mémo plutôt qu'une chaîne.
Voir aussi STR.
INT
est utilisé pour convertir une expression en entier.
|
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. |
REAL
est utilisé pour convertir une expression en une valeur de type réel.
|
INT
(voir INT) mais renvoie une valeur de type réel au lieu d'un entier.
Voir aussi INT.
DATE
est utilisé pour convertir une expression en une date.
|
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. |
TIME
est utilisé pour convertir une expression en une heure.
|
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. |
Cette section liste les opérateurs booléens.
15.9.1 AND Conjonction de valeurs booléennes. 15.9.2 OR Disjonction de valeurs booléennes. 15.9.3 NOT Inversion d'une valeur booléenne.
AND
vérifie que tous ses arguments sont vrais (TRUE).
|
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.
OR
vérifie que tous les arguments 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.
NOT
est utilisé pour inverser la valeur d'une expression booléenne.
|
Cette section présente les fonctions de comparaison de valeur.
15.10.1 Opérateurs relationnels =, <>, <, >, <=, >= et leur version étoilée. 15.10.2 CMP Retourne un entier représentant l'ordre. 15.10.3 CMP* Comparaison étendue, p. ex. sensible à la casse.
Pour comparer deux valeurs dans un programme MUIbase, il faut utiliser
|
=
, <>
, <
, >
, >=
,
<=
, =*
, <>*
, <*
, >*
, >=*
, <=*
}.
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) |
CMP
retourne un entier représentant l'ordre de ses arguments.
|
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.
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.
Ici quelques fonctions mathématiques sont listées.
15.11.1 + Ajouter des valeurs. 15.11.2 - Soustraire des valeurs. 15.11.3 1+ Incrémenter une valeur. 15.11.4 1- Décrémenter une valeur. 15.11.5 * Multiplication en virgule flottante. 15.11.6 / Division en virgule flottante. 15.11.7 DIV Division entière. 15.11.8 MOD Modulo entier. 15.11.9 MAX Expression maximum. 15.11.10 MIN Expression minimum. 15.11.11 ABS Valeur absolue d'une expression. 15.11.12 TRUNC Tronquer les décimales d'une valeur réelle. 15.11.13 ROUND Arrondir une valeur réelle. 15.11.14 RANDOM Générateur de nombre aléatoire.
Pour ajouter des valeurs, utilisez
|
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.
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 |
Pour soustraire des valeurs, utilisez
|
(-
expr)
a une signification particulière :
cela retourne la valeur négative de expr (entier ou réel),
p. ex.
`(- (+ 1 2))' retourne -3.
1+
incrémente de un une expression entière ou réelle.
|
1-
décrémente de un une expression entière ou réelle.
|
Pour multiplier des valeurs entières/réelles, utilisez :
|
Pour divisez des valeurs entières/réelles, utilisez :
|
DIV
permet d'effectuer des divisions entières.
|
MOD
permet de calculer le modulo.
|
Voir aussi DIV.
MAX
retourne l'argument ayant la plus grande valeur.
|
Voir aussi MIN.
MIN
retourne l'argument ayant la plus petite valeur.
|
Voir aussi MAX.
ABS
calcule al valeur absolue d'une expression.
|
TRUNC
tronque les décimales d'une valeur réelle.
|
Exemples: `(TRUNC 26.1)' renvoie 26, `(TRUNC -1.2)' renvoie -2.
Voir aussi ROUND.
ROUND
arrondit une valeur réelle.
|
Exemples: `(ROUND 70.70859 2)' renvoie 70.71, `(ROUND 392.36 -1)' renvoie 390.0.
Voir aussi TRUNC.
RANDOM
permet de générer des nombres aléatoires.
|
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.
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 |
Cette section concerne les fonctions ayant trait aux chaînes de caractères.
15.12.1 LEN Longueur de la chaîne. 15.12.2 LEFTSTR Sous-chaîne gauche. 15.12.3 RIGHTSTR Sous-chaîne droite. 15.12.4 MIDSTR Sous-chaîne quelconque. 15.12.5 SETMIDSTR Remplacement de sous-chaîne. 15.12.6 INSMIDSTR Insertion de chaîne. 15.12.7 INDEXSTR Première occurence de chaîne, sensible à la casse. 15.12.8 INDEXSTR* Première occurence de chaîne, insensible à la casse. 15.12.9 INDEXBRK Première occurence de caractère, sensible à la casse. 15.12.10 INDEXBRK* Première occurence de caractère, insensible à la casse. 15.12.11 RINDEXSTR Dernière occurence de chaîne, sensible à la casse. 15.12.12 RINDEXSTR* Dernière occurence de chaîne, insensible à la casse. 15.12.13 RINDEXBRK Dernière occurence de caractère, sensible à la casse. 15.12.14 RINDEXBRK* Dernière occurence de caractère, insensible à la casse. 15.12.15 REPLACESTR Remplacement de chaîne, sensible à la casse. 15.12.16 REPLACESTR* Remplacement de chaîne, insensible à la casse. 15.12.17 REMCHARS Suppression de caractères dans une chaîne. 15.12.18 TRIMSTR Suppression de caractères de début et de fin d'une chaîne. 15.12.19 WORD Extraction de mot dans une chaîne. 15.12.20 WORDS Nombre de mots dans une chaîne. 15.12.21 STRTOLIST Conversion d'une chaîne en une liste de sous-chaînes. 15.12.22 LISTTOSTR Conversion d'une liste d'éléments en une chaîne. 15.12.23 CONCAT Concaténation de chaînes. 15.12.24 CONCAT2 Concaténation de chaînes. 15.12.25 COPYSTR Création de copies de chaîne. 15.12.26 SHA1SUM Valeur de hachage SHA1 d'une chaîne. 15.12.27 UPPER Mise en majuscules d'une chaîne. 15.12.28 LOWER Mise en minuscules d'une chaîne. 15.12.29 ASC Valeur Unicode/8 bits d'un caractère. 15.12.30 CHR Caractère de valeur Unicode/8 bits. 15.12.31 LIKE Comparaison de chaînes. 15.12.32 SPRINTF Formatage de chaîne.
LEN
calcule la longueur d'une chaîne.
|
Voir aussi WORDS, LINES, MAXLEN.
LEFTSTR
extrait une sous-chaîne de la chaîne.
|
Exemple: `(LEFTSTR "Hello world!" 5)' retourne "Hello".
Voir aussi RIGHTSTR, MIDSTR, WORD, LINE.
RIGHTSTR
extrait une sous-chaîne de la chaîne.
|
Exemple: `(RIGHTSTR "Hello world!" 6)' retourne "world!".
Voir aussi LEFTSTR, MIDSTR, WORD, LINE.
MIDSTR
extrait une sous-chaîne de la chaîne.
|
Exemple: `(MIDSTR "Hello world!" 3 5)' retourne "lo wo".
Voir aussi LEFTSTR, RIGHTSTR, WORD, LINE, SETMIDSTR, INSMIDSTR.
SETMIDSTR
remplace une partie de la chaîne.
|
Exemple: `(SETMIDSTR "Salut monde!" 6 "Mélanie!")' retourne "Salut Mélanie!".
Voir aussi INSMIDSTR, REPLACESTR.
INSMIDSTR
permet d'insérer une chaîne dans une autre.
|
Exemple: `(INSMIDSTR "Salut le monde !" 14 " de MUIbase")' retourne "Salut le monde de MUIbase !".
Voir aussi SETMIDSTR, REPLACESTR.
INDEXSTR
cherche la première occurrence d'une chaîne dans une autre.
|
Exemple: `(INDEXSTR "Salut monde !" "monde")' retourne 6.
Voir aussi INDEXSTR*, RINDEXSTR, RINDEXSTR*, INDEXBRK, INDEXBRK*.
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*.
INDEXBRK
cherche la première occurrence d'un caractère dans une chaîne.
|
Exemple: `(INDEXBRK " Salut monde!" "aeiou")' retourne 1.
Voir aussi INDEXBRK*, RINDEXBRK, RINDEXBRK*, INDEXSTR, INDEXSTR*.
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*.
RINDEXSTR
recherche la dernière occurrence d'une chaîne dans une autre.
|
Exemple: `(RINDEXSTR "Doo itashimashite." "shi")' returns 11.
Voir aussi RINDEXSTR*, INDEXSTR, INDEXSTR*, RINDEXBRK, RINDEXBRK*.
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*.
RINDEXBRK
recherche la dernière occurrence d'un caractère dans une chaîne.
|
Exemple: `(RINDEXBRK "Konnichiwa" "chk")' retourne 6.
Voir aussi RINDEXBRK*, INDEXBRK, INDEXBRK*, RINDEXSTR, RINDEXSTR*.
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*.
REPLACESTR
remplace des sous-chaînes par d'autres.
|
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.
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.
REMCHARS
supprime des caractères d'une chaîne.
|
Exemple: `(REMCHARS votre-chaîne " \t\n")' supprime tous les espaces, tabulations et retour chariot de votre-chaîne.
Voir aussi REPLACESTR, TRIMSTR.
TRIMSTR
supprime des caractères au début et à la fin d'une chaîne.
|
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.
WORD
retourne un mot contenu dans une chaîne.
|
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.
WORDS
compte le nombre de mots contenus dans une chaîne.
|
Exemple: `(WORDS "En fait, ce n'était pas vraiment mon vélo.")' retourne 8.
STRTOLIST
convertit une chaîne en une liste de sous-chaînes.
|
"\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é.
LISTTOSTR
convertit une liste d'éléments en une chaîne.
|
"\t"
est utilisé.
Si list ou sep sont NIL alors NIL est retourné.
CONCAT
concatène des chaînes.
|
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.
CONCAT2
concatène des chaînes.
|
Exemple: `(CONCAT2 "! " "Mais" "ça" "ne" "l'était" "pas")' retourne "Mais! ça! ne! l'était! pas!".
Voir aussi CONCAT, +, LISTTOSTR, COPYSTR, SPRINTF.
COPYSTR
crée des copies d'une chaîne.
|
Exemple: `(COPYSTR "+-" 5)' retourne "+-+-+-+-+-"
Voir aussi CONCAT CONCAT2, +, SPRINTF.
SHA1SUM
calcule la valeur de hachage SHA1 d'une chaîne.
|
UPPER
convertit une chaîne en majuscules.
|
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.
LOWER
convertit en minuscules une chaîne.
|
Exemple: `(LOWER "La lettre était de Silke.")' retourne "la lettre était de silke.".
Voir aussi UPPER.
ASC
convertit un caractère en sa représentation interne entière.
|
Exemple: (ASC "A")
retourne 65.
CHR
convertit une valeur entière en caractère.
|
Exemple: `(CHR 67)' retourne "C".
LIKE
compare des chaînes.
|
Exemple: `(LIKE "Silke est allé en France pendant un an." "*France*")' retourne TRUE.
Voir aussi Fonctions de comparaison.
SPRINTF
formate une chaîne à partir de diverses données.
|
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 :
|
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.
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é.
SPRINTF
retourne la chaîne formatée ou NIL si fmt est NIL.
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!" |
Cette section traite des fonctions de manipulation des mémos.
15.13.1 LINE Extraire une ligne d'un mémo. 15.13.2 LINES Nombre de lignes dans un mémo. 15.13.3 MEMOTOLIST Convertir un mémo en liste. 15.13.4 LISTTOMEMO Convertir une liste en mémo. 15.13.5 FILLMEMO Remplir un mémo. 15.13.6 FORMATMEMO Formater un mémo. 15.13.7 INDENTMEMO Indenter un mémo.
LINE
extrait une ligne d'un mémo.
|
LINES
retourne le nombre de lignes dans un mémo.
|
MEMOTOLIST
convertit un mémo en une liste de chaînes.
|
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.
`(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.
LISTTOMEMO
convertit une liste en mémo.
|
LISTTOSTR
(voir LISTTOSTR) lui est appliqué avant d'intégrer la chaîne
résultat dans le mémo.
`(LISTTOMEMO (LIST (LIST "Nom" "Date naissance") (LIST "Steffen" 28.11.1968)' retourne "Nom\tDate naissance\nSteffen\t28.11.1968".
Voir aussi LISTTOSTR, MEMOTOLIST.
FILLMEMO
remplit un mémo avec les résultats d'expressions.
|
Exemple: `(FILLMEMO "(+ 1 1) donne $(+ 1 1).")' retourne "(+ 1 1) donne 2."
Le déboguage 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.
FORMATMEMO
formate un mémo.
|
Voir aussi FILLMEMO, INDENTMEMO.
INDENTMEMO
indente un mémo en mettant des espaces à gauche.
|
Voir aussi FILLMEMO, FORMATMEMO.
Cette section concerne les fonctions de manipulation de valeurs de type date et heure.
15.14.1 DAY Extraire le jour à partir d'une date. 15.14.2 MONTH Extraire le mois à partir d'une date. 15.14.3 YEAR Extraire l'année à partir d'une date. 15.14.4 DATEDMY Créer une date à partir du jour, du mois et de l'année. 15.14.5 MONTHDAYS Nombre de jours d'un mois. 15.14.6 YEARDAYS Nombre de jours d'une année. 15.14.7 ADDMONTH Ajouter un nombre de mois à une date. 15.14.8 ADDYEAR Ajouter un nombre d'années à une date. 15.14.9 TODAY Obtenir la date courante. 15.14.10 NOW Obtenir l'heure courante.
DAY
extrait le jour d'une date.
|
Voir aussi MONTH, YEAR, DATEDMY.
MONTH
extrait le mois d'une date.
|
Voir aussi DAY, YEAR, DATEDMY, MONTHDAYS.
YEAR
extrait l'année d'une date.
|
Voir aussi DAY, MONTH, DATEDMY, YEARDAYS.
DATEDMY
crée une date à partir du jour, du mois et de l'année.
|
Exemple: `(DATEDMY 28 11 1968)' donne le 28 novembre 1968.
Voir aussi DATE, TODAY, DAY, MONTH, YEAR.
MONTHDAYS
donne le nombre de jours d'un mois.
|
Exemples: `(MONTHDAYS 2 2004)' donne 29, `(MONTHDAYS 2 NIL)' donne 28.
YEARDAYS
donne le nombre de jours d'une année.
|
Exemples: `(YEARDAYS 2004)' donne 366, `(YEARDAYS 2005)' donne 365.
ADDMONTH
ajoute un certain nombre de mois à une date.
|
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.
ADDYEAR
ajoute un certain nombre d'années à une date.
|
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.
TODAY
renvoie la date du jour.
|
NOW
renvoie l'heure courante.
|
Voir aussi TODAY.
Cette section énumère les fonctions pour le traitement des listes.
15.15.1 CONS Constructeur élémentaire de liste. 15.15.2 LIST Produire une liste d'éléments. 15.15.3 LENGTH Obtenir le nombre d'éléments d'une liste. 15.15.4 FIRST Extraire le premier élément d'une liste. 15.15.5 REST Obtenir le reste d'une liste. 15.15.6 LAST Extraire le dernier élément d'une liste. 15.15.7 NTH Extraire le N ième élément d'une liste. 15.15.8 APPEND Enchaîner les listes. 15.15.9 REVERSE Renverser une liste. 15.15.10 MAPFIRST Application d'une fonction à tous les éléments d'une liste. 15.15.11 SORTLIST Trier les éléments d'une liste. 15.15.12 SORTLISTGT Trier les éléments d'une liste.
CONS
établit une paire d'expressions.
|
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.
LIST
produit une liste en dehors de ses arguments.
|
(CONS
elem (CONS
... NIL))
.
Notez que NIL reste seul pour une liste vide.
LENGTH
détermine la longueur d'une liste.
|
Exemple: `(LENGTH (LIST "a" 2 42 3))' donne 4.
Voir aussi LIST.
FIRST
extrait le premier élément dans une liste.
|
Voir aussi REST, LAST, NTH, CONS.
REST
renvoie la sous-liste après le premier élément d'une liste.
|
Exemple: `(REST (LIST 1 2 3))' donne ( 2 3 ).
LAST
extrait le dernier élément dans une liste.
|
NTH
extrait le N ième élément d'une liste.
|
APPEND
enchaîner les listes.
|
Exemple: `(APPEND (list 1 2) (list 3 4) (list 5))' donne ( 1 2 3 4 5 ).
Voir aussi LIST.
REVERSE
renverse une liste.
|
Exemple: `(REVERSE (list 1 2 3))' donne ( 3 2 1 ).
MAPFIRST
applique une fonction à tous les éléments de la liste.
|
Expression Value (MAPFIRST 1+ (LIST 1 2 3)) ( 2 3 4 ) (MAPFIRST + (LIST 1 2 3) (LIST 2 3)) ( 3 5 NIL ) |
SORTLIST
Trie les éléments d'une liste.
|
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) ) ) |
(SORTLIST cmp_str (LIST "salut" "excellent" "grand" "ok")) |
Voir aussi SORTLISTGT, MAPFIRST.
SORTLIST
tri les éléments de la liste
|
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.
Pour demander des informations à l'utilisateur, les fonctions suivantes peuvent être utilisées :
15.16.1 ASKFILE Invite l'utilisateur à fournir un nom de fichier 15.16.2 ASKDIR Invite l'utilisateur à fournir un nom de tiroir. 15.16.3 ASKSTR Invite l'utilisateur à fournir une chaîne texte. 15.16.4 ASKINT Invite l'utilisateur à fournir un nombre entier. 15.16.5 ASKCHOICE Invite l'utilisateur à fournir un article parmis beaucoup d'articles. 15.16.6 ASKCHOICESTR Invite l'utilisateur à fournir une chaîne texte, parmis celle qui sont prédéfinies. 15.16.7 ASKOPTIONS Invite l'utilisateur à fournir quelques articles parmis beaucoup d'articles. 15.16.8 ASKBUTTON Invite l'utilisateur à appuyer sur un bouton. 15.16.9 ASKMULTI Invite l'utilisateur à fournir plusieurs informations.
ASKFILE
demande à l'utilisateur d'écrire 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.
ASKDIR
demande à l'utilisateur d'écrire le nom d'un tiroir.
|
ASKFILE
(voir ASKFILE).
ASKDIR
renvoie le nom du tiroir écrit dans une chaîne texte
ou NIL dans le cas où l'utilisateur aurait annulé le sélecteur de fichier.
ASKSTR
demande à l'utilisateur d'écrire une chaîne texte.
|
ASKSTR
renvoie la chaîne texte entrée ou NIL au cas où l'utilisateur l'annulerait.
Voir aussi ASKFILE, ASKDIR, ASKCHOICESTR, ASKINT.
ASKINT
incite l'utilisateur à écrire un nombre entier.
|
ASKINT
renvoie le nombre entier saisie ou NIL si l'utilisateur annule la requête.
Voir aussi ASKSTR.
ASKCHOICE
Invite l'utilisateur à choisir un élément parmi d'autres.
|
"\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.
(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)) ) ) ) |
(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) ) |
ASKCHOICESTR
Invite l'utilisateur à entrer la valeur d'une chaîne texte parmi celles qui ont été prédéfinies.
|
"\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.
(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)) ) |
ASKOPTIONS
Invite l'utilisateur à sélectionner plusieurs éléments dans une liste.
|
"\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.
(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))) ) ) ) ) |
ASKBUTTON
invite l'utilisateur à appuyer sur un bouton.
|
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'.
(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) |
ASKMULTI
incite l'utilisateur à écrire divers genres d'informations.
|
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 :
|
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é.
(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") )) ) |
Cette section liste les fonctions et les variables d'entrées/sortie (par exemple l'impression) des données.
15.17.1 FOPEN Ouverture d'un fichier pour la lecture/écriture. 15.17.2 FCLOSE Fermeture d'un fichier. 15.17.3 stdout Descripteur de fichier de la sortie standard. 15.17.4 PRINT Imprimer une expression vers la sortie standard. 15.17.5 PRINTF Formatter l'impression vers la sortie standard. 15.17.6 FPRINTF Formatter l'impression vers un fichier. 15.17.7 FERROR Vérification des erreurs d'un fichier. 15.17.8 FEOF Détection de la fin d'un fichier. 15.17.9 FSEEK Réglage de la position dans un fichier. 15.17.10 FTELL Obtenir la position actuelle dans un fichier. 15.17.11 FGETCHAR Lecture du prochain caractère entrée à partir d'un fichier. 15.17.12 FGETCHARS Lecture de plusieurs caractères d'entrée à partir d'un fichier. 15.17.13 FGETSTR Lecture d'une chaîne texte à partir d'un fichier. 15.17.14 FGETMEMO Lecture d'un mémo à partir d'un fichier. 15.17.15 FPUTCHAR Ecrire un caractère dans un fichier. 15.17.16 FPUTSTR Ecrire une chaîne dans un fichier. 15.17.17 FPUTMEMO Ecrire un mémo dans un fichier. 15.17.18 FFLUSH Flushing un fichier.
FOPEN
ouvre un fichier en lecture/écriture.
|
Le paramètre optionnel encodage contrôle l'encodage du fichier et peut prendre l'une des chaînes suivantes pour valeur :
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.
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é.
`(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.
FCLOSE
ferme un fichier.
|
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.
PRINT
converti une expression en chaîne et l'affiche.
|
stdout
. Cette fonction existe principalement pour le débogage (la mise au
point).
PRINTF
imprime une chaîne formater.
|
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.
FPRINTF
imprime une chaîne texte formatée dans un fichier.
|
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é.
FERROR
vérifie si un fichier produit une erreur d'entrée/sortie.
|
Voir aussi FEOF, FOPEN, FCLOSE.
FEOF
vérifie l'état de fin de fichier.
|
Voir aussi FERROR, FTELL, FOPEN, FCLOSE.
FSEEK
place la position de lecture/écriture d'un 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.
FTELL
renvoie la position de lecture/écriture d'un fichier.
|
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.
FGETCHAR
lit un caractère à partir d'un fichier.
|
Voir aussi FGETCHARS, FGETSTR, FPUTCHAR.
FGETCHARS
lit des caractères à partir d'un fichier.
|
FGETSTR
lit une chaîne texte à partir d'un fichier.
|
Voir également FGETCHAR, FGETCHARS, FGETMEMO, FPUTSTR.
FGETMEMO
lit un mémo à partir d'un fichier.
|
FPUTCHAR
écrit un caractère dans un fichier.
|
FPUTSTR
écrit une chaîne texte dans un fichier.
|
Voir aussi FPUTCHAR, FPUTMEMO, FGETSTR.
FPUTMEMO
écrit un mémo dans un fichier.
|
FFLUSH
purge les données en attente vers un fichier.
|
Cette section énumère les fonctions qui traitent des enregistrements.
15.18.1 NEW Alloue un nouvel enregistrement. 15.18.2 NEW* Alloue un nouvel enregistrement en appelant le déclencheur. 15.18.3 DELETE Supprime un enregistrement. 15.18.4 DELETE* Supprime un enregistrement en appelant le déclencheur. 15.18.5 DELETEALL Supprime tous les enregistrements d'une table. 15.18.6 GETMATCHFILTER Getting the match-filter state of a record. 15.18.7 SETMATCHFILTER Setting the match-filter state of a record. 15.18.8 GETISSORTED Vérifie si un enregistrement est dans le bon ordre. 15.18.9 SETISSORTED Telling a record its order state. 15.18.10 RECNUM Donne le nombre d'enregistrements of a record. 15.18.11 COPYREC Copie le contenu d'un enregistrement.
NEW
alloue un nouvel enregistrement pour une table.
|
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.
NEW*
est une version améliorée de NEW
(voir NEW).
|
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.
DELETE
supprime les enregistrements dans une table.
|
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é.
A 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.
DELETE*
est une version améliorée de DELETE
(voir DELETE).
|
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 requester 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*.
DELETEALL
supprime tous les enregistrements d'une table.
|
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.
GETMATCHFILTER
renvoie l'état du filtre d'enregistrement.
|
Voir aussi SETMATCHFILTER, GETISSORTED, GETFILTERSTR, SETFILTERSTR.
SETMATCHFILTER
place l'état du filtre d'un enregistrement.
|
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.
GETISSORTED
renvoie l'état du type d'enregistrement.
|
Voir aussi SETISSORTED, GETMATCHFILTER, REORDER, GETORDERSTR, SETORDERSTR, Comparison function.
SETISSORTED
modifie l'indicateur de tri de l'enregistrement.
|
REORDER
(voir voir REORDER).
SETISSORTED
renvoie la novelle 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.
RECNUM
renvoie le numéro d'enregistrement d'un enregistrement.
|
COPYREC
copie les enregistrements.
|
COPYREC
renvoie rec.
Voir aussi NEW.
Cette section énumère les fonctions qui travaillent sur les champs d'une table.
15.19.1 ATTRNAME Obtenir le nom d'un champ. 15.19.2 MAXLEN Nombre maximum de caractères pour le champ d'une chaîne. 15.19.3 GETLABELS Obtenir le label des choix ou le champ d'une chaîne texte. 15.19.4 SETLABELS Réglage des étiquettes de la liste d'affichage pour le champ d'une chaîne.
ATTRNAME
renvoie le nom d'un champ.
|
Voir aussi TABLENAME
MAXLEN
renvoie la taille maximum du champ d'une chaîne.
|
Voir aussi LEN.
GETLABELS
renvoie toutes les étiquettes d'un choix ou d'une chaîne.
|
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.
SETLABELS
est utilisé pour placer les étiquettes d'un champ dans une chaîne.
|
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.
15.20.1 TABLENAME Obtenir le nom d'une table. 15.20.2 GETORDERSTR Obtenir le tri d'un enregistrement. 15.20.3 SETORDERSTR Réglage du tri de l'enregistrement. 15.20.4 REORDER Réordonner les enregistrements non triés. 15.20.5 REORDERALL Réordonner tous les enregistrements d'une table. 15.20.6 GETFILTERACTIVE Obtenir l'état du filtre d'enregistrement. 15.20.7 SETFILTERACTIVE Réglage de l'état du filtre d'enregistrement. 15.20.8 GETFILTERSTR Obtenir l'expression du filtre d'enregistrement. 15.20.9 SETFILTERSTR Réglage de l'expression du filtre d'enregistrement. 15.20.10 RECORDS Nombre d'enregistrements. 15.20.11 RECORD Obtenir le pointeur d'enregistrement. 15.20.12 SELECT Requêtes "Select-from-where".
TABLENAME
renvoie le nom d'une table.
|
Voir aussi ATTRNAME
GETORDERSTR
renvoie un enregistrement trié dans une table.
|
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.
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.
SETORDERSTR
place un enregistrement trié dans une table.
|
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.
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.
REORDER
réordonne tous les enregistrements non triés dans le bon ordre.
|
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.
REORDERALL
réordonne tous les enregistrements d'une table.
|
REORDER
pour tout réordonner.
REORDERALL
renvoie NIL.
Voir aussi REORDER, GETORDERSTR, SETORDERSTR, GETISSORTED, SETISSORTED, Order, Fonction de comparaison.
GETFILTERACTIVE
renvoie l'état du filtre de la table.
|
Voir aussi SETFILTERACTIVE, GETFILTERSTR, GETMATCHFILTER.
SETFILTERACTIVE
Place l'état du filtre de la table.
|
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.
GETFILTERSTR
renvoie l'expression de l'enregistrement dans le filtre d'une table.
|
Voir aussi SETFILTERSTR, GETFILTERACTIVE, GETMATCHFILTER.
SETFILTERSTR
place l'expression de l'enregistrement dans le filtre d'une table.
|
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)) ) |
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.
RECORDS
renvoie le nombre d'enregistrements dans une table.
|
RECORD
renvoie l'indicateur d'enregistrement pour le nombre de données enregistrées.
|
Veuillez noter que les nombres d'enregistrements commencent par 1 et que le numéro d'enregistrement 0 est utilisé pour l'enregistrement initial.
SELECT
extrait et renvoie diverses données à partir des enregistrements.
|
exprlist: |
tablelist: table[ |
orderlist a la syntaxe suivante :
orderlist: expr [ |
ASC
ou DESC
pour un tri croissant ou décroissant.
Si aucun d'eux n'est présent, le tri croissant est assumé.
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.
Voir les Voir exemples de questions, pour quelques exemples utilisant la fonction SELECT
.
Voir aussi FOR ALL.
Cette section décrit les fonctions pour manipuler les éléments d'une interface graphique.
15.21.1 SETCURSOR Placement du curseur sur un élément graphique. 15.21.2 GETWINDOWOPEN Obtenir l'état d'une fenêtre ouverte/fermée. 15.21.3 SETWINDOWOPEN Ouvrir/fermer une fenêtre. 15.21.4 GETVIRTUALLISTACTIVE Obtenir la ligne active d'un champ virtuel. 15.21.5 SETVIRTUALLISTACTIVE Changer la ligne active d'un champ virtuel.
SETCURSOR
place le curseur sur un élément graphique.
|
SETCURSOR
renvoie TRUE si tout va bien
(la fenêtre a pu être ouverte) ou NIL en cas d'échec.
Voir aussi SETVIRTUALLISTACTIVE.
GETWINDOWOPEN
renvoie l'état d'ouverture d'une fenêtre.
|
Voir aussi SETWINDOWOPEN.
SETWINDOWOPEN
ouvre ou ferme une fenêtre.
|
SETWINDOWOPEN
renvoie le nouvel état d'ouverture de la fenêtre.
Voir aussi GETWINDOWOPEN.
GETVIRTUALLISTACTIVE
renvoie l'index de la ligne active d'un champ virtuel
utilisant une `Liste' son affichage.
|
Voir aussi SETVIRTUALLISTACTIVE.
SETVIRTUALLISTACTIVE
Modifie la ligne active d'un
champ virtuel utilisant une `Liste' pour son affichage.
|
SETVIRTUALLISTACTIVE
ne place pas le curseur sur l'élément graphique
du champ, utilisez pour cela SETCURSOR
(voir voir SETCURSOR).
Voir aussi GETVIRTUALLISTACTIVE, SETCURSOR.
Cette section énumère les fonctions traitant des projets.
15.22.1 PROJECTNAME Obtenir le nom de projet. 15.22.2 CHANGES Obtenir le nombre de changements fait sur le projet en cours. 15.22.3 GETADMINMODE Vérifier si l'on est en mode administrateur ou utilisateur. 15.22.4 SETADMINMODE Basculer vers le mode administrateur ou utilisateur. 15.22.5 ADMINPASSWORD hachage SHA1 du mot de passe administrateur.
PROJECTNAME
renvoie le nom de projet.
|
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.
CHANGES
renvoie le nombre de changements du projet en cours.
|
Voir aussi PROJECTNAME.
GETADMINMODE
tells whether the current project is in admin mode
GETADMINMODE
indique si le projet courant est en mode administrateur
ou utilisateur.
|
SETADMINMODE
bascule le projet courant vers le mode aministrateur ou
utilisateur.
|
ADMINPASSWORD
obtient le mot de passe administrateur sous forme de chaîne de hachage SHA1.
|
Cette section énumère les fonctions faisant appel au système d'exploitation.
15.23.1 EDIT Lancer l'éditeur externe de façon synchronisé. 15.23.2 EDIT* Lancer l'éditeur externe de façon asynchrone. 15.23.3 VIEW Lancer la visionneuse externe de façon synchronisé. 15.23.4 VIEW* Lancer la visionneuse externe de façon asynchrone. 15.23.5 SYSTEM Appeler les commandes externes de façon synchronisé. 15.23.6 SYSTEM* Appeler les commandes externes de façon asynchrone. 15.23.7 STAT Examiner un fichier. 15.23.8 TACKON Créer un chemin d'accès à partir de ses composants. 15.23.10 DIRNAME Obtenir le nom d'un tiroir à partir de son chemin d'accès. 15.23.9 FILENAME Obtenir le dernier composant d'un chemin d'accès. 15.23.11 MESSAGE Afficher des messages à l'utilisateur. 15.23.12 COMPLETEMAX Régler le nombre maximum d'étapes de progression. 15.23.13 COMPLETEADD Incrémenter l'état de progression. 15.23.14 COMPLETE Postionner l'état de progression de manière absolue. 15.23.15 GC Forcer le passage du « ramasse-miettes ». 15.23.16 PUBSCREEN Nom de l'écran publique (Amiga).
EDIT
Lancement d'un é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.
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*.
VIEW
lance la 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.
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*.
SYSTEM
appelle un programme externe.
|
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.
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*.
STAT
examine un nom de fichier.
|
STAT
renvoie NIL si le fichier ne peut pas être trouvé,
0 si le fichier existe et est un tiroir, et un nombre entier
supérieur à 0 si le fichier existe et est un fichier normal.
TACKON
crée le 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".
FILENAME
extrait le nom de fichier à partir du chemin d'accès.
|
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".
DIRNAME
extrait une partie correspondant au répertoire depuis un chemin d'accès.
|
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".
MESSAGE
affiche un message à l'utilisateur.
|
SPRINTF
(voir SPRINTF).
MESSAGE
renvoie le champ titre formaté.
Exemple: `(MESSAGE "6 * 7 = %i" (* 6 7))'.
COMPLETEMAX
spécifie le nombre maximum d'étapes de progression.
|
COMPLETEMAX
renvoie son argument steps.
Voir aussi COMPLETEADD, COMPLETE.
COMPLETEADD
incrémente l'état de progression.
|
COMPLETEADD
renvoie son argument add.
(SETQ num ...) (COMPLETEMAX num) (DOTIMES (i num) (COMPLETEADD 1) ) |
COMPLETE
modifie l'état de progression.
|
COMPLETE
renvoie son argument cur.
(COMPLETE 10) ... (COMPLETE 50) ... (COMPLETE 100) |
GC
force le passage du « ramasse-miettes ».
|
PUBSCREEN
retourne le nom de l'écran publique.
|
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.
MUIbase connaît quelques variables globales prédéfinies.
Dans la version en cours il existe seulement une variable globale : stdout
(voir stdout).
Les constantes prédéfinies suivantes peuvent être employées dans toute expression pour la programmation.
Nom Type Valeur Commentaire ------------------------------------------------------------------------- |
#define
(voir #define).
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).
(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 ) ) |
`(map (LIST 1 2 3 4) 1+)' donne ( 2 3 4 5 ).
Voir aussi FUNCALL, APPLY, MAPFIRST.
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 |
(LET (x:INT (y:REAL 0.0) z) ...) |
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) ...) |
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) |
(SETQ foo (RECORD Foo 3)) (PRINT foo.Bar) |
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.
Renvoie le pointeur d'enregistrement du programme pour la table.
Renvoie le pointeur d'enregistrement de l'interface pour la table de données.
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'.
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).
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.
15.29.1 onOpen Déclenchement après ouverture d'un projet. 15.29.2 onClose Déclenchement à la fermeture d'un projet. 15.29.3 onAdminMode Déclenchement à l'entrée/sortie du mode administrateur. 15.29.4 onChange Déclenchement au changement de projet. 15.29.5 Déclencheur de création Déclencheur pour allouer un nouvel enregistrement. 15.29.6 Déclencheur de suppression Déclencheur pour supprimer un enregistrement. 15.29.7 Fonction de comparaison Pour comparer les enregistrements d'une table. 15.29.8 Déclencheur de champ Déclenchement au changement de champs. 15.29.9 Champs virtuels Comment écrire des fonctions pour les champs virtuels. 15.29.10 Fonction de calcul d'activation Pour déterminer l'état d'activation d'un object. 15.29.11 Déclencheur de double-clic Déclencheur pour les double-clics dans une liste virtuelle. 15.29.12 Calculer les étiquettes des listes Déclencheur pour calculer les étiquettes des listes. 15.29.13 Calculer les enregistrements référencés Déclenchement lors de l'activation d'une liste déroulante de références.  
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.
(DEFUN onOpen () (ASKBUTTON NIL "Merci de m'ouvrir !" NIL NIL) ) |
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.
(DEFUN onClose () (ASKBUTTON NIL "Au revoir !" NIL NIL) ) |
À 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).
(DEFUN onAdminMode (admin) (IF admin (ASKBUTTON NIL "Maintenant en mode administrateur" NIL NIL) (ASKBUTTON NIL "Revenu en mode utilisateur" NIL NIL) ) ) |
A 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.
(DEFUN onChange () (SETQ Control.NumChanges (CHANGES)) ) |
Voir aussi onOpen, onClose, onAdminMode, la démo `Trigger.mb'.
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*).
(DEFUN nouvelEnregistrement (init) (PROG1 ; pour renvoyer le résultat de NEW (NEW Table init) ... ) ) |
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*).
(DEFUN supprimerEnregistrement (confirmation) (DELETE Table confirmation) ) |
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) ) |
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 `Proprietaire' vers `Personnes' et la fonction suivante pour comparer les enregistrements :
(DEFUN cmpJouets (rec1:Jouets rec2:Jouets) (CMP* rec1.Proprietaire rec2.Propriétaire) ) |
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) ) |
Voir aussi Order, CMP, GETISSORTED, SETISSORTED, REORDER, REORDERALL, GETORDERSTR, SETORDERSTR, la démo `Order.mb'.
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.
(DEFUN setMontant (montant) (IF une-expression (SETQ Table.Montant montant) (ASKBUTTON NIL "Valeur Invalide !" NIL NIL) ) Table.Montant ; retourne la valeur courante ) |
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 ) |
SETQ
:
(SETQ champ-virtuel expr) |
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'.
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émet sélectionné ressemblerait à :
(DEFUN activeObjet () (GETVIRTUALLISTACTIVE champ-liste-virtuel) ) |
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) ... ) |
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) ...) ... ) ) |
(DEFUN declencheurDoubleClic (lig col) (PRINT (NTH col (NTH lig attr-virtuel))) ) |
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" ) |
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) ) |
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).
[ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |