Obligement - L'Amiga au maximum

Vendredi 19 avril 2024 - 00:35  

Translate

En De Nl Nl
Es Pt It Nl


Rubriques

Actualité (récente)
Actualité (archive)
Comparatifs
Dossiers
Entrevues
Matériel (tests)
Matériel (bidouilles)
Points de vue
En pratique
Programmation
Reportages
Quizz
Tests de jeux
Tests de logiciels
Tests de compilations
Trucs et astuces
Articles divers

Articles in english


Réseaux sociaux

Suivez-nous sur X




Liste des jeux Amiga

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z,
ALL


Trucs et astuces

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z


Glossaire

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z


Galeries

Menu des galeries

BD d'Amiga Spécial
Caricatures Dudai
Caricatures Jet d'ail
Diagrammes de Jay Miner
Images insolites
Fin de jeux (de A à E)
Fin de Jeux (de F à O)
Fin de jeux (de P à Z)
Galerie de Mike Dafunk
Logos d'Obligement
Pubs pour matériels
Systèmes d'exploitation
Trombinoscope Alchimie 7
Vidéos


Téléchargement

Documents
Jeux
Logiciels
Magazines
Divers


Liens

Associations
Jeux
Logiciels
Matériel
Magazines et médias
Pages personnelles
Réparateurs
Revendeurs
Scène démo
Sites de téléchargement
Divers


Partenaires

Annuaire Amiga

Amedia Computer

Relec


A Propos

A propos d'Obligement

A Propos


Contact

David Brunet

Courriel

 


En pratique : Programmation de MUIbase
(Article écrit par Steffen Gutmann et extrait de muibase.sourceforge.net - mars 2006)


Cet article décrit le langage de programmation de MUIbase, ainsi que toutes les fonctions disponibles. En revanche, cet article 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 :-)).

Sommaire

1. Éditeur de programme - Où saisir un programme MUIbase.
2. Code source externe - Utiliser son éditeur favori pour programmer.
3. Préprocesseur - Inclusions, compilation conditionnelle et constantes.
4. Langage de programmation - La syntaxe des expressions.

Fonctions

5. Commandes de définition - Définitions de fonction et de variable.
6. Structures de contrôle - Boucles, expressions conditionnelles et cetera.
7. Prédicats de typage - Examiner le type d'une expression.
8. Fonctions de conversion de type - Conversion de type.
9. Fonctions booléennes - AND, OR, et NOT.
10. Fonctions de comparaison - Comparer les valeurs des expressions.
11. Fonctions mathématiques - Ajouter, Multiplier, etc.
12. Fonctions sur les chaînes - Choses utiles sur les chaînes de caractères.
13. Fonctions sur les mémo - Choses utiles sur les mémos.
14. Fonctions sur la date et l'heure - Choses utiles sur les dates et les heures.
15. Fonctions sur les listes - Commandes de traitement de liste.
16. Fonctions de demande de saisie - Demander une saisie à l'utilisateur.
17. Fonctions d'E/S - Commandes de lecture/écriture de fichier.
18. Fonctions sur les enregistrements - Choses utiles sur les enregistrements.
19. Fonctions sur les champs - Manipuler les champs.
20. Fonctions sur les tables - Manipuler les tables.
21. Fonctions d'Interface - Manipuler l'interface graphique.
22. Fonctions sur les projets - Récupérer des informations à propos du projet.
23. Fonctions système - Fonctions en relation avec le système d'exploitation.
24. Variables - Variables prédéfinies.
25. Constantes - Constantes prédéfinies.

Informations utiles

26. Paramètres fonctionnels - Utiliser des fonctions comme argument dans des appels de fonction.
27. Spécificateurs de type - Types pour les variables.
28. Sémantique des expressions - La signification d'une expression.
29. Déclenchement de fonction - Comment déclencher des fonctions.
30. Liste des fonctions obsolètes - Les fonctions ayant disparu et devant être remplacées.

x. Index des fonctions - Index de toutes les fonctions.

1. Éditeur de programme

Pour saisir un programme dans un projet, ouvrez l'éditeur de programme en sélectionnant le menu "Programme - Éditer". Si vous êtes configuré en code source en interne, cela ouvre la fenêtre "Edition de programme" qui contient :
  • Un champ éditeur de texte où vous éditez le programme du projet.
  • Un bouton "Compiler & fermer" pour compiler le programme et, en cas de réussite, sortir de l'éditeur de programme.
  • Un bouton "Compiler" pour compiler le programme. Si votre programme contient une erreur quelque part, alors une description de l'erreur est affichée dans le titre de la fenêtre et le curseur est positionné sur l'emplacement fautif.
  • Un bouton "Rétablir" qui annule tous les changements effectués depuis la dernière compilation réussie.
L'éditeur de programme est une fenêtre non modale, vous pouvez laisser la fenêtre ouverte et continuer à travailler avec le reste de l'application. Vous pouvez fermer l'éditeur à tout moment en cliquant sur le bouton de fermeture de sa fenêtre, si vous avez fait des changements depuis la dernière compilation réussie, alors une requête de sécurité vous demandera de confirmer la fermeture de la fenêtre.

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

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.

2. Code source externe

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

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

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

Sur Amiga, il est possible d'envoyer la commande "compile" au port ARexx de MUIbase depuis votre éditeur. MUIbase lit alors le fichier source externe, le compile et retourne le statut de la compilation ainsi qu'un éventuel message d'erreur contenant le nom du fichier, la ligne, la colonne et une description de l'erreur. Cela permet de positionner le curseur à l'emplacement exact où l'erreur de compilation s'est produite.

3. Préprocesseur

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

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

3.1 #define - Définir des constantes.
3.2 #undef - Supprimer la définition de constantes.
3.3 #include - Inclure des fichiers externes.
3.4 #if - Compilation conditionnelle.
3.5 #ifdef - Compilation conditionnelle.
3.6 #ifndef - Compilation conditionnelle.
3.7 #elif - Compilation conditionnelle.
3.8 #else - Compilation conditionnelle.
3.9 #endif - Compilation conditionnelle.

3.1 #define

#define nom chaîne

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

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

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

#define BEGIN (
#define END )

BEGIN defun test ()
        ...
END

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

Voir aussi #undef, #ifdef, #ifndef.

3.2 #undef

#undef nom

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

Voir aussi #define, #ifdef, #ifndef.

3.3 #include

#include fichier

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

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

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

3.4 #if

#if expr-const

Si le résultat de l'expression constante spécifiée est différent de NIL, alors le texte présent jusqu'à la directive #else, #elif ou #endif correspondante est utilisé pour la compilation, sinon (c'est-à-dire 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.

3.5 #ifdef

#ifdef nom

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

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

3.6 #ifndef

#ifndef nom

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

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

3.7 #elif

#elif expr-const

N'importe quel nombre de directives #elif peut apparaître entre une directive #if, #ifdef ou #ifndef et sa directive #else ou #endif correspondante. Les lignes suivant la directive #elif sont prises en compte dans la compilation seulement si toutes les conditions suivantes sont remplies :
  • L'expression constante dans la directive #if précédente a été évaluée à NIL, le symbole de la directive #ifdef précédente n'était pas défini ou le symbole de la directive #ifndef précédente était défini.
  • L'expression constante de chacune des directives #elif intermédiaires a été évaluée à NIL.
  • L'expression constante a été évaluée comme différente de NIL.
Si toutes les conditions précédentes sont remplies, alors les directives #elif et #else suivantes sont ignorées jusqu'au #endif correspondant.

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

3.8 #else

#else

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

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

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

3.9 #endif

#endif

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

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

4. Langage de programmation

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

4.1 Pourquoi Lisp ?

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

Les langages de programmation impératifs (par exemple 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 (par exemple variables) et un programme calcule ses sorties en passant d'un état à un autre (par exemple 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.

4.2 Syntaxe Lisp

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

(+ a b)

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

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

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

4.3 Types de programmes

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

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.

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, par exemple 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.

4.4 Nomenclature

Dans un programme MUIbase, il est possible de définir des symboles tels que des fonctions et des variables globales ou locales. Les noms de ces symboles doivent suivrent les conventions suivantes :
  • Le premier caractère d'un nom doit être une lettre minuscule, cela différencie les symboles de programme des noms de table et de champs.
  • Les caractères suivants peuvent être n'importe quelle lettre, chiffre ou caractère de soulignement. Les autres caractères, comme les umlauts allemands ne sont pas autorisés.
4.5 Accéder aux enregistrements

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

Les chemins peuvent être soit relatifs, soit absolus. Les chemins absolus sont reconnaissables par le fait que leur premier composant est un nom de table, suivi par une liste de champs se terminant par le champ à atteindre. Par exemple le chemin absolu "Personne.Nom" accède au champ "Nom" de l'enregistrement courant de la table "Personne", de même le chemin absolu "Personne.Pere.Nom" accède à 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, par exemple 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".

4.6 Types de données pour programmer

Le langage de programmation de MUIbase connaît les types de données suivants :
  • Bool : toutes les expressions, les expressions différentes de NIL sont considérées comme TRUE.
  • Integer : entier long sur 32 bits, les valeurs de choix sont converties automatiquement en entiers.
  • Real : double sur 64 bits.
  • String : chaîne de caractères de longueur arbitraire.
  • Memo : comme une chaîne, mais répartie sur plusieurs lignes.
  • Date : valeur de date.
  • Time : valeur horaire.
  • Record : pointeur sur un enregistrement.
  • File : descripteur de fichier pour la lecture/écriture.
  • List : liste d'éléments, NIL est la liste vide.
Tous les types de données supportent la valeur NIL.

4.7 Constantes

Le langage de programmation de MUIbase gère les expressions constantes qui peuvent être saisies en fonction de son type :
  • Integer : les constantes entières dans l'intervalle -2147483648 2147483647 peuvent être indiquées telles quelles. Les valeurs débutant par 0 sont interprétées comme des nombres octaux, tandis que celles débutant par 0x comme des nombres hexadécimaux.
  • Real : les constantes réelles dans l'intervalle -3.59e308 3.59e308 peuvent être spécifiée comme habituellement, au format scientifique ou non. En l'absence de point décimal, le nombre peut être traité comme un entier au lieu d'un réel.
  • String : les chaînes constantes sont toute suite de caractères encadrée par des guillemets, p. ex. "chaîne exemple". Entre les guillemets, tout caractère peut apparaître hormis les caractères de contrôle et les retours à la ligne. Cependant des codes d'échappement spéciaux permettent de saisir ces caractères :
    • \n : retour à la ligne (nl).
    • \t : tabulation horizontale (ht).
    • \v : tabulation verticale (vt).
    • \b : retour arrière (bs).
    • \r : retour chariot (cr).
    • \f : saut de page (ff).
    • \\ : un caractère backslash.
    • \" : guillemet.
    • \e : code échappement 033.
    • \nnn : caractère ayant le code octal nnn.
    • \xnn : caractère ayant le code hexa nn.
  • Memo : comme pour les chaînes (String).
  • Date : les valeurs constantes de date peuvent être spécifiées dans l'un des formats "JJ.MM.AAAA", "MM/JJ/AAAA" ou "AAAA-MM-JJ", où "JJ", "MM" et "AAAA" sont des valeurs de deux ou quatre chiffres représentant respectivement le jour, le mois et l'année de la date.
  • Time : les valeurs constantes horaires peuvent être spécifiées au format "HH:MM:SS", où "HH" représente les heures, "MM" les minutes et `SS' les secondes.
Pour quelques autres valeurs constantes prédéfinies, voir chapitre "Constantes prédéfinies".

4.8 Typographie utilisée

Le reste de ce chapitre est consacré à la description de toutes les commandes et fonctions disponibles pour programmer dans MUIbase. La syntaxe suivante est utilisée pour la description des commandes :
  • Le texte entre crochets "[]" est optionnel. Si vous omettez le texte entre crochet, une valeur par défaut est utilisée.
  • Du texte séparé par une barre verticale "|" indique plusieurs options, par exemple "a | b" signifie que vous pouvez spécifier soit "a" soit "b".
  • Le texte écrit dans une police telle que var indique un paramètre qui est remplacé par une autre expression.
  • Les points de suspension "..." indiquent que d'autres expressions peuvent suivre.
  • Tout autre texte est obligatoire.
5. Commandes de définition

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

5.1 DEFUN - Définition de fonction.
5.2 DEFUN* - Définition de fonction avec nom masqué.
5.3 DEFVAR - Définition de variable globale.
5.4 DEFVAR* - Variable globale mémorisant sa valeur.

5.1 DEFUN

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

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

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

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

liste-var: var1 ...

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

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

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

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

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

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

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

Voir aussi DEFUN*, DEFVAR.

5.2 DEFUN*

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

Cette commande est uniquement disponible dans les programmes de projet.

Voir aussi DEFUN, DEFVAR.

5.3 DEFVAR

(DEFVAR var [expr])

Définit une variable globale ayant comme valeur initiale "expr" ou "NIL" si "expr" est absent. Les noms des variables doivent commencer par une lettre minuscule suivie de lettres, chiffres ou caractères souligné (voir 4.4 Nomenclature). Il est également possible d'ajouter un spécificateur de type au nom de la variable (voir 27. 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 5.4 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 14. Variables prédéfinies).

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

5.4 DEFVAR*

(DEFVAR* var [expr])

DEFVAR* a le même effet que la commande DEFVAR (voir 5.3 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.

6. Structures de contrôle

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

6.1 PROGN - Compound statement, returns last expression.
6.2 PROG1 - Compound statement, returns first expression.
6.3 LET - Définit les variables locales.
6.4 SETQ - Positionne la valeur des variables, champs et tables.
6.5 SETQ* - Positionne la valeur des variables, champs et tables.
6.6 FUNCALL - Appelle une fonction avec des arguments.
6.7 APPLY - Applique une fonction à une liste d'arguments.
6.8 IF - Si-alors-sinon : exécution conditionnelle de programme.
6.9 CASE - Selon-cas : exécution conditionnelle de programme.
6.10 COND - Puissante instruction d'exécution conditionnelle de programme.
6.11 DOTIMES - Boucle sur un intervalle de valeurs entières.
6.12 DOLIST - Boucle sur une liste.
6.13 DO - Boucle générique.
6.14 FOR ALL - Boucle sur un ensemble d'enregistrements.
6.15 NEXT - Passe à la prochaine exécution de la boucle.
6.16 EXIT - Sort de la boucle.
6.17 RETURN - Quitte une fonction.
6.18 HALT - Arrête l'exécution du programme.
6.19 ERROR - Avorte l'exécution du programme avec un message d'erreur.

6.1 PROGN

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

([expr ...])

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

Exemple : "(1 2 3 4)" retourne 4.

Voir aussi PROG1.

6.2 PROG1

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

(PROG1 [expr ...])

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

Exemple : "(PROG1 1 2 3 4)" retourne 1.

Voir aussi PROGN.

6.3 LET

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

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

Où "liste-var" est une liste de variables locales.

liste-var : varspec ...

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

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

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

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

Par exemple, l'expression LET suivante :

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

Renvoie 1.

Voir aussi DOTIMES, DOLIST, DO, DEFVAR.

6.4 SETQ

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

(SETQ lvalue1 expr ...)

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

Affecter la valeur à une table correspond à positionner son pointeur de programme ou d'interface : "(SETQ Table expr)" positionne le pointeur d'enregistrement du programme de "Table" à la valeur "expr", "(SETQ Table* expr)" positionne son pointeur d'enregistrement de l'interface et rafraîchit l'affichage.

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.

6.5 SETQ*

SETQ* est la version étoilée de SETQ (voir 6.4 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 29.11 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, par exemple 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.

6.6 FUNCALL

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

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

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

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

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

Voir aussi APPLY.

6.7 APPLY

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

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

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

L'expression "fonc-expr" peut être n'importe quelle expression dont la valeur est une fonction utilisateur ou prédéfinie, par exemple 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 26. Paramètres fonctionnels.

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

Voir aussi FUNCALL.

6.8 IF

IF est un opérateur conditionnel.

(IF expr1 expr2 [expr3])

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

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

Voir aussi CASE, COND.

6.9 CASE

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

(CASE expr [choix ...])

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

case: (valeur [expr ...])

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

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

Exemple : "(CASE 1 ((2 3 4) 1) (1 2))" retourne 2.

Voir aussi IF, COND.

6.10 COND

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

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

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

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

Exemple :

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

Retourne "1 < 2".

Voir aussi IF, CASE.

6.11 DOTIMES

Pour des boucles simples, la commande DOTIMES est utilisable.

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

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

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

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

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

Exemple :

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

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

Voir aussi DOLIST, DO, FOR ALL, LET.

6.12 DOLIST

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

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

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

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

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

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

Exemple :

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

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

Voir aussi DOTIMES, DO, FOR ALL, LET.

6.13 DO

L'expression DO permet de programmer des boucles arbitraires.

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

Où "binding ..." sont les variables de liaison, chacune étant soit :
  • Un nouveau nom de variable (qui sera initialisé à NIL).
  • Une liste de la forme : "(nom init [pas])" où "nom" est le nom de la nouvelle variable, "init" est la valeur initiale de cette variable et "pas" est l'expression de pas (NDT : c'est-à-dire que c'est elle qui modifie la valeur de la variable d'une exécution de boucle à une autre).
De plus, "expr-terminaison" est l'expression du test d'arrêt, "expr-résultat ..." les expressions du résultat (NIL en cas d'absence) et "expr-boucle ..." correspond au corps de la boucle.

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

Exemple :

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

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

Voir aussi DOTIMES, DOLIST, FOR ALL, LET.

6.14 FOR ALL

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

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


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

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

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

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

L'expression FOR ALL renvoie NIL.

Voir aussi SELECT, DOTIMES, DOLIST, DO.

6.15 NEXT

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

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

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

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

6.16 EXIT

EXIT peut être utilisé pour terminer une boucle.

(EXIT [expr ...])

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

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

...ne sont pas exécutées.

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

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

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

6.17 RETURN

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

(RETURN [expr ...])

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

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

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

Voir aussi HALT, EXIT.

6.18 HALT

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

(HALT)

Arrête l'exécution du programme silencieusement.

Voir aussi ERROR, EXIT, RETURN.

6.19 ERROR

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

(ERROR fmt [arg ...])

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

Voir aussi HALT, SPRINTF.

7. Prédicats de typage

Pour chaque type il existe un prédicat qui retourne TRUE si l'expression fournie est du type spécifié ou NIL dans le cas contraire. Ces prédicats sont :
  • (STRP expr) : TRUE si "expr" est de type chaîne, NIL sinon.
  • (MEMOP expr) : TRUE si "expr" est de type mémo, NIL sinon.
  • (INTP expr) : TRUE si "expr" est de type entier, NIL sinon.
  • (REALP expr) : TRUE si "expr" est de type réel, NIL sinon.
  • (DATEP expr) : TRUE si "expr" est de type date, NIL sinon.
  • (TIMEP expr) : TRUE si "expr" est de type heure, NIL sinon.
  • (NULL expr) : TRUE si "expr" est NIL (une liste vide), NIL sinon.
  • (CONSP expr) : TRUE si "expr" n'est pas la liste vide, NIL sinon.
  • (LISTP expr) : TRUE si "expr" est une liste (peut être NIL), NIL sinon.
  • (RECP table expr) : TRUE si "expr" pointe sur un enregistrement de la table spécifiée. Si "expr" est NIL, TRUE est renvoyé (enregistrement initial). Si "table" est NIL, vérification si "expr" est un pointeur d'enregistrement vers l'une des tables.
8. Fonctions de conversion de type

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

8.1 STR - Convertir en chaîne.
8.2 MEMO - Convertir en mémo.
8.3 INT - Convertir en entier.
8.4 REAL - Convertir en réel.
8.5 DATE - Convertir en date.
8.6 TIME - Convertir en heure.

8.1 STR

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

(STR expr)

Convertit "expr" en une représentation chaîne. Le type de "expr" détermine la conversion :
  • 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 deux décimales sont produites.
  • Choice : le label associé au choix.
  • Date : la représentation de la date en chaîne.
  • Time : la représentation de l'heure en chaîne.
  • Bool : la chaîne "TRUE".
  • NIL : la chaîne nil définie par l'utilisateur si "expr" est un champ, la chaîne "NIL" sinon.
  • Record : la représentation du numéro d'enregistrement en chaîne.
  • Autres : la représentation de l'adresse interne du pointeur en chaîne.
Voir aussi MEMO, SPRINTF.

8.2 MEMO

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

(MEMO expr)

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

Voir aussi STR.

8.3 INT

INT est utilisé pour convertir une expression en entier.

(INT expr)

Convertit expr en valeur entière. Les conversions possibles sont :
  • 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.
  • Autres : un message d'erreur est généré et l'exécution du programme avortée.
Voir aussi REAL, ASC.

8.4 REAL

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

(REAL expr)

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

Voir aussi INT.

8.5 DATE

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

(DATE expr)

Convertit l'expression spécifiée en une valeur de type date. Les conversions possibles sont :
  • 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'est-à-dire 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.
  • Autres : un message d'erreur est généré et l'exécution du programme avortée.
Voir aussi DATEDMY.

8.6 TIME

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

(TIME expr)

Convertit l'expression spécifiée en une valeur de type date. Les conversions possibles sont :
  • 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.
  • Autres : un message d'erreur est généré et l'exécution du programme avortée.
9. Fonctions booléennes

Cette section liste les opérateurs booléens.

9.1 AND - Conjonction de valeurs booléennes.
9.2 OR - Disjonction de valeurs booléennes.
9.3 NOT - Inversion d'une valeur booléenne.

9.1 AND

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

(AND [expr ...])

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

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

Voir aussi OR, NOT.

9.2 OR

OR vérifie que tous les arguments sont NIL.

(OR [expr ...])

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

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

Voir aussi AND, NOT.

9.3 NOT

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

(NOT expr)

Renvoie TRUE si "expr" est NIL, NIL dans le cas contraire.

Voir aussi AND, OR.

10. Fonctions de comparaison

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

10.1 Opérateurs relationnels : =, <>, <, >, <=, >= et leur version étoilée.
10.2 CMP : retourne un entier représentant l'ordre.
10.3 CMP* : comparaison étendue, par exemple sensible à la casse.
10.4 MAX : expression maximum.
10.5 MAX* : expression maximum utilisant l'ordre étendu.
10.6 MIN : expression minimum.
10.7 MIN* : expression minimum utilisant l'ordre étendu.

10.1 Opérateurs relationnels

Pour comparer deux valeurs dans un programme MUIbase, il faut utiliser :

(op expr1 expr2)

Où "op" est parmi {=, <>, <, >, >=, <=, =*, <>*, <*, >*, >=*, <=*}. L'étoile est utilisée pour les comparaisons spéciales (par exemple 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.
  • Entier : NIL < MIN_INT < ... < -1 < 0 < 1 < ... < MAX_INT.
  • Réel : NIL < -HUGE_VAL < ... < -1.0 < 0.0 < 1.0 < ... < HUGE_VAL.
  • Chaîne : NIL < "" < "Z" < "a" < "aa" < "b" < ... (sensible à la casse)
    NIL <* "" <* "a" <* "AA" <* "b" < ... (insensible à la casse).
  • Mémo : identique aux chaînes.
  • Date : NIL < 1.1.0000 < ... < 31.12.9999.
  • Heure : NIL < 00:00:00 < ... < 596523:14:07.
  • Booléen : NIL < TRUE.
  • Enregistrement : NIL < un_enregistrement (les enregistrements ne sont pas comparables avec <)
    NIL <* rec1 <* rec2 (l'ordre définit par l'utilisateur).
Voir aussi CMP, CMP*, LIKE.

10.2 CMP

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

(CMP expr1 expr2)

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

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

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

Voir aussi CMP*, Opérateurs relationnels.

10.3 CMP*

CMP* est la version étoilée de CMP. La différence est que CMP* utilise un ordre étendu comme défini dans les opérateurs relationnels (voir 10.1 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.

10.4 MAX

MAX retourne l'argument ayant la plus grande valeur.

(MAX [expr ...)]

Renvoie la valeur maximale des arguments "expr ...". Si aucun argument n'est donné, alors NIL est retourné. Pour déterminer l'élément le plus large, la simple (pas d'étoile) relation d'ordre comme les opérateurs relationnels est utilisée.

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

10.5 MAX*

MAX* est la version étoilée de MAX. La différence est que MAX* utilise un ordre étendu comme défini pour les 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.

Example : "(MAX* "x" "Y")" renvoie "Y".

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

10.6 MIN

MIN retourne l'argument ayant la plus petite valeur.

(MIN [expr ...)]

Renvoie la valeur minimale des arguments "expr ...". Si aucun argument n'est donné, alors NIL est retourné. Pour déterminer l'élément le plus petit, la simple (pas d'étoile) relation d'ordre comme les opérateurs relationnels est utilisée.

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

10.7 MIN*

MIN* est la version étoilée de MIN. La différence est que MIN* utilise un ordre étendu comme défini pour les 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 : "(MIN* "x" "Y")" renvoie "x".

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

11. Fonctions mathématiques

Quelques fonctions mathématiques sont listées ici.

11.1 + - Ajouter des valeurs.
11.2 - - Soustraire des valeurs.
11.3 1+ - Incrémenter une valeur.
11.4 1- - Décrémenter une valeur.
11.5 * - Multiplication en virgule flottante.
11.6 / - Division en virgule flottante.
11.7 DIV - Division entière.
11.8 MOD - Modulo entier.
11.9 ABS - Valeur absolue d'une expression.
11.10 TRUNC - Tronquer les décimales d'une valeur réelle.
11.11 ROUND - Arrondir une valeur réelle.
11.12 RANDOM - Générateur de nombre aléatoire.
11.13 POW - Puissance d'un nombre.
11.14 SQRT - Fonction racine carrée.
11.15 EXP - Fonction exponentielle.
11.16 LOG - Logarithme d'un nombre.

11.1 Ajouter des valeurs

Pour ajouter des valeurs, utilisez :

(+ expr ...)

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

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

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

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

Exemples (expression, valeur) :

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

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

11.2 Soustraire des valeurs

Pour soustraire des valeurs, utilisez :

(- expr1 expr2 ...)

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

"(- expr)" a une signification particulière : cela retourne la valeur négative de "expr" (entier ou réel), par exemple "(- (+ 1 2))" retourne -3.

Voir aussi +, 1-.

11.3 1+

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

(1+ expr)

Renvoie la valeur de "expr" (entier ou réel) augmentée de un. Si "expr" est NIL alors le résultat est également NIL.

Voir aussi +, 1-.

11.4 1-

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

(1- expr)

Renvoie la valeur de "expr" (entier ou réel) diminuée de un. Si "expr" est NIL alors le résultat est également NIL.

Voir aussi -, 1+.

11.5 Multiplier des valeurs

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

(* expr ...)

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

Voir aussi +, /.

11.6 Diviser des valeurs

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

(/ expr1 [expr2 ...])

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

Voir aussi *, DIV, MOD.

11.7 DIV

DIV permet d'effectuer des divisions entières.

(DIV int1 int2)

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

Voir aussi /, MOD.

11.8 MOD

MOD permet de calculer le modulo.

(MOD int1 int2)

Renvoie "int1" modulo "int2". Par exemple, "(MOD 5 3)" renvoie 2.

Voir aussi DIV.

11.9 ABS

ABS calcule la valeur absolue d'une expression.

(ABS expr)

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

11.10 TRUNC

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

(TRUNC reel)

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

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

Voir aussi ROUND.

11.11 ROUND

ROUND arrondit une valeur réelle.

(ROUND reel décimales)

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

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

Voir aussi TRUNC.

11.12 RANDOM

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

(RANDOM expr)

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

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

11.13 POW

POW calcule la puissance d'une valeur.

(POW x y)

Renvoie la valeur réelle x élevée à la puissance de la valeur réelle y. Si x ou y sont NIL, ou si x est négatif et que y n'est pas un nombre entier, alors NIL est renvoyé.

Exemple : "(POW 2 3)" retourne 8.

Voir aussi SQRT, EXP.

11.14 SQRT

SQRT calcule la racine carrée d'un nombre.

(SQRT x)

Retourne la racine carrée de la valeur x. Si x est NIL ou un nombre négatif, alors NIL est retouné.

Voir aussi POW.

11.15 EXP

EXP calcul la fonction exponentielle.

(EXP x)

Renvoie la valeur de la base du logarithme naturel élevé à la puissance de la valeur réelle x. Si x est NIL, alors NIL est renvoyé.

Voir aussi POW, LOG.

11.16 LOG

LOG calcule le logarithme naturel d'un nombre.

(LOG x)

Renvoie le logarithme naturel de la valeur réelle x. Si x est NIL ou n'est pas un nombre positif, alors NIL is retourné.

Voir aussi EXP.

12. Fonctions sur les chaînes

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

12.1 LEN - Longueur de la chaîne.
12.2 LEFTSTR - Sous-chaîne gauche.
12.3 RIGHTSTR - Sous-chaîne droite.
12.4 MIDSTR - Sous-chaîne quelconque.
12.5 SETMIDSTR - Remplacement de sous-chaîne.
12.6 INSMIDSTR - Insertion de chaîne.
12.7 INDEXSTR - Première occurrence de chaîne, sensible à la casse.
12.8 INDEXSTR* - Première occurrence de chaîne, insensible à la casse.
12.9 INDEXBRK - Première occurrence de caractère, sensible à la casse.
12.10 INDEXBRK* - Première occurrence de caractère, insensible à la casse.
12.11 RINDEXSTR - Dernière occurrence de chaîne, sensible à la casse.
12.12 RINDEXSTR* - Dernière occurrence de chaîne, insensible à la casse.
12.13 RINDEXBRK - Dernière occurrence de caractère, sensible à la casse.
12.14 RINDEXBRK* - Dernière occurrence de caractère, insensible à la casse.
12.15 REPLACESTR - Remplacement de chaîne, sensible à la casse.
12.16 REPLACESTR* - Remplacement de chaîne, insensible à la casse.
12.17 REMCHARS - Suppression de caractères dans une chaîne.
12.18 TRIMSTR - Suppression de caractères de début et de fin d'une chaîne.
12.19 WORD - Extraction de mot dans une chaîne.
12.20 WORDS - Nombre de mots dans une chaîne.
12.21 FIELD - Extraction d'un champ dans une chaîne.
12.22 FIELDS - Nombre de champs dans une chaîne.
12.23 STRTOLIST - Conversion d'une chaîne en une liste de sous-chaînes.
12.24 LISTTOSTR - Conversion d'une liste d'éléments en une chaîne.
12.25 CONCAT - Concaténation de chaînes.
12.26 CONCAT2 - Concaténation de chaînes.
12.27 COPYSTR - Création de copies de chaîne.
12.28 SHA1SUM - Valeur de hachage SHA1 d'une chaîne.
12.29 UPPER - Mise en majuscules d'une chaîne.
12.30 LOWER - Mise en minuscules d'une chaîne.
12.31 ASC - Valeur Unicode/8 bits d'un caractère.
12.32 CHR - Caractère de valeur Unicode/8 bits.
12.33 LIKE - Comparaison de chaînes.
12.34 SPRINTF - Formatage de chaîne.

12.1 LEN

LEN calcule la longueur d'une chaîne.

(LEN str)

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

Voir aussi WORDS, LINES, MAXLEN.

12.2 LEFTSTR

LEFTSTR extrait une sous-chaîne de la chaîne.

(LEFTSTR str long)

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

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

Voir aussi RIGHTSTR, MIDSTR, WORD, LINE.

12.3 RIGHTSTR

RIGHTSTR extrait une sous-chaîne de la chaîne.

(RIGHTSTR str long)

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

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

Voir aussi LEFTSTR, MIDSTR, WORD, LINE.

12.4 MIDSTR

MIDSTR extrait une sous-chaîne de la chaîne.

(MIDSTR str pos long)

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

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

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

12.5 SETMIDSTR

SETMIDSTR remplace une partie de la chaîne.

(SETMIDSTR str index set)

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

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

Voir aussi INSMIDSTR, REPLACESTR.

12.6 INSMIDSTR

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

(INSMIDSTR str index insert)

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

Exemple : "(INSMIDSTR "Salut le monde !" 14 " de MUIbase")" retourne "Salut le monde de MUIbase !".

Voir aussi SETMIDSTR, REPLACESTR.

12.7 INDEXSTR

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

(INDEXSTR str substr)

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

Exemple : "(INDEXSTR "Salut monde !" "monde")" retourne 6.

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

12.8 INDEXSTR*

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

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

12.9 INDEXBRK

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

(INDEXBRK str listecar)

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

Exemple : "(INDEXBRK " Salut monde !" "aeiou")" retourne 1.

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

12.10 INDEXBRK*

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

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

12.11 RINDEXSTR

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

(RINDEXSTR str substr)

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

Exemple : "(RINDEXSTR "Doo itashimashite." "shi")" returns 11.

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

12.12 RINDEXSTR*

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

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

12.13 RINDEXBRK

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

(RINDEXBRK str listecar)

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

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

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

12.14 RINDEXBRK*

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

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

12.15 REPLACESTR

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

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

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

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

Exemple : "(REPLACESTR "noir c'est blanc" "noir" "blanc" "blanc "noir")" retourne "noir c'est noir".

Voir aussi REPLACESTR*, SETMIDSTR, INSMIDSTR, REMCHARS.

12.16 REPLACESTR*

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

Voir aussi REPLACESTR, SETMIDSTR, INSMIDSTR, REMCHARS.

12.17 REMCHARS

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

(REMCHARS str car-à-supprimer)

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

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

Voir aussi REPLACESTR, TRIMSTR.

12.18 TRIMSTR

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

(TRIMSTR str [début fin])

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

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

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

Voir aussi REMCHARS.

12.19 WORD

WORD retourne un mot contenu dans une chaîne.

(WORD str num)

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

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

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

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

12.20 WORDS

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

(WORDS str)

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

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

Voir aussi WORD, LINES, LEN.

12.21 FIELD

FIELD retourne un champ dans une chaîne.

(FIELD str num [sep [quotes]])

Renvoie la "num"-ième champ (à partir de zéro) de la chaîne spécifiée. Les champs d'une chaîne sont des sous-chaînes séparées par exactement un caractère de séparation. Un champ peut être une chaîne vide. L'argument "sep" contient les caractères qui séparent les champs. Si "sep" est NIL ou n'est pas fourni, des caractères d'espace insécables (par exemple, espace, tabulation ou retour chariot) sont utilisés. Si des guillemets sont donnés et non NIL, les champs peuvent être entourés de guillemets doubles et contenir des caractères de séparation. Les guillemets doubles sont supprimés lors du renvoi du champ.

Si "str" ou "num" sont NIL, or si "num" est hors limite, c'est-à-dire, moins que zéro ou plus grand ou égal au nombre de champs, alors NIL is retourné.

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

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

12.22 FIELDS

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

(FIELDS str [sep [quotes]])

Renvoie le nombre de champ dans une chaîne donnée ou NIL si "str" est NIL. Les champs dans une chaîne sont des sous-chaînes séparées par exactement un caractère de séparation. Un champ peut être une chaîne vide. L'argument "sep" contient les caractères qui séparent les champs. Si "sep" est NIL ou n'est pas fourni, des caractères d'espace insécables (par exemple, espace, tabulation ou retour chariot) sont utilisés. Si des guillemets sont donnés et non NIL, les champs peuvent être entourés de guillemets doubles et contenir des caractères de séparation.

Voir aussi FIELD, WORDS, LEN.

12.23 STRTOLIST

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

(STRTOLIST str [sep])

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

Exemples :
  • "(STRTOLIST "J'aime\tle\tJapon.")" retourne ( "J'aime" "le" "Japon." ).
  • "(STRTOLIST "Nom|Rue|Ville" "|")" retourne ( "Nom" "Rue" "Ville" ).
  • "(STRTOLIST "abc" "")" retourne ( "a" "b" "c" ).
Voir aussi MEMOTOLIST, LISTTOSTR.

12.24 LISTTOSTR

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

(LISTTOSTR liste [sep])

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

Exemples :
  • "(LISTTOSTR (LIST "Pierre a" 18 "ans"))" retourne "Pierre a\t18\tans".
  • "(LISTTOSTR (LIST "Nom" "Rue" "Ville") "|")" retourne "Nom|Rue|Ville".
Voir aussi LISTTOMEMO, CONCAT, CONCAT2, STRTOLIST.

12.25 CONCAT

CONCAT concatène des chaînes.

(CONCAT [str ...])

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

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

12.26 CONCAT2

CONCAT2 concatène des chaînes.

(CONCAT2 insert [str ...])

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

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

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

12.27 COPYSTR

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

(COPYSTR str num)

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

Exemple : "(COPYSTR "+-" 5)" retourne "+-+-+-+-+-".

Voir aussi CONCAT CONCAT2, +, SPRINTF.

12.28 SHA1SUM

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

(SHA1SUM str)

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

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

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

12.29 UPPER

UPPER convertit une chaîne en majuscules.

(UPPER str)

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

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

Voir aussi LOWER.

12.30 LOWER

LOWER convertit en minuscules une chaîne.

(LOWER str)

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

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

Voir aussi UPPER.

12.31 ASC

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

(ASC str)

Renvoie le code entier interne du premier caractère de "str". Il s'agit du code entier 8 bits dans le jeu de caractères configuré dans le système. Si "str" est vide, le résultat est 0. Si "str" est NIL, le résultat est NIL.

Exemple : (ASC "A") retourne 65.

Voir aussi CHR, INT.

12.32 CHR

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

(CHR entier)

Renvoie une chaîne contenant le caractère de code entier "entier". "entier" est un entier 8 bits dans le jeu de caractères configuré dans le système. Si "entier" vaut 0, une chaîne vide est renvoyée. Si "entier" est NIL ou en dehors de l'intervalle des caractères valides, le résultat est NIL.

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

Voir aussi ASC, STR.

12.33 LIKE

LIKE compare des chaînes.

(LIKE str1 str2)

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

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

Voir aussi 10. Fonctions de comparaison.

12.34 SPRINTF

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

(SPRINTF fmt [expr ...])

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

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

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

Où :
  • Le champ optionnel "drapeaux" contrôle la justification, le caractère de signe des valeurs numériques, le point décimal et les espaces de fin.
  • Le champ optionnel "largeur" indique le nombre minimum de caractères à afficher (la largeur du champ), avec un bourrage par des blancs ou des zéros.
  • Le champ optionnel "précision" spécifie soit le plus grand nombre de caractères à restituer pour les types chaîne, booléen, date et heure, soit le nombre de décimales à restituer après le séparateur décimal pour le type réel.
  • Le champ "type" indique le type effectif de l'argument que SPRINTF va convertir : texte, entier, réel, etc.
Noter que le tous les champs ci-dessus sont optionnels à l'exception de type. Les tableaux suivants listent les options valides pour ces champs.

Champ drapeaux
  • - : le résultat est justifié à gauche, avec un bourrage par la droite avec des blancs. Par défaut lorsque "-" n'est pas spécifié, le résultat est justifié à droite avec un bourrage à gauche par des 0 ou des blancs.
  • + : le résultat possède toujours un caractère représentant son signe s'il s'agit d'une conversion numérique.
  • 0 : pour les nombres justifiés à gauche, le remplissage est effectué avec des zéros au lieu d'espaces.
  • espace : les nombres positifs débutent par un espace à la place d'un caractère "+", en revanche les valeurs négatives sont toujours préfixées d'un "-".
Champ largeur
  • n : un minimum de "n" caractères sont affichés. Si la conversion dispose de moins de "n" caractères, un remplissage par des espaces ou des zéros non-significatifs est effectué.
  • * : la valeur de la largeur est fournie dans la liste d'arguments en tant que valeur entière ou réelle, avant l'argument à convertir. Cette valeur est limitée à l'intervalle 0-999.
Champ précision
  • .n : pour les valeurs de type texte, booléen, date et heure, "n" est le nombre maximum de caractères de l'élément converti à restituer. Pour les conversions de valeurs réelles, "n" spécifie le nombre de chiffres après la virgule (conversions "f" et "e") ou le nombre de chiffres significatifs (conversion "g"). Dans les conversions d'entiers, ce champ est ignoré.
  • .* : la valeur de la précision est fournie dans la liste des arguments sous forme de valeur entière ou réelle, avant l'argument à convertir. Cette valeur est limitée à l'intervalle 0-999.
Champ type
  • b : convertit une valeur booléenne en "TRUE" ou "NIL".
  • i : convertit une valeur entière en une notation décimale signée. o : convertit une valeur entière en une notation octale non signée.
  • x : convertit une valeur entière en une notation hexadécimale non signée, en utilisant les lettres minuscules "abcdef".
  • X : convertit une valeur entière en une notation hexadécimale non signée, en utilisant les lettres majuscules "ABCDEF".
  • e : convertit une valeur réelle en utilisant le format [-]d.ddde+dd (NDT : c'est-à-dire la notation scientifique). Exactement un chiffre avant le point décimal, suivi d'un "e", suivi d'un exposant. Le nombre de chiffres après le point décimal est déterminé par le champ précision ou est de 2 si aucune précision n'a été spécifiée. Le point décimal n'apparaît pas si la précision est de 0.
  • f : convertit une valeur réelle en utilisant le format [-]ddd.ddd. Le nombre de chiffres après le point décimal est déterminé par le champ précision ou est de 2 si aucune précision n'est spécifiée. Le point décimal n'apparaît pas si la précision est de 0.
  • g : convertit une valeur réelle en utilisant le style "e" ou "f" en fonction du nombre de chiffres représentant la valeur. Les zéros terminaux sont supprimés de la sortie, à l'exception de celui qui suit directement le point décimal.
  • s : écrit la chaîne jusqu'à ce que la fin de la chaîne soit atteinte, ou jusqu'à ce que le nombre de caractères spécifié par le champ précision soit atteint.
  • d : convertit une valeur de date.
  • t : convertit une valeur horaire.
  • % : écrit le caractère "%" sans qu'aucun argument ne soit converti.
SPRINTF retourne la chaîne formatée ou NIL si "fmt" est NIL.

Exemples :
  • (SPRINTF "Hello") retourne "Hello"
  • (SPRINTF "%s" "Hello") retourne "Hello"
  • (SPRINTF "%10s" "Hello") retourne " Hello"
  • (SPRINTF "%-10.10s" "Hello") retourne "Hello "
  • (SPRINTF "%010.3s" "Hello") retourne " Hel"
  • (SPRINTF "%-5.3b" TRUE) retourne "TRU "
  • (SPRINTF "%i" 3) retourne "3"
  • (SPRINTF "%03i" 3) retourne "003"
  • (SPRINTF "%0- 5.3i" 3) retourne " 3 "
  • (SPRINTF "%f" 12) retourne "12.00"
  • (SPRINTF "%10e" 12.0) retourne " 1.20e+01"
  • (SPRINTF "%+-10.4f" 12.0) retourne "+12.0000 "
  • (SPRINTF "%10.5t" 12:30:00) retourne " 12:30"
  • (SPRINTF "%d" 28.11.1968) retourne "28.11.1968"
  • (SPRINTF "He%s %5.5s!"
    "llo"
    "world champion ship") retourne "Hello world!"
Voir aussi PRINTF, FPRINTF, STR, +, CONCAT, CONCAT2, COPYSTR.

13. Fonctions sur les mémos

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

13.1 LINE - Extraire une ligne d'un mémo.
13.2 LINES - Nombre de lignes dans un mémo.
13.3 MEMOTOLIST - Convertir un mémo en liste.
13.4 LISTTOMEMO - Convertir une liste en mémo.
13.5 FILLMEMO - Remplir un mémo.
13.6 FORMATMEMO - Formater un mémo.
13.7 INDENTMEMO - Indenter un mémo.

13.1 LINE

LINE extrait une ligne d'un mémo.

(LINE memo num)

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

Voir aussi LINES, WORD.

13.2 LINES

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

(LINES memo)

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

Voir aussi LINE, WORDS, LEN.

13.3 MEMOTOLIST

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

(MEMOTOLIST memo [expandstr])

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

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

Exemples :
  • "(MEMOTOLIST "Mon assurance\nprend en charge\nle vélo cassé.")" retourne ( "Mon assurance" "prend en charge" "le vélo cassé." ).
  • "(MEMOTOLIST "Voici\tun exemple\nmulti-colonnes." TRUE)" retourne ( ( "Voici" "un exemple" ) ( "multi-colonnes." ) ).
Voir aussi STRTOLIST, LISTTOMEMO.

13.4 LISTTOMEMO

LISTTOMEMO convertit une liste en mémo.

(LISTTOMEMO list)

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

Exemples :
  • "(LISTTOMEMO (LIST "Silke" "me prête" "« mon » vélo" "jusqu'au" 01.09.1998)" retourne "Silke\nme prête\n« mon » vélo\njusqu'au\n01.09.1998".
  • "(LISTTOMEMO (LIST (LIST "Nom" "Date naissance") (LIST "Steffen" 28.11.1968)" retourne "Nom\tDate naissance\nSteffen\t28.11.1968".
Voir aussi LISTTOSTR, MEMOTOLIST.

13.5 FILLMEMO

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

(FILLMEMO memo)

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

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

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

Voir aussi FORMATMEMO, INDENTMEMO.

13.6 FORMATMEMO

FORMATMEMO formate un mémo.

(FORMATMEMO memo longueur [bourrage [secmonoligne]])

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

Voir aussi FILLMEMO, INDENTMEMO.

13.7 INDENTMEMO

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

(INDENTMEMO memo indentation)

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

Voir aussi FILLMEMO, FORMATMEMO.

14. Fonctions sur la date et l'heure

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

14.1 DAY - Extraire le jour à partir d'une date.
14.2 MONTH - Extraire le mois à partir d'une date.
14.3 YEAR - Extraire l'année à partir d'une date.
14.4 DATEDMY - Créer une date à partir du jour, du mois et de l'année.
14.5 MONTHDAYS - Nombre de jours d'un mois.
14.6 YEARDAYS - Nombre de jours d'une année.
14.7 ADDMONTH - Ajouter un nombre de mois à une date.
14.8 ADDYEAR - Ajouter un nombre d'années à une date.
14.9 TODAY - Obtenir la date courante.
14.10 NOW - Obtenir l'heure courante.

14.1 DAY

DAY extrait le jour d'une date.

(DAY date)

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

Voir aussi MONTH, YEAR, DATEDMY.

14.2 MONTH

MONTH extrait le mois d'une date.

(MONTH date)

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

Voir aussi DAY, YEAR, DATEDMY, MONTHDAYS.

14.3 YEAR

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

(YEAR date)

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

Voir aussi DAY, MONTH, DATEDMY, YEARDAYS.

14.4 DATEDMY

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

(DATEDMY jour mois année)

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

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

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

14.5 MONTHDAYS

MONTHDAYS donne le nombre de jours d'un mois.

(MONTHDAYS mois année)

Renvoie le nombre de jours à partir des données du mois et de l'année. Si "mois" est NIL ou hors limite (inférieur à 1 ou supérieur à 12), alors NIL est retourné. Si "année" est NIL alors une année non bissextile est supposée pour calculer le nombre de jours. Si "année" est invalide (inférieure à 0 ou supérieure à 9999), alors NIL est retourné.

Exemples :
  • "(MONTHDAYS 2 2004)" donne 29.
  • "(MONTHDAYS 2 NIL)" donne 28.
Voir aussi YEARDAYS, MONTH.

14.6 YEARDAYS

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

(YEARDAYS année)

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

Exemples :
  • "(YEARDAYS 2004)" donne 366.
  • "(YEARDAYS 2005)" donne 365.
Voir aussi MONTHDAYS, YEAR.

14.7 ADDMONTH

ADDMONTH ajoute un certain nombre de mois à une date.

(ADDMONTH date mois)

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

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

Exemples :
  • "(ADDMONTH 30.01.2004 1)" donne 29.02.2004.
  • "(ADDMONTH 30.01.2004 -1)" donne 30.12.2003.
Voir aussi ADDYEAR, +.

14.8 ADDYEAR

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

(ADDYEAR date années)

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

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

Exemples :
  • "(ADDYEAR 29.02.2004 1)" donne 28.02.2005.
  • "(ADDMONTH 04.02.2004 -1962)" donne 04.02.0042.
Voir aussi ADDMONTH, +.

14.9 TODAY

TODAY renvoie la date du jour.

(TODAY)

Renvoie la date du jour en tant que valeur date.

Voir aussi NOW, DATEDMY.

14.10 NOW

NOW renvoie l'heure courante.

(NOW)

Renvoie l'heure courante en tant que valeur de l'heure.

Voir aussi TODAY.

15. Liste des fonctions

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

15.1 CONS - Constructeur élémentaire de liste.
15.2 LIST - Produire une liste d'éléments.
15.3 LENGTH - Obtenir le nombre d'éléments d'une liste.
15.4 FIRST - Extraire le premier élément d'une liste.
15.5 REST - Obtenir le reste d'une liste.
15.6 LAST - Extraire le dernier élément d'une liste.
15.7 NTH - Extraire le N ième élément d'une liste.
15.8 APPEND - Enchaîner les listes.
15.9 REVERSE - Renverser une liste.
15.10 MAPFIRST - Application d'une fonction à tous les éléments d'une liste.
15.11 SORTLIST - Trier les éléments d'une liste.
15.12 SORTLISTGT - Trier les éléments d'une liste.

15.1 CONS

CONS établit une paire d'expressions.

(CONS elem list)

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

Exemple : "(CONS 1 (CONS 2 NIL))" donne ( 1 2 ).

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

Voir aussi LIST, FIRST, REST.

15.2 LIST

LIST produit une liste en dehors de ses arguments.

(LIST [elem ...])

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

Voir aussi CONS, LENGTH.

15.3 LENGTH

LENGTH détermine la longueur d'une liste.

(LENGTH list)

Renvoie la longueur des données de la liste.

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

Voir aussi LIST.

15.4 FIRST

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

(FIRST list)

Renvoie le premier élément des données de la liste. Si "list" est vide (NIL) alors NIL est retourné.

Voir aussi REST, LAST, NTH, CONS.

15.5 REST

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

(REST list)

Renvoie le reste des données de la liste (la liste sans premier élément). Si "list" est vide (NIL) alors NIL est retourné.

Exemple : "(REST (LIST 1 2 3))" donne ( 2 3 ).

Voir aussi FIRST, CONS.

15.6 LAST

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

(LAST list)

Renvoie le dernier élément des données de la liste ou NIL si "list" est NIL.

Voir aussi FIRST, NTH.

15.7 NTH

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

(NTH n list)

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

Voir aussi FIRST, LAST.

15.8 APPEND

APPEND enchaîner les listes.

(APPEND [list ...])

Renvoie la concaténation de "list ...".

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

Voir aussi LIST.

15.9 REVERSE

REVERSE renverse une liste.

(REVERSE list)

Renvoie la liste renversée.

Exemple : "(REVERSE (list 1 2 3))" donne ( 3 2 1 ).

15.10 MAPFIRST

MAPFIRST applique une fonction à tous les éléments de la liste.

(MAPFIRST func list [...])

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

Exemples :
  • "(MAPFIRST 1+ (LIST 1 2 3))" donne "( 2 3 4 )".
  • "(MAPFIRST + (LIST 1 2 3) (LIST 2 3))" donne "( 3 5 NIL )".
15.11 SORTLIST

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

(SORTLIST func list)

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

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

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

Maintenant vous pouvez trier une liste en appelant :

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

...qui retourne :

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

Voir aussi SORTLISTGT, MAPFIRST.

15.12 SORTLISTGT

SORTLIST tri les éléments de la liste.

(SORTLISTGT gtfunc list)

Comme SORTLIST mais ici vous indiquez une fonction de tri qui renvoie une valeur différente de NIL si le premier et le second élément sont supérieur, et NIL autrement.

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

Voir aussi SORTLIST, MAPFIRST.

16. Fonctions de demande de saisie

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

16.1 ASKFILE - Invite l'utilisateur à fournir un nom de fichier.
16.2 ASKDIR - Invite l'utilisateur à fournir un nom de répertoire.
16.3 ASKSTR - Invite l'utilisateur à fournir une chaîne texte.
16.4 ASKINT - Invite l'utilisateur à fournir un nombre entier.
16.5 ASKCHOICE - Invite l'utilisateur à fournir un article parmi beaucoup d'articles.
16.6 ASKCHOICESTR - Invite l'utilisateur à fournir une chaîne texte, parmi celle qui sont prédéfinies.
16.7 ASKOPTIONS - Invite l'utilisateur à fournir quelques articles parmi beaucoup d'articles.
16.8 ASKBUTTON - Invite l'utilisateur à appuyer sur un bouton.
16.9 ASKMULTI - Invite l'utilisateur à fournir plusieurs informations.

16.1 ASKFILE

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

(ASKFILE title oktext default savemode)

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

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

Voir aussi ASKDIR, ASKSTR.

16.2 ASKDIR

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

(ASKDIR title oktext default savemode)

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

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

Voir aussi ASKFILE, ASKSTR.

16.3 ASKSTR

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

(ASKSTR title oktext default maxlen [secret])

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

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

Voir aussi ASKFILE, ASKDIR, ASKCHOICESTR, ASKINT.

16.4 ASKINT

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

(ASKINT title oktext default min max)

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

ASKINT renvoie le nombre entier saisie ou NIL si l'utilisateur annule la requête.

Voir aussi ASKSTR.

16.5 ASKCHOICE

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

(ASKCHOICE titre oktext choix defaut [titres])

Ouvre une requête de saisie demandant à l'utilisateur de choisir un élément dans une liste. Vous pouvez placer le titre de la fenêtre et le texte du bouton "Ok" dans "titre" et "oktext" (chaîne texte ou NIL pour des valeurs par défaut). Dans "choix", vous indiquez une liste de choix sous forme de mémo avec un choix par ligne. Il est possible d'utiliser un format multicolonne en séparant les colonnes par le caractère tabulation "\t". La valeur initiale peut être placée dans "defaut", il s'agit de l'index de la ligne dans le mémo (en commençant par l'index 0 pour le premier élément). Utilisez NIL pour ne pas spécifier de valeur initiale. Si l'argument optionnel titres est spécifié et n'est pas NIL, alors un entête de colonne est affiché dans la liste en utilisant les titres contenus dans titres. Dans le cas de colonnes multiples, séparez les titres de colonnes par des tabulations.

"choix" et "titre" 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 ou LISTTOSTR respectivement.

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

Exemple :

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

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

(LET ((requete (SELECT Article, Nom, Quantite, Prix from Article 
                  WHERE (> Prix 10) ORDER BY Nom))
     (enregs (MAPFIRST FIRST (REST query)))       ; pointeurs d'enregistrement
     (elements (MAPFIRST REST (REST query)))      ; choix
     (titres (REST (FIRST query)))                ; titres
     (index (ASKCHOICE "Sélectionnez" "Ok" items NIL titles))
     (elem (NTH index enregs))) 
     ; maintenant elem contient l'enregistrement choisi (ou NIL si annulation)
)

Voir aussi ASKCHOICESTR, ASKOPTIONS.

16.6 ASKCHOICESTR

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

(ASKCHOICESTR titre oktext chaines defaut [titres])

Ouvre une requête de saisie demandant à l'utilisateur de choisir une chaîne texte dans une liste ou d'en saisir une dans un champ texte séparé. Vous pouvez placer le titre de fenêtre et le texte du bouton "Ok" dans "titre" et "oktext" (chaîne texte ou NIL pour des valeurs par défaut). Dans "chaines", vous indiquez la liste de choix sous forme de mémo avec un choix par ligne. Vous pouvez utiliser un format multicolonne en séparant les colonnes par le caractère tabulation "\t". La valeur initiale du champ texte peut être placée dans "defaut" (chaîne texte ou NIL pour un champ texte vide). Si l'argument optionnel "titres" est spécifié et n'est pas NIL, alors un entête de colonne est affiché dans la liste en utilisant les titres contenus dans titres. Dans le cas de colonnes multiples, séparez les titres de colonnes par des tabulations.

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

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

Exemple :

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

Voir aussi ASKCHOICE, ASKOPTIONS.

16.7 ASKOPTIONS

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

(ASKOPTIONS titre oktext options selectionnes [titres])

Ouvre une requête de saisie demandant à l'utilisateur de sélectionner une ou plusieurs options dans une liste. Vous pouvez placer le titre de la fenêtre et le texte du bouton "Ok" dans "titre" et "oktext" (chaîne texte ou NIL pour des valeurs par défaut). Dans "options", vous indiquez la liste d'options sous forme de mémo avec une option par ligne. Vous pouvez utiliser un format multicolonne en séparant les colonnes par le caractère tabulation "\t". L'état initial peut être spécifié dans selectionnes sous forme de liste de nombres entiers spécifiant l'index dont la ligne correspondante dans options qui doit être sélectionnée au début. Utilisez NIL pour tous les éléments ne devant pas être présélectionnés.

Si l'argument optionnel "titres" est spécifié et n'est pas NIL, alors un entête de colonne est affiché dans la liste en utilisant les titres contenus dans titres. Dans le cas de colonnes multiples, séparez les titres de colonnes par des tabulations.

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

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

Exemple :

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

16.8 ASKBUTTON

ASKBUTTON invite l'utilisateur à appuyer sur un bouton.

(ASKBUTTON title text buttons canceltext)

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

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

Exemples :

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

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

Voir aussi ASKCHOICE.

16.9 ASKMULTI

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

(ASKMULTI title oktext itemlist)

ASKMULTI est une requête de saisie à usages multiples. Il ouvre une requête avec le titre indiqué, un ensemble d'objets GUI pour l'édition des données, et deux boutons ("Ok" et "Annuler") pour fermer la requête. Le texte du bouton "Ok" peut être placé dans "oktext" (chaîne texte ou NIL pour le texte de défaut). L'ensemble des objets GUI sont spécifiés dans "itemlist" qui est une liste où chaque élément a l'une des formes suivantes :
  • (LIST title "String" initial [help [secret]]) pour éditer une ligne de texte.
  • (LIST title "Memo" initial [help]) pour éditer plusieurs lignes de texte.
  • (LIST title "Integer" initial [help]) pour éditer un nombre entier.
  • (LIST title "Real" initial [help]) pour éditer un réel.
  • (LIST title "Date" initial [help]) pour éditer une date.
  • (LIST title "Time" initial [help]) pour éditer une heure.
  • (LIST title "Bool" initial [help]) pour un champ booléen.
  • (LIST title "Choice" initial
    (LIST choice ...) [help]
    ) pour un champ choix.
  • (LIST title "ChoiceList" initial
    (LIST choice ...) [help]
    ) pour choisir un élément dans une liste.
  • (LIST title "Options" initial
    (LIST option ...) [help]
    ) pour choisir plusieurs éléments dans une liste.
  • non-list-expr pour le texte statique
Le titre (chaîne texte ou NIL s'il n'y a pas de titre) sera affiché à la gauche de l'objet GUI. Si la valeur initiale est NIL la valeur par défaut est utilisée (par exemple un champ texte vide). Pour le choix de la valeur initiale des champs, l'index doit être (démarrer avec 0) l'entrée active initiale, parce que la valeur initiale d'une liste de champs peut être NIL (aucun article n'est activé), et pour les options des champs la valeur initiale doit être une liste de nombres entiers représentant les index (démarrant avec 0) des articles qui ont initialement été sélectionnés. Le champ facultatif d'aide (chaîne texte) peut être utilisé pour fournir plus d'information à l'utilisateur au sujet de l'utilisation du champ. Pour les champs texte un paramètre additionnel "secret" peut être spécifié. S'il n'est pas NIL alors le contenu du champ texte est rendu invisible en affichant un symbole rond pour chacun de ses caractères.

ASKMULTI renvoie une liste de résultats que l'utilisateur a édités et validés en appuyant sur le bouton "Ok". Chaque valeur de résultat d'un champ a le même format que celui de la valeur initiale, par exemple pour le choix d'une liste de champs la valeur résultat est l'index de l'article choisi (ou NIL si aucun article n'a été choisi) ou pour une option de champ la valeur résultat est une liste de nombres entiers représentant les index des articles choisis. Pour le texte statique une valeur NIL est retournée.

Par exemple si vous avez indiqué un champ date, un champ texte statique, le choix d'un champ texte, une option de champ et une chaîne champ de texte avec la valeur initiale "world", et que l'utilisateur a écrit 11.11.1999, choisi l'entrée avec l'index numéro 2, choisi le 3e et 4e article dans l'option champ, et à gauche laissé le champ de la chaîne texte intact alors la fonction renvoie la liste "( 11.11.1999 NIL 2 ( 3 4 ) "world" )".

Si l'utilisateur a annulé la requête, NIL est retourné.

Exemple :

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

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

17. Fonctions d'E/S

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

17.1 FOPEN - Ouverture d'un fichier pour la lecture/écriture.
17.2 FCLOSE - Fermeture d'un fichier.
17.3 stdout - Descripteur de fichier de la sortie standard.
17.4 PRINT - Imprimer une expression vers la sortie standard.
17.5 PRINTF - Formater l'impression vers la sortie standard.
17.6 FPRINTF - Formater l'impression vers un fichier.
17.7 FERROR - Vérification des erreurs d'un fichier.
17.8 FEOF - Détection de la fin d'un fichier.
17.9 FSEEK - Réglage de la position dans un fichier.
17.10 FTELL - Obtenir la position actuelle dans un fichier.
17.11 FGETCHAR - Lecture du prochain caractère entrée à partir d'un fichier.
17.12 FGETCHARS - Lecture de plusieurs caractères d'entrée à partir d'un fichier.
17.13 FGETSTR - Lecture d'une chaîne texte à partir d'un fichier.
17.14 FGETMEMO - Lecture d'un mémo à partir d'un fichier.
17.15 FPUTCHAR - Écrire un caractère dans un fichier.
17.16 FPUTSTR - Écrire une chaîne dans un fichier.
17.17 FPUTMEMO - Écrire un mémo dans un fichier.
17.18 FFLUSH - Nettoyer un fichier.
17.1 FOPEN

FOPEN ouvre un fichier en lecture/écriture.

(FOPEN nomfichier mode [encodage])

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

Le paramètre optionnel encodage contrôle l'encodage du fichier et peut prendre l'une des chaînes suivantes pour valeur :
  • "none" : aucune interprétation de caractère n'est effectuée. Utilisez ceci pour les fichiers binaires.
  • "UTF-8" : le texte est encodé en UTF-8. La lecture et l'écriture convertissent depuis/en UTF-8.
  • "locale" : le texte est encodé selon les réglages de votre système. Sur Amiga, c'est l'encodage à 8 bits par défaut.
  • "8-bit" : le texte est encodé selon l'encodage à 8 bits par défaut. Sur Amiga, il s'agit de l'encodage à 8 bits par défaut du système (comme "locale").
  • "auto" : l'encodage est détecté automatiquement. Si le fichier est lisible alors l'encodage est déterminé comme suit : si l'intégralité du contenu est conforme à UTF-8 alors "UTF-8" (avec guillemets) est utilisé. Sinon, si la locale du système n'est pas UTF-8 alors "locale" est utilisé. Autrement, c'est "8-bit" qui est utilisé. Lors de l'écriture, si l'encodage n'a pas encore été déterminé, alors la première locale du système rencontrée est essayée. Si aucune erreur de conversion ne se produit, c'est "locale" qui est utilisé, sinon "UTF-8".
Si aucun paramètre encodage n'est spécifié, c'est "auto" qui est utilisé.

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

Exemples :
  • (FOPEN "index.html" "w" "utf-8") ouvre et renvoi un descripteur de fichier pour écrire dans le fichier "index.html" selon l'encodage UTF-8.
  • (FOPEN "output.txt" "a+") ouvre le fichier "output.txt" pour y ajouter des données dans le même encodage que celui du fichier. Remarquez que si vous spécifiez uniquement "a" pour "mode", MUIbase peut ne pas être en mesure de lire le fichier et de déterminer son encodage. Dans ce cas, l'encodage sera déterminé au moment de l'écriture (et pourrait être différent de celui de la première partie du fichier).
Voir aussi FCLOSE, stdout, FFLUSH.

17.2 FCLOSE

FCLOSE ferme un fichier.

(FCLOSE file)

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

Voir aussi FOPEN, FFLUSH.

17.3 stdout

La variable globale stdout conserve le descripteur de fichier vers la sortie standard de MUIbase. Le nom du fichier de sortie peut être réglé depuis le menu "Programme - fichier de sortie".

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" (avec les guillemets), soit "a+" (idem) en fonction du réglage "Ajouter" du menu "Programme - Fichier de sortie". L'encodage est réglé à "auto" (idem).

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

Voir aussi FOPEN, PRINTF.

17.4 PRINT

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

(PRINT elem)

Convertit la valeur de "elem" en chaîne lisible et l'imprime dans stdout. Cette fonction existe principalement pour le débogage (la mise au point). Cette fonction n'est pas considérée comme ayant un effet secondaire tel qu'elle peut être utilisée par exemple pour déboguer une fonction de comparaison.

Voir aussi PRINTF, stdout, Fonction de comparaison.

17.5 PRINTF

PRINTF imprime une chaîne formater.

(PRINTF format [expr ...])

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

PRINTF renvoie le nombre de caractères en sortie ou NIL en cas d'échec. Si "format" est NIL, alors NIL est retourné.

Cette fonction n'est pas considérée comme ayant un effet secondaire tel qu'elle peut être utilisée par exemple pour déboguer une fonction de comparaison.

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

17.6 FPRINTF

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

(FPRINTF file format [expr ...])

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

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

Voir aussi PRINTF, FOPEN.

17.7 FERROR

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

(FERROR file)

Renvoie TRUE si une erreur pour les données d'un fichier donné s'est produite, NIL autrement. Si "file" est NIL, alors NIL est retourné.

Voir aussi FEOF, FOPEN, FCLOSE.

17.8 FEOF

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

(FEOF file)

Examine l'indicateur de fin de fichier d'un fichier donné et renvoie TRUE s'il est placé, autrement NIL est retourné. Si le "file" est NIL, alors NIL est retourné.

Voir aussi FERROR, FTELL, FOPEN, FCLOSE.

17.9 FSEEK

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

(FSEEK file offset whence)

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

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

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

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

17.10 FTELL

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

(FTELL file)

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

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

Voir aussi FSEEK, FOPEN, FEOF.

17.11 FGETCHAR

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

(FGETCHAR file)

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

Voir aussi FGETCHARS, FGETSTR, FPUTCHAR.

17.12 FGETCHARS

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

(FGETCHARS num file)

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

Voir aussi FGETCHAR, FGETSTR.

17.13 FGETSTR

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

(FGETSTR file)

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

Voir également FGETCHAR, FGETCHARS, FGETMEMO, FPUTSTR.

17.14 FGETMEMO

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

(FGETMEMO file)

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

Voir aussi FGETSTR, FPUTMEMO.

17.15 FPUTCHAR

FPUTCHAR écrit un caractère dans un fichier.

(FPUTCHAR str file)

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

Voir aussi FPUTSTR, FGETCHAR.

17.16 FPUTSTR

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

(FPUTSTR str file)

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

Voir aussi FPUTCHAR, FPUTMEMO, FGETSTR.

17.17 FPUTMEMO

FPUTMEMO écrit un mémo dans un fichier.

(FPUTMEMO memo file)

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

Voir aussi FPUTSTR, FGETMEMO.

17.18 FFLUSH

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

(FFLUSH fichier)

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

Voir aussi FOPEN, FCLOSE.

18. Les fonctions sur les enregistrements

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

18.1 NEW - Alloue un nouvel enregistrement.
18.2 NEW* - Alloue un nouvel enregistrement en appelant le déclencheur.
18.3 DELETE - Supprime un enregistrement.
18.4 DELETE* - Supprime un enregistrement en appelant le déclencheur.
18.5 DELETEALL - Supprime tous les enregistrements d'une table.
18.6 GETMATCHFILTER - Obtient l'état du filtre de correspondance d'un enregistrement.
18.7 SETMATCHFILTER - Règle l'état du filtre de correspondance d'un enregistrement.
18.8 GETISSORTED - Vérifie si un enregistrement est dans le bon ordre.
18.9 SETISSORTED - Indique à un enregistrement l'état de son ordre.
18.10 RECNUM - Donne le nombre d'enregistrements d'un enregistrement.
18.11 COPYREC - Copie le contenu d'un enregistrement.

18.1 NEW

NEW alloue un nouvel enregistrement pour une table.

(NEW table init)

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

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

La fonction NEW a un effet secondaire qui initialise le programme pointant les enregistrements d'une table donnée 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.

18.2 NEW*

NEW* est une version améliorée de NEW (voir NEW).

(NEW* table init)

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

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

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

Voir aussi NEW, DELETE*.

18.3 DELETE

DELETE supprime les enregistrements dans une table.

(DELETE table confirm)

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

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

À propos de la suppression, DELETE place le pointeur du programme d'enregistrement (voir 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.

18.4 DELETE*

DELETE* est une version améliorée de DELETE (voir DELETE).

(DELETE* table confirm)

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

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

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

Voir aussi DELETE, DELETEALL, NEW*.

18.5 DELETEALL

DELETEALL supprime tous les enregistrements d'une table.

(DELETEALL table[*])

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

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

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

Voir aussi DELETE, Tables.

18.6 GETMATCHFILTER

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

(GETMATCHFILTER rec)

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

Voir aussi SETMATCHFILTER, GETISSORTED, GETFILTERSTR, SETFILTERSTR.

18.7 SETMATCHFILTER

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

(SETMATCHFILTER rec on)

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

Voir aussi GETMATCHFILTER, SETISSORTED, GETFILTERSTR, SETFILTERSTR.

18.8 GETISSORTED

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

(GETISSORTED rec)

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

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

18.9 SETISSORTED

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

(SETISSORTED rec on)

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

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

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

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

18.10 RECNUM

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

(RECNUM record)

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

Voir aussi RECORDS, INT.

18.11 COPYREC

COPYREC copie les enregistrements.

(COPYREC rec source)

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

COPYREC renvoie rec.

Voir aussi NEW.

19. Fonctions sur les champs

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

19.1 ATTRNAME - Obtenir le nom d'un champ.
19.2 MAXLEN - Nombre maximum de caractères pour le champ d'une chaîne.
19.3 GETLABELS - Obtenir le label des choix ou le champ d'une chaîne texte.
19.4 SETLABELS - Réglage des entrées de la liste d'affichage pour le champ d'une chaîne.

19.1 ATTRNAME

ATTRNAME renvoie le nom d'un champ.

(ATTRNAME attr)

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

Voir aussi TABLENAME.

19.2 MAXLEN

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

(MAXLEN string-attr)

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

Voir aussi LEN.

19.3 GETLABELS

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

(GETLABELS attr)

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

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

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

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

Voir aussi SETLABELS.

19.4 SETLABELS

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

(SETLABELS attr str)

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

SETLABELS renvoie la valeur de l'argument "str".

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

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

Voir aussi GETLABELS.

20. Fonctions sur les tables

20.1 TABLENAME - Obtenir le nom d'une table.
20.2 GETORDERSTR - Obtenir le tri d'un enregistrement.
20.3 SETORDERSTR - Réglage du tri de l'enregistrement.
20.4 REORDER - Réordonner les enregistrements non triés.
20.5 REORDERALL - Réordonner tous les enregistrements d'une table.
20.6 GETFILTERACTIVE - Obtenir l'état du filtre d'enregistrement.
20.7 SETFILTERACTIVE - Réglage de l'état du filtre d'enregistrement.
20.8 GETFILTERSTR - Obtenir l'expression du filtre d'enregistrement.
20.9 SETFILTERSTR - Réglage de l'expression du filtre d'enregistrement.
20.10 RECORDS - Nombre d'enregistrements.
20.11 RECORD - Obtenir le pointeur d'enregistrement.
20.12 SELECT - Requêtes "Select-from-where".

20.1 TABLENAME

TABLENAME renvoie le nom d'une table.

(TABLENAME table)

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

Voir aussi ATTRNAME.

20.2 GETORDERSTR

GETORDERSTR renvoie un enregistrement trié dans une table.

(GETORDERSTR table)

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

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

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

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

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

20.3 SETORDERSTR

SETORDERSTR place un enregistrement trié dans une table.

(SETORDERSTR table Tri)

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

Pour trier en utilisant une liste de champs, le champ "Tri" doit contenir les noms des champs séparés par un nombre d'espaces, tabulations ou une nouvelle ligne. Chaque nom de champ peut être précédé par le signe "+" ou "-" 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 qui permet de copier le nom d'un champ dans le champ tri.

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

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

20.4 REORDER

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

(REORDER table)

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

REORDER renvoie NIL.

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

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

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

20.5 REORDERALL

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

(REORDERALL table)

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

REORDERALL renvoie NIL.

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

20.6 GETFILTERACTIVE

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

(GETFILTERACTIVE table)

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

Voir aussi SETFILTERACTIVE, GETFILTERSTR, GETMATCHFILTER.

20.7 SETFILTERACTIVE

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

(SETFILTERACTIVE table bool)

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

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

Voir aussi GETFILTERACTIVE, SETFILTERSTR, SETMATCHFILTER.

20.8 GETFILTERSTR

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

(GETFILTERSTR table)

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

Voir aussi SETFILTERSTR, GETFILTERACTIVE, GETMATCHFILTER.

20.9 SETFILTERSTR

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

(SETFILTERSTR table filter-str)

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

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

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

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

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

Voir aussi GETFILTERSTR, SETFILTERACTIVE, SETMATCHFILTER.

20.10 RECORDS

RECORDS renvoie le nombre d'enregistrements dans une table.

(RECORDS table)

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

Voir aussi RECORD, RECNUM.

20.11 RECORD

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

(RECORD table num)

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

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

Voir aussi RECORDS, RECNUM.

20.12 SELECT

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

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

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

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

Et "tablelist" est une liste de noms de table :

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

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

"orderlist" a la syntaxe suivante :

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

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

Comment ça fonctionne

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

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

Voir aussi FOR ALL.

21. Les fonctions GUI

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

21.1 SETCURSOR - Placement du curseur sur un élément graphique.
21.2 SETBGPEN - Configurer le pinceau d'arrière-plan d'un élément de l'interface.
21.3 GETWINDOWOPEN - Obtenir l'état d'une fenêtre ouverte/fermée.
21.4 SETWINDOWOPEN - Ouvrir/fermer une fenêtre.
21.5 GETVIRTUALLISTACTIVE - Obtenir la ligne active d'un champ Virtuel.
21.6 SETVIRTUALLISTACTIVE - Changer la ligne active d'un champ Virtuel.

21.1 SETCURSOR

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

(SETCURSOR attr-or-table)

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

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

Voir aussi SETVIRTUALLISTACTIVE.

21.2 SETBGPEN

SETBGPEN définit le crayon d'arrière-plan d'un élément GUI.

(SETBGPEN attr pen)

Définit le crayon pour dessiner le fond de l'objet GUI donné par "attr". Pour le crayon, une valeur entière hexadécimale contenant une couleur au format RBG (rouge, vert, bleu) ou une des constantes PEN_* peut être utilisée. Si "pen" est NIL, un fond par défaut est défini.

SETBGPEN renvoie la valeur du nouveau crayon de fond.

Exemple : "(SETBGPEN Control.Status 0xFF000000)" définit un fond rouge pour l'élément GUI de l'attribut "Status" dans la table "Table". Le même effet peut être obtenu par "(SETBGPEN Control.Status PEN_RED)".

Voir aussi 25. Constantes Prédéfinies.

21.3 GETWINDOWOPEN

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

(GETWINDOWOPEN attr-or-table)

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

Voir aussi SETWINDOWOPEN.

21.4 SETWINDOWOPEN

SETWINDOWOPEN ouvre ou ferme une fenêtre.

(SETWINDOWOPEN attr-or-table open)

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

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

Voir aussi GETWINDOWOPEN.

21.5 GETVIRTUALLISTACTIVE

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

(GETVIRTUALLISTACTIVE virtual-attr)

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

Voir aussi SETVIRTUALLISTACTIVE.

21.6 SETVIRTUALLISTACTIVE

SETVIRTUALLISTACTIVE modifie la ligne active d'un champ Virtuel utilisant une "Liste" pour son affichage.

(SETVIRTUALLISTACTIVE virtual-attr num)

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

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

Voir aussi GETVIRTUALLISTACTIVE, SETCURSOR.

22. Les fonctions projets

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

22.1 PROJECTNAME - Obtenir le nom de projet.
22.2 PREPARECHANGE - Préparer le projet à une modifiaction.
22.3 CHANGES - Obtenir le nombre de changements fait sur le projet en cours.
22.4 GETADMINMODE - Vérifier si l'on est en mode administrateur ou utilisateur.
22.5 SETADMINMODE - Basculer vers le mode administrateur ou utilisateur.
22.6 ADMINPASSWORD - Hach SHA1 du mot de passe administrateur.
22.1 PROJECTNAME

PROJECTNAME renvoie le nom de projet.

(PROJECTNAME)

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

Voir aussi CHANGES.

22.2 PREPARECHANGE

PREPARECHANGE prépare le projet for un changement.

(PREPARECHANGE)

Cette commande permet d'obtenir un verrouillage de modification sur le projet. Ceci est utile lorsque vous accédez à un projet avec plusieurs instances MUIbase pouvant fonctionner sur différents ordinateurs. Une fois qu'un verrou de changement a été obtenu, aucune autre instance de MUIbase ne peut en obtenir un avant que le verrou ne soit libéré. Le blocage de modification est libéré si le programme de projet revient sans effectuer de modification ou après la sauvegarde du projet.

PREPARECHANGE renvoie NIL en cas de succès. Si l'obtention du verrouillage de modification échoue, le programme sort avec un message d'erreur approprié.

Voir aussi CHANGES.

22.3 CHANGES

CHANGES renvoie le nombre de changements du projet en cours.

(CHANGES)

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

Voir aussi PROJECTNAME.

22.4 GETADMINMODE

GETADMINMODE indique si le projet courant est en mode administrateur ou utilisateur.

(GETADMINMODE)

Retourne TRUE si le projet courant est en mode administrateur, NIL sinon.

Voir aussi SETADMINMODE, ADMINPASSWORD, onAdminMode.

22.5 SETADMINMODE

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

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

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

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

22.6 ADMINPASSWORD

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

(ADMINPASSWORD)

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

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

23. Les fonctions système

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

23.1 EDIT - Lancer l'éditeur externe de façon synchronisé.
23.2 EDIT* - Lancer l'éditeur externe de façon asynchrone.
23.3 VIEW - Lancer la visionneuse externe de façon synchronisé.
23.4 VIEW* - Lancer la visionneuse externe de façon asynchrone.
23.5 SYSTEM - Appeler les commandes externes de façon synchronisé.
23.6 SYSTEM* - Appeler les commandes externes de façon asynchrone.
23.7 STAT - Examiner un fichier.
23.8 TACKON - Créer un chemin d'accès à partir de ses composants.
23.9 FILENAME - Obtenir le dernier composant d'un chemin d'accès.
23.10 DIRNAME - Obtenir le nom d'un répertoire à partir de son chemin d'accès.
23.11 MESSAGE - Afficher des messages à l'utilisateur.
23.12 COMPLETEMAX - Régler le nombre maximum d'étapes de progression.
23.13 COMPLETEADD - Incrémenter l'état de progression.
23.14 COMPLETE - Positionner l'état de progression de manière absolue.
23.15 GC - Forcer le passage du "ramasse-miettes".
23.16 PUBSCREEN - Nom de l'écran publique (Amiga).

23.1 EDIT

EDIT Lancement d'un éditeur externe.

(EDIT filename)

Démarre un éditeur externe pour éditer un fichier spécifié. L'éditeur externe peut être placé dans le menu" "Préférences - Configurer l'éditeur externe". 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 de retour de l'éditeur externe comme nombre entier.

Voir aussi EDIT*, VIEW, SYSTEM.

23.2 EDIT*

EDIT* est la version étoilée de EDIT et a le même effet que 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*.

23.3 VIEW

VIEW lance la visionneuse externe.

(VIEW filename)

Démarre la visionneuse externe pour afficher le fichier spécifié. La visionneuse externe peut être placée dans menu "Préférences - Configurer la visionneuse". 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.

23.4 VIEW*

VIEW* est la version étoilée de VIEW et a les mêmes effets que 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*.

23.5 SYSTEM

SYSTEM appelle un programme externe.

(SYSTEM fmt [arg ...])

Appelle un programme externe. La ligne de commande pour appeler le programme est spécifiée par "fmt" et des arguments facultatifs comme dans la fonction SPRINTF. Pour interpréter la ligne de commande, le Shell du système est utilisé. 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.

23.6 SYSTEM*

SYSTEM* est la version étoilée de SYSTEM et a les mêmes effets que 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*.

23.7 STAT

STAT examine un nom de fichier.

(STAT filename)

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

23.8 TACKON

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

(TACKON dirname [component ...])

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

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

Voir aussi FILENAME, DIRNAME.

23.9 FILENAME

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

(FILENAME path)

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

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

Voir aussi DIRNAME, TACKON.

23.10 DIRNAME

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

(DIRNAME path)

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

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

Voir aussi FILENAME, TACKON.

23.11 MESSAGE

MESSAGE affiche un message à l'utilisateur.

(MESSAGE fmt [arg ...])

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

MESSAGE renvoie le champ titre formaté.

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

Voir aussi PRINT, PRINTF.

23.12 COMPLETEMAX

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

(COMPLETEMAX steps)

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

COMPLETEMAX renvoie son argument steps.

Voir aussi COMPLETEADD, COMPLETE.

23.13 COMPLETEADD

COMPLETEADD incrémente l'état de progression.

(COMPLETEADD add)

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

COMPLETEADD renvoie son argument add.

Exemple :

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

Voir aussi COMPLETEMAX, COMPLETE.

23.14 COMPLETE

COMPLETE modifie l'état de progression.

(COMPLETE cur)

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

COMPLETE renvoie son argument cur.

Exemple :

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

Voir aussi COMPLETEMAX, COMPLETEADD.

23.15 GC

GC force le passage du "ramasse-miettes".

(GC)

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

23.16 PUBSCREEN

PUBSCREEN retourne le nom de l'écran public.

(PUBSCREEN)

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

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

24. Les variables prédéfinies

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

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

25. Les constantes prédéfinies

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

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

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

26. Paramètres fonctionnels

Vous pouvez passer une fonction comme argument à une autre fonction. C'est utile pour définir des fonctions évoluées, 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 6.6 FUNCALL).

Exemple :

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

Vous pouvez maintenant employer la fonction "map" par exemple pour incrémenter tous les articles d'une liste de nombres entiers : ""(map (LIST 1 2 3 4) 1+)" donne ( 2 3 4 5 ).

Voir aussi FUNCALL, APPLY, MAPFIRST.

27. Spécificateurs de type

Il est possible d'indiquer le type d'une variable en ajoutant un spécificateurs de type derrière son nom. Les spécificateurs de type suivants existent :
  • :INT pour les entiers.
  • :REAL pour les réels.
  • :STR pour les chaînes.
  • :MEMO pour les mémos.
  • :DATE pour les dates.
  • :TIME pour les heures.
  • :LIST pour les listes.
  • :FILE pour les descripteurs de fichier.
  • :FUNC pour les fonctions de n'importe quel type.
  • :table pour les pointeurs d'enregistrement sur table.
Un spécificateur de type s'accole au nom de variable comme dans l'exemple suivant :

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

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

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

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

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

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

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

(LET (foo:Foo))

Alors vous pourrez afficher le champ "Bar" du troisième enregistrement en utilisant :

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

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

28. Sémantique des expressions

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

(func [expr ...])

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

([expr ...])

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

Table

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

Table*

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

AttrPath

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

var

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

var.AttrPath

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

29. Déclenchement de fonctions

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.

29.1 onOpen - Déclenchement après ouverture d'un projet.
29.2 onReload - Déclenchement après le rechargement d'un projet.
29.3 onClose - Déclenchement à la fermeture d'un projet.
29.4 onAdminMode - Déclenchement à l'entrée/sortie du mode administrateur.
29.5 onChange - Déclenchement au changement de projet.
29.6 logLabel - Calcul l'entrée des nouvelles entrées du journal.
29.7 mainWindowTitle - Calcul le titre de la fenêtre principale.
29.8 Déclencheur de création - Déclencheur pour allouer un nouvel enregistrement.
29.9 Déclencheur de suppression - Déclencheur pour supprimer un enregistrement.
29.10 Fonction de comparaison - Pour comparer les enregistrements d'une table.
29.11 Déclencheur de champ - Déclenchement au changement de champs.
29.12 Champs virtuels - Comment écrire des fonctions pour les champs virtuels.
29.13 Fonction de calcul d'activation - Pour déterminer l'état d'activation d'un objet.
29.14 Calculer la description de l'enregistrement - Déclenchement pour calculer une description d'enregistrement.
29.15 Déclencheur de double-clic - Déclencheur pour les double-clics dans une liste virtuelle.
29.16 Calculer les entrées des listes - Déclencheur pour calculer les entrées des listes.
29.17 Calculer les enregistrements référencés - Déclenchement lors de l'activation d'une liste déroulante de références.

29.1 onOpen

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

Exemple :

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

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

29.2 onReload

Similaire à onOpen, MUIbase appelle la fonction onReload lors du rechargement d'un projet, par exemple en sélectionnant l'option de menu "Projet - Recharger". La fonction est appelée sans aucun argument.

Cependant, onReload n'est appelée que s'il n'y a pas de changements structurels au projet, c'est-à-dire qu'aucune table ou attribut n'a été modifié, ajouté ou supprimé, qu'aucun changement n'a été apporté au programme du projet et qu'aucun autre changement ne peut être considéré comme un changement structurel. Dans un tel cas, une recharge est considérée comme une réouverture du projet, et la fonction onOpen est appelée à la place.

Voir aussi onOpen, onClose, onAdminMode, onChange.

29.3 onClose

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

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

Exemple :

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

Voir aussi onOpen, onChange, demo "Trigger.mb".

29.4 onAdminMode

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

Exemple :

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

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

29.5 onChange

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

Exemple :

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

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

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

29.6 logLabel

Lors de la création d'une nouvelle entrée pour le journal du projet, MUIbase recherche dans le programme du projet une fonction portant le nom "logLabel". Si elle existe, il appelle cette fonction sans aucun argument. L'expression retournée est convertie en chaîne de caractères et utilisée pour le champ "_Label" de la nouvelle entrée de journal.

Exemple :

(DEFUN logLabel ()
    Control.CurrentUser.Name
)

L'exemple ci-dessus est tiré du projet "Users.mb". Ici, l'étiquette est le nom de l'utilisateur courant qui a ouvert le projet. Cela signifie que toutes les modifications apportées par l'utilisateur actuel sont étiquetées avec son nom. Ainsi, il est possible par la suite d'identifier quel utilisateur a effectué quelle modification. Voir aussi onChange, la démo "Users.mb".

29.7 mainWindowTitle

Si le programme d'un projet contient une fonction portant le nom "mainWindowTitle", le résultat de cette fonction est utilisé pour définir le titre de la fenêtre principale du projet. La fonction est appelée sans aucun argument et doit retourner une valeur de chaîne de caractères. Le titre de la fenêtre est automatiquement recalculé chaque fois qu'un attribut utilisé dans la fonction change.

Si mainWindowTitle n'existe pas, le titre de la fenêtre affiche le nom du projet.

Notez que, dans tous les cas, MUIbase précède le titre d'un caractère "*" chaque fois que le projet a des changements non enregistrés.

Voir aussi la démo "Trigger.mb".

29.8 Déclencheur de création

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

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". 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*.

Exemple de déclencheur de création :

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

Voir aussi NEW, NEW*, Déclencheur de suppression.

29.9 Déclencheur de suppression

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

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 pour supprimer l'enregistrement.

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

Exemple de déclencheur de suppression :

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

Voir aussi DELETE, DELETE*, Déclencheur de création.

29.10 Fonction de comparaison

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

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

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

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

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

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

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

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

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

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

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

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

Voir aussi Order, CMP, GETISSORTED, SETISSORTED, REORDER, REORDERALL, GETORDERSTR, SETORDERSTR, PRINT, PRINTF, la démo "Order.mb".

29.11 Déclencheur de champ

Dans la fenêtre de 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 6.5 SETQ*) pour positionner la valeur d'un champ.

Exemple de déclencheur de champ :

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

Voir aussi SETQ*.

29.12 Programmation de champs virtuels

Dans MUIbase, les champs virtuels sont des champs spéciaux qui calculent leur valeur à chaque fois que c'est nécessaire. Par exemple, si vous passez à un autre enregistrement en cliquant sur le bouton flèche dans l'onglet 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. La valeur renvoyée par ce déclencheur définit la valeur du champ virtuel. Si vous ne spécifiez aucun déclencheur de "Calcul" pour un champ virtuel, alors la valeur du champ est NIL.

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

(DEFUN buttonHook ()
    champ-virtuel
)

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

(SETQ champ-virtuel expr)

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

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

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

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

29.13 Fonction de calcul d'activation

Pour les objects champs et les boutons de fenêtre, il est possible de spécifier une fonction pour calculer l'état d'activation de l'objet.

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ée lorsqu'un champ virtuel de type "Liste" a un élément sélectionné ressemblerait à :

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

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

29.14 Calculer la description de l'enregistrement

Pour les objets de table et les objets d'attribut de référence de type, une fonction déclencheur peut être saisie pour calculer une description d'enregistrement.

La fonction de déclenchement est appelée sans aucun argument. Elle doit retourner une seule expression ou une liste d'expressions.

Par exemple, dans une table "Personne" avec les attributs "Nom" et "Anniversaire", la fonction pourrait ressembler à ceci :

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

Voir aussi Éditeur d'objets de table, Éditeur d'objets d'attribut.

29.15 Déclencheur de double-clic

Pour les champs virtuels utilisant un affichage de type "liste" pour leurs contenus, il est possible de spécifier une fonction exécutée toutes les fois que l'utilisateur double-clic sur un élément de la liste.

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

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

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

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

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

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

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

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

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

29.16 Calculer les entrées des listes

Pour les champs chaînes, l'objet graphique peut contenir une liste déroulante permetant à l'utilisateur de choisir parmi une liste de chaînes. Les entrées de cette liste peuvent être statiques ou être calculées dynamiquement par un déclencheur.

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

Par exemple la fonction de calcul pourrait ressembler à ceci :

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

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

29.17 Calculer les enregistrements référencés

Pour les champs référence, l'objet graphique possède généralement un bouton permettant d'ouvrir une liste d'enregistrements parmi lesquels l'utilisateur peut faire son choix. La liste de ces enregistrements peut être calculée par un déclencheur.

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 "Personne" avec un champ booléen "Femme". Alors la fonction de calcul suivante n'affiche que les personnes féminines dans la liste déroulante :

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

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

30. Liste des fonctions obsolètes

Les fonctions suivantes sont obsolètes depuis la version 2.7 de MUIbase.
  • GETDISABLED.
  • SETDISABLED.
  • GETWINDOWDISABLED.
  • SETWINDOWDISABLED.
Les fonctions obsolètes ne fonctionnent plus comme attendu et leur appel est soit ignoré (donnant une non-opération), soit ouvre une fenêtre d'avertissement, soit cause une erreur selon le réglage du menu "Programme - Fonctions obsolètes".

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.


[Retour en haut] / [Retour aux articles]