Programmation LSE
Présentation.
Le L.S.E. (Langage Symbolique d'Enseignement) a été créé par Yves Noyelle au début des années 1970 pour enseigner la programmation dans les lycées français. Entre 1968 et 1969, Monsieur Noyelle avait écrit le langage LSD (Langage Symbolique Didactique) pour les besoins de l'École supérieure d'électricité mais au cours d'un colloque tenu à Sèvres en 1970, il fut décidé d'installer quelques machines à titre expérimental dans des lycées. C'est pour ce projet que fut créé LSE, une évolution naturelle de LSD, E suivant D dans l'alphabet.
Cette documentation couvre le langage tel qu'il est défini dans sa version LSE-2000 (aussi nommé Phoenix, et parfois LSF) proposé par Luc Goulet.
Elle ne traitera pas de la proposition LSE-83 de Jacques Arsac qui était une proposition de modernisation devenue obsolète avec l'introduction de LSE-2000 qui retient plusieurs éléments proposés par LSE-83 notamment au chapitre des boucles.
LSE-2000 ajoute de nombreuses fonctionnalités à la version AFNOR et en réforme d'autre.
Notez que les améliorations sur la norme de 1980 sont indiquées par un (LSE-2000).
LSE-2000 est à son ancêtre ce que les Basics modernes sont à ceux de 1970.
Tout d'abord parmi les modifications apportées par LSE-2000 sur la norme AFNOR, il y a l'instruction SI..ALORS SINON...FINSI qui remplace l'ancienne forme.
Il y a ensuite l'ajout de nombreuses formes de boucle qui s'ajoutent à la forme d'origine.
L'ajout de nouveaux types du genre « contenant », soit les types ENSEMBLE et QUEUE, qui s'ajoutent au seul type de ce genre existant, le type TABLEAU.
La distinction entre nombre réel et entier par la séparation des types ENTIER et NOMBRE.
L'ajout de nouveaux opérateurs tels que NI, ET QUE, NI QUE, OU QUE, ainsi que des opérateurs destinés à la manipulation de nouveaux types de données comme l'opérateur DANS.
Un nouvel opérateur conditionnel SELON-CHOISIR-SINON s'ajoute au préexistant SI-ALORS-SINON.
S'ajoute également l'instruction de branchement SELON..ALLER EN..SINON EN... 
À cela s'ajoute des extensions de programmation orienté objet, ainsi que diverses améliorations à la bibliothèque standard.
Enfin il faut se souvenir que LSE est insensible à la casse, ainsi les noms PhoenixLSE, phoenixlse et pHoEnIxLsE seront reconnus comme étant la même chose.
Notez également que les numéros de ligne obligatoire sous LSE-80 bien que facultatifs sous LSE-2000 demeurent reconnus ce qui facilite la migration d'anciens logiciels.
Ils sont désormais traités comme des étiquettes lorsque des instructions mal-aimées comme ALLER EN sont utilisées.
Généralités.
Dans cette section nous aborderons certaines généralités concernant LSE: les conventions et tous les petits détails importants.
Les Commentaires.
Ligne de commentaire.
Pour créer un commentaire sous LSE plusieurs options sont possibles. Pour créer un commentaire sur une seule ligne, c'est à dire
qui se termine au retour de chariot à la fin de la ligne il faut placer un astérisque * en début de commentaire.
 * CECI EST UN COMMENTAIRE SUR UNE LIGNE
Bloc de commentaire.
Pour créer un bloc de commentaire, sur une ou plusieurs lignes, il faut faire précéder le texte du commentaire par (* tandis que
pour fermer ce bloc il faut taper *). De plus les commentaires peuvent être imbriqués.
 (* CECI
 EST
 UN BLOC *)
Chaîne de texte.
Pour former une chaîne on l'écrit entre une paire d'apostrophes, par exemple : codice_1.
Si votre chaîne contient des apostrophes, il faut les doubler ; ainsi ils ne seront pas pris comme marqueurs de la fin mais bien comme caractère, par exemple on écrira codice_2.
Pour produire une chaîne à partir d'un code de caractère on le place entre une paire de point, par exemple codice_3 équivaudra à 'A'.
Les nombres.
Les nombres réels peuvent être écris de deux façons essentiellement :
Les nombres entiers peuvent être exprimés dans différentes bases : la base binaire, la base octale, la base décimale et la base hexadécimale.
Exemples :
Les angles.
Les angles sont toujours exprimés en radian pour l'ensemble des fonctions trigonométriques de la bibliothèque standard.
Les fins de lignes.
Chaque instruction LSE doit se terminer par un saut de ligne ou par son alter ego le point-virgule. Si on veut écrire sur une même ligne plusieurs instructions on écrira entre elle des point-virgule.
Dans le cas où une expression deviendrait trop longue il est possible de l'écrire sur plusieurs lignes en inscrivant au bout de
chaque ligne un \ ce qui indiquera à LSE d'ignorer le saut de ligne.
 X←SI U # K ALORS 1.0 SINON \
 SI W = P ALORS 2.1 SINON \
 SI N-3 <= 17 ALORS 3.141592 SINON 0 FINSI \
 FINSI \
 FINSI
Types et constantes.
Types prédéfinis.
BOOLEEN<var1>,<var2>...
Ce type permet de déclarer une variable booléenne, pouvant prendre les valeurs VRAI ou FAUX.
CARACTERE<var1>,<var2>...
Ce type permet de déclarer une variable de type caractères.
CHAINE<var1>,<var2>...
Ce type permet de déclarer une chaîne de caractères.
ENTIER<var1>,<var2>...(LSE2000)
Ce type permet de déclarer une variable entière.
ENSEMBLE DE <type><var1>[dim],<var2>... (LSE2000)
Ce type permet de déclarer un ensemble composé d'éléments du type <type>.<br>codice_4
FILE DE <type> <var1>[dim], <var2>...(LSE2000)
Ce type permet de déclarer une file dont la longueur est définie par <dim> et composé d'éléments du type <type>.Une FILE est une structure de donnée du type PIPE, premier inséré, premier extrait.<br>codice_5
PILE DE <type> <var1>[dim], <var2>...(LSE2000)
Ce type permet de déclarer une pile dont la profondeur est définie par <dim> et composé d'éléments du type <type>. Une PILE esty une structure de donnée du type PIDE, premier inséré, dernier extrait.<br>codice_6
NOMBRE<var1>,<var2>...
Ce type permet de déclarer une variable numérique (flottant).C'est un autre nom pour REEL.
PROCEDURE @<identificateur>(<liste de params> ) [<type>][ LOCAL <params locaux>]...(LSE2000)
Ce type permet de déclarer une variable désignant une procédure à ne pas confondre avec une déclaration de procédure à proprement parler. La distinction se fait par le fait que le nom de la variable est précédé par un arobase (@) tandis que dans le cas d'une déclaration le nom de la procédure est précédé par une perluette (&). Pour plus d'information sur les procédures consulter le chapître Procédures.<br>PROCEDURE @VARPROC(ENTIER PARAM):NOMBRE LOCAL PARAM
REEL<var1>,<var2>...
Ce type permet de déclarer une variable numérique (flottant). C'est un autre nom pour NOMBRE.
TABLEAU DE <type> <var1>[dim...], <var2>...
Ce type permet de déclarer un tableau multi-dimensionné composé d'éléments du type <type>.<br>codice_7
Qualificateurs.
NATUREL (LSE2000)
Ce qualificateur s'applique au type de valeur entière et force l'usage de nombre entier exclusivement positif.<br>codice_8
RELATIF (LSE2000)
Ce qualificateur s'applique au type de valeur entière et force l'usage de nombre entier signé (pouvant être positif ou négatif). Par défaut les types de valeur entière sont RELATIF il est inutile d'utiliser ce qualificatif dans une déclaration. Il existe pour effectuer des conversions de type.
NB: Les anciennes dénominations AVEC et SANS SIGNE ont été remplacées par cette forme plus compacte et naturelle.
ÉTENDU (LSE2000)
Ce qualificateur s'applique aux types RÉEL et NOMBRE et force l'usage de leur forme étendu.<br>codice_9
Types construits.
TYPE <montype> EST <type>(LSE2000)
Permet de déclarer un type construit nommé <montype> comme équivalent de sa déclaration.<br>codice_10
STRUCTURE <montype> EST <declarations>FIN STRUCTURE(LSE2000)
Permet de déclarer un type structure nommé <montype> comme équivalent de sa déclaration.
 STRUCTURE "MASTRUCT" EST \
 CHAINE iChaine \
 ENTIER NATUREL iTableau[32] \
 FIN STRUCTURE
Constantes.
.E.
Constante du nombre d'Euler.
.FAUX.
Valeur booléenne fausse.
.GAMMA.
Constante d'Euler-Mascheroni.
.PHI.
Constante du nombre d'or.
.PI.
Constante de Pythagore (π).
.PUN.
Constante Pas Un Nombre.
.VRAI.
Valeur booléenne vraie.
Constante textuelle. Les # sont remplacés par le code du caractère voulu. Par exemple .32.
Opérateurs et Expressions.
Opérateurs arithmétiques.
← Opérateur d'assignation
<variable>←<expression>
Opérateur d'assignation, transfère la valeur de l'expression «expression» dans la variable «variable».
Traditionnellement le caractère «←» correspondait au code 95, sur les systèmes ne disposant pas de ce jeu de caractère, il est remplacé par <-. En Unicode on utilisera en UTF-16 $2190 ou en UTF-8 $E2 $86 $90.
+ Opérateur d'addition
<nombre>←<expression1> + <expression2>Opérateur d'addition, additionne les expressions «expression1» et «expression2». Le résultat est une valeur numérique.
- Opérateur de soustraction
<nombre>←<expression1> - <expression2>Opérateur de soustraction, Soustrait l'expression «expression2» de «expression1». Le résultat est une valeur numérique.
<nombre>←<expression1> * <expression2>Opérateur de multiplication, multiplie les expressions «expression1» et «expression2». Le résultat est une valeur numérique.
/ Opérateur de division
<nombre>←<expression1> / <expression2>Opérateur de division, Divise l'expression «expression1» par «expression2». Le résultat est une valeur numérique
% Opérateur modulo
<nombre>←<expression1> % <expression2>
Opérateur de modulo, Divise l'expression «expression1» par «expression2» et retourne le reste. Le résultat est une valeur numérique
^ Opérateur de puissance
<nombre>←<expression1> ^ <expression2>Opérateur de puissance, élève à la puissance «expression2» la valeur de l'expression «expression1». Le résultat est une valeur numérique.
Opérateurs booléens.
ET Conjonction booléenne
<booléen>←<expression-booléenne1> ET <expression-booléenne2>
Opérateur logique bit à bit, effectue la conjonction des expressions «expression1» et «expression2». Le résultat est une valeur booléenne.
ET QUE Conjonction booléenne (LSE2000)
<booléen>←<expression-booléenne1> ET QUE <expression-booléenne2>
Opérateur logique bit à bit, effectue la conjonction des expressions «expression1» et «expression2». Le résultat est une valeur booléenne. Si «expression1» est fausse «expression2» n'est pas évaluée et une valeur fausse est retournée.
NI Disjonction booléenne inverse (LSE2000)
<booléen>←<expression-booléenne1> NI <expression-booléenne2>
Opérateur booléen, effectue la disjonction inversée des expressions «expression1» et «expression2». Est équivalent à NON( exp1 OU exp2 ). Le résultat est une valeur booléenne.
NI QUE Disjonction booléenne inverse (LSE2000)
<booléen>←<expression-booléenne1> NI QUE <expression-booléenne2>
Opérateur booléen, effectue la disjonction inversée des expressions «expression1» et «expression2». Si «expression1» est vraie «expression2» n'est pas évaluée et une valeur fausse est retournée. Le résultat est une valeur booléenne.
NON Négation booléenne
<booléen>← NON <expression-booléenne>
Opérateur booléen, effectue la négation de l'expression «expression». Le résultat est une valeur booléenne.
OU Disjonction booléenne
<booléen>←<expression-booléenne1> OU <expression-booléenne2>
Opérateur booléen, effectue la disjonction des expressions «expression1» et «expression2». Le résultat est une valeur booléenne.
OU QUE Disjonction booléenne (LSE2000)
<booléen>←<expression-booléenne1> OU QUE <expression-booléenne2>
Opérateur booléen, effectue la disjonction des expressions «expression1» et «expression2». Le résultat est une valeur booléenne. Si «expression1» est vraie «expression2» n'est pas évaluée et une valeur vraie est retournée.
OX Différence symétrique booléenne
<booléen>←<expression-booléenne1> OX <expression-booléenne2>
Opérateur Ou eXclusif booléen, effectue la différence symétrique des expressions «expression1» et «expression2». Le résultat est une valeur booléenne.
Opérateurs comparatifs.
= Egalité
<booléen>←<expression1> = <expression2>Compare les expressions «expression1» et «expression2». Le si les deux expressions sont de valeur égale le résultat est une valeur booléenne VRAI autrement c'est FAUX.
< Plus Petit Que
<booléen>←<expression1> < <expression2>Compare les expressions «expression1» et «expression2». Le si la première expression a une valeur plus petite que la seconde le résultat est une valeur booléenne VRAI autrement c'est FAUX.
> Plus Grand Que
<booléen>←<expression1> > <expression2>Compare les expressions «expression1» et «expression2». Le si la première expression a une valeur plus grande que la seconde le résultat est une valeur booléenne VRAI autrement c'est FAUX.
<booléen>←<expression1> # <expression2>Compare les expressions «expression1» et «expression2». Le si les deux expressions sont de valeur différente le résultat est une valeur booléenne VRAI autrement c'est FAUX.
<= Plus Petit ou Egal
<booléen>←<expression1> <= <expression2>Compare les expressions «expression1» et «expression2». Le si la première expression a une valeur plus petite ou égale à la seconde le résultat est une valeur booléenne VRAI autrement c'est FAUX.
>= Plus Grand ou Egal
<booléen>←<expression1> >= <expression2>Compare les expressions «expression1» et «expression2». Le si la première expression a une valeur plus grande ou égale à la seconde le résultat est une valeur booléenne VRAI autrement c'est FAUX.
Opérateurs textuels.
! Concaténation
<chaîne>←<chaîne1> ! <chaîne2>Concatène les chaînes «chaîne1» et «chaîne2».
Opérateurs conditionels.
SI ... ALORS ... SINON ... IS
<valeur>←SI<expression booléenne> ALORS <expression1> SINON <expression2>ISRetourne <expression1> si <expression booléenne> est VRAI et <expression2> sinon.
SELON ... CHOISIR ... SINON ...FIN
<valeur>← SELON <expression entière> CHOISIR <expression1>[,<expression2>...] SINON <expression0>FINRetourne <expression1> si la valeur de <expression entière> est 0, <expression2> si elle est 1, etc. et <expression0> sinon.<br>codice_11
Opérateurs sur les ensembles.
! Concaténation (LSE2000)
<ensemble>←<ensemble1> ! <ensemble2>Concatène les ensembles « ensemble1» et « ensemble2».
DANS inclusion (LSE2000)
<booléen>←< élément> DANS <ensemble>Détermine si l'élément est présent dans l'ensemble.
Priorité des opérateurs.
L'ordre le plus petit indique une priorité plus élevé.
Controles.
Branchement.
ALLER EN <#ligne>
Continue l'exécution à la ligne spécifier par <#ligne>, consistait en un numéro de ligne à l'origine.
SELON <expression> ALLER EN <#ligne1>[,<#ligne2>, ...] [SINON EN <#ligne>]
Selon la valeur de l'expression l'exécution continue à la ligne spécifiée par l'une des étiquettes, consistait en un numéro de ligne à l'origine. Si la valeur de l'expression est 0 c'est la première étiquette qui est prise, si elle vaut 1 alors c'est la seconde ainsi de suite. L'instruction optionnelle SINON permet de spécifier un branchement dans le cas où la valeur de l'expression déborde des choix. Si on omet cette dernière l'exécution continuera son cours normal à la ligne suivante.
SI <expression booléenne> ALORS <bloc1> [ SINON <bloc2> ] FIN SI 
Si l'expression booléenne <expression booléenne> est VRAI alors les instructions du bloc <bloc1> sont exécutées sinon ce sont celles du bloc <bloc2> qui seront exécutées. Pour mettre plusieurs instructions dans une branche, on peut utiliser un bloc DEBUT...FIN comme jadis ou simplement écrire les instructions en les faisant suivre d'un séparateur ; codice_12
Attention : Ne confondez pas l'instruction de contrôle avec l'opérateur SI-ALORS-[SINON]. Consultez la section sur les opérateurs pour de plus amples informations sur ce sujet.
EVALUER <expression1> [QUAND <expression1> <bloc>]...] QUAND AUTRE <bloc> FIN EVALUER
Compare la ou les expressions à la droite de EVALUER avec celle ou celles à la droite des QUAND et exécute le bloc d'instruction du premier QUAND dont les expressions correspondent à celles du EVALUER. Si aucune correspondance n'est trouvée alors c'est le bloc du QUAND AUTRE qui est exécuté.
 EVALUER X
 QUAND 255
 AFFICHER 'QUAND 255 255'
 QUAND TOUS
 AFFICHER 'QUAND TOUS 255'
 QUAND 255 TOUS
 AFFICHER 'QUAND 255 TOUS'
 QUAND AUTRE
 AFFICHER 'QUAND AUTRE'
 FIN EVALUER
Pour évaluer si des conditions sont vraies ou fausses, il faut mettre en paramètre du ÉVALUER l'une des constantes booléennes (.VRAI. ou .FAUX.) ainsi les expressions des instructions QUAND seront comparées avec cette valeur. Par exemple :
 EVALUER .VRAI.
 QUAND COND0
 AFFICHER 'QUAND COND0 est vrai'
 QUAND COND1
 AFFICHER 'QUAND COND1 est vrai'
 QUAND COND2
 AFFICHER 'QUAND COND3 est vrai'
 QUAND AUTRE
 AFFICHER 'QUAND aucune des condition n"est vrai'
 FIN EVALUER
Pour évaluer l'une après l'autre si une suite de conditions sont vraies ou fausses, il faut mettre EN CHAÎNE suite au ÉVALUER. Quand une expression est vraie alors le bloc QUAND est exécuté avant d'évaluer le QUAND suivant. Par exemple :
 EVALUER EN CHAINE
 QUAND COND0
 AFFICHER 'COND0 est vrai'
 QUAND COND1
 AFFICHER 'COND1 est vrai'
 QUAND COND2
 AFFICHER 'COND2 est vrai'
 FIN EVALUER
Ce code exprimé sous la forme d'une suite de SI-ALORS correspond à la séquence d'instructions suivante :
 SI COND0 ALORS AFFICHER 'COND0 est vrai'
 SI COND1 ALORS AFFICHER 'COND1 est vrai'
 SI COND2 ALORS AFFICHER 'COND2 est vrai'
Dans le cas d'un EVALUER EN CHAINE la présence d'un QUAND AUTRE produira une erreur de syntaxe.
TOUS
Indique dans une instruction EVALUER-QUAND que l'expression correspondante du QUAND peut être n'importe quoi. Cela n'a pas d'importance pour ce cas.
Boucles.
POUR "var" ← "expression1" [ PAS "expression2" ] JUSQUA "expression3" FAIRE "bloc" BOUCLER (LSE2000)
POUR "var" ← "expression1" [ PAS "expression2" ] TANT QUE "expression3" FAIRE "bloc" BOUCLER (LSE2000)
Exécute en boucle la ou les instructions du bloc jusqu'à ce que les conditions de sortie de boucle soit atteintes.
PAS indique le pas d'incrémentation de "var" (décrémentation si négatif) un pas de 0 provoque une boucle sans fin.
JUSQUA "expression3" indique la valeur que doit atteindre "var" pour terminer la boucle
TANT QUE indique d'arrêter la boucle quand le résultat de "expression3" est FAUX
TANT QUE "expression" FAIRE "bloc" BOUCLER (LSE2000)
 Effectue les opérations comprises dans le bloc délimité par les mots-clefs FAIRE et BOUCLER tant que la valeur booléenne "expression" est vraie ou qu'une instruction FINIR est rencontrer.
FAIRE "bloc" BOUCLER (LSE2000)
Boucle sans fin qui peut être interrompue par un appel à FINIR. 
FAIRE "bloc" TANT QUE 'expression" (LSE2000)
Effectue les opérations comprises dans le bloc délimité par les mots-clefs FAIRE et TANT QUE tant que la valeur booléenne "expression" est vraie ou qu'une instruction FINIR est rencontrée.
FAIRE "#ligne" POUR "var" ←"expression" [ PAS "expression" ] JUSQUA "expression"FAIRE "#ligne" POUR "var" ←"expression" [ PAS "expression" ] TANT QUE "expression" 
Exécute en boucle la ou les instructions qui suivent cette ligne jusqu'à la ligne pointée par étiquette #ligne inclusivement, jusqu'à ce que les conditions de sortie de boucle soit atteintes. Cette boucle est là pour simplifier le portage du code ancien, il est préférable de l'éviter pour du nouveau code.
PAS indique le pas d'incrémentation de "var" (décrémentation si négatif) un pas de 0 provoque une boucle sans fin.
JUSQUA "expression3" indique la valeur que doit atteindre "var" pour terminer la boucle
TANT QUE indique d'arrêter la boucle quand le résultat de <expression> est FAUX
Autres.
BOUCLER (LSE2000)
Reprend la boucle courante et passe au pas suivant si c'est une boucle POUR.
BRISER (LSE2000)
Brise la boucle courante.
BRISER QUAND <expression booléenne>(LSE2000)
Brise la boucle courante si l'expression <expression booléenne> est vraie.
RESULTAT <expression>
Retourne un résultat d'une fonction.
RETOUR
Retour d'une procédure.
TERMINER
Termine le programme.
Exceptions.
À faire...
Déclaration d'un bloc.
ESSAYER (LSE2000)
Défini le bloc associé à l'auditeur.
ERREUR (LSE2000)
Défini un auditeur pour toutes les exceptions lancées à l'intérieur du bloc.
Lancement des exceptions.
LANCER "exception" (LSE2000)
Lance une exception.
Procédures.
Déclaration.
PROCEDURE &<identificateur>(<liste de params> ) [<type>][ LOCAL <params locaux>] (LSE2000)
Un paramètre peut être passé par référence, par valeur ou par descripteur. Le paramètre formel est passé par valeur s'il figure dans la liste suivant le mot-clef LOCAL comme dans les versions précédentes de LSE. Mais il est aussi possible de déclarer un paramètre comme local en lui ajoutant # en préfixe. Sinon par défaut les paramètres sont passés par référence.
On sort d'une procédure en invoquant RETOUR ou encore RESULTAT si cette dernière doit retourner une valeur. La valeur de retour est établie selon la syntaxe: RESULTAT <expression>. Le type de la valeur de retour est spécifié à la suite des paramètres dans la déclaration de la procédure.
 PROCEDURE &sontEgaux(ENTIER A, ENTIER B, ENTIER C) BOOLEEN LOCAL A,B
 C←A-B
 RESULTAT A=B
 FIN
Ou en utilisant la notation # pour les paramêtres locaux (LSE2000)
 PROCEDURE &sontEgaux(ENTIER #A, ENTIER #B, ENTIER C) BOOLEEN
 C←A-B
 RESULTAT A=B
 FIN
Invocation.
Pour invoquer une procédure on précède son identificateur par & comme dans l'exemple suivant.
codice_13
Variable.
Comme indiqué dans le chapitre sur les types il existe une type PROCEDURE qui permet de déclarer une variable désignant une procédure. Ce qui permet par exemple, de passer une procédure en paramètre à une autre, par exemple si nous avons la procédure &TRI_PYRAMIDALE on peut lui passer une procédure de comparaison en paramètre ce qui lui permettra de trier n'importe quoi.
La distinction entre une variable et une procédure se fait par le fait que le nom de la variable est précédé par un arobase (@) tandis que dans le cas d'une déclaration le nom de la procédure est précédé par une esperluette (&). Lorsque l'on voudra invoquer une procédure désignée par une variable il suffira de précéder son nom par une esperluette.
codice_14
Voici un exemple d'utilisation d'une variable de type PROCEDURE :
 * DECLARATION VARIABLE ET PROCEDURE
 PROCEDURE @VARPROC(ENTIER PARAM):NOMBRE LOCAL PARAM
 PROCEDURE &PROCVAR(ENTIER PARAM):NOMBRE LOCAL PARAM
 RESULTAT .PI. * PARAM<br>FIN<br><br>* ASSIGNATION
 VARPROC ← PROCVAR
 * INVOCATION<br>AFFICHER[/,'APPEL PAR LA VARIABLE TYPE PROCEDURE',/]
 AFFICHER[4X,'RESULTAT = ',U,/] &VARPROC( 255 )
/!\ Attention il faut préalablement assigner la variable avant d'invoquer celle-ci !
Fonctions intégrées.
AFFICHER.
AFFICHER() Afficher sur la console.
AFFICHER [ <spécification de format>... ] <valeur> [expression...]
Liste des formats possibles:
Si un facteur de répétition numérique est donné, l'effet obtenu est le même que si la spécification de format qui suit avait été répétée autant de fois. Le facteur de répétition se pause avant le format. Par exemple «afficher [3/] » ici le facteur de répétition 3 indique d'il faut sauter trois lignes.
Si une étoile (*) est donnée comme facteur de répétition, la prochaine expression est prise comme facteur de répétition.
LIRE.
LIRE() Lire depuis le terminalLIRE...
Programmation Orientée Objet.
CLASSE
Type permettant de déclarer une classe.
CECI
Variable réservée qui désigne l'objet courant.
+ à venir
Fonctions Standards.
PS: pas encore révisé pour LSE2000ABS() Valeur absolue<nombre> ← ABS(<expression>)
Retourne la valeur absolue de l'expression numérique «expression».
ALE() Valeur aléatoire<nombre> ← ALE(<nombre>)
Retourne une valeur une valeur « pseudo-aléatoire », dépendante du paramètre, est retournée. Entre 0.0 et 1.0 si arg = 0.
ALEE() Valeur aléatoire entière (LSE2000)<entier> ← ALE(<entier>)
Retourne une valeur une valeur « pseudo-aléatoire », dépendante du paramètre, est retournée. Entre 0 et 2^32 si arg = 0.
AROND() Valeur arrondie (LSE2000)<nombre> ← ATG(<nombre>)Retourne la valeur arrondie d'un nombre.
ATG() Arc tangente<nombre> ← ATG(<nombre>)Retourne la valeur de l'arc tangente de l'expression numérique « expression ».
ATT() Attention<nombre> ← ATT()Retourne normalement 0. Quand l'utilisateur tape Ctrl-A, ATT() retourne 1 (une fois), puis de nouveau 0, jusqu'à ce que l'utilisateur tape de nouveau Ctrl-A. Ça permet d'envoyer un signal traitable par le programme. (ESCape envoie un signal au système qui interrompt le programme).
CCA() Conversion en chaîne<chaîne> ← CCA( <expression-arithmétique> )Converti l'expression arithmétique en sa représentation textuelle.
CNB() Conversion en nombre<nombre> ← CNB( <expression-chaîne>, <debut> [, <fin>] )Converti la sous-chaîne délimitée par et en nombre. Si le paramètre est omis la conversion se fait jusqu'à la fin de la chaîne.
COS() Cosinus<nombre> ← COS(<expression>)Retourne la valeur du cosinus de l'expression numérique «expression».
DAT() Date<chaîne> ← DAT()Retourne la date courante sous la forme "JJ/MM/AA HH:MM:SS".
DIS() secteur disque<chaîne> ← DIS( <nombre> )Retourne le contenu d'un secteur du disque dur sous forme d'une chaîne de 256 caractères.
ENT() partie entière<nombre> ← ENT( <nombre> )Retourne la partie entière du nombre.
EQC() équivalent chaîne<chaîne> ← EQC( <nombre> )Retourne dans une chaîne le caractère de code ASCII indiqué par le nombre.
EQN() équivalent nombre<entier> ← EQN( <chaîne>,[<entier>] )Retourne le code ASCII du premier caractère de la chaîne.
ETL() Et logique<nombre> ← ETL( <nombre> , <nombre> )Retourne le nombre résultant du ET logique, bit à bit des deux nombres. ETL(10,7)=2 car 01010 ETL 00111 = 00010
EXP() valeur de l'exponentielle<nombre> ← EXP( <nombre> )Retourne la valeur de l'exponentiel du <nombre> soit, e à la puissance <nombre>.
EXP2() valeur de l'exponentielle(LSE2000)<nombre> ← EXP( <nombre> )Retourne la valeur de l'exponentiel base 2 du <nombre> soit, 2 à la puissance <nombre>.
GRL() Groupe de lettres<chaîne> ← GRL( <chaîne> , <nombre> [ , <variable> ] )Extrait de la chaîne commençant à la position indiquée une sous-chaîne composée uniquement de lettres. Si une variable est donnée, elle sera affectée par la position du premier caractère qui n'est pas une lettre, ou la longueur de la sous-chaîne plus un.
ICH() Inverser chaîne<chaîne> ← ICH( <chaîne> )Inverse l'ordre des caractères dans la chaîne.
LG2() Logarithme base 2(LSE2000)<nombre> ← LG2( <nombre> )Retourne le logarithme base 2 du nombre.
LGN() Logarithme népérien<nombre> ← LGN( <nombre> )Retourne le logarithme Népérien du nombre.
LGR() Longueur de la chaîne<nombre> ← LGR( <chaîne> )Retourne la longueur de la chaîne.
MCH() Modifier chaîne<chaîne> ← MCH( <chaîne>, <nombre>, <nombre>,<chaîne> )Retourne une nouvelle <chaîne>, en remplaçant la sous-chaîne commençant à la position indiquée par <nombre> et finissant à la position indiquée par l'<expression>, qui peut être un nombre, ou une chaîne auquel cas la position de fin est le premier caractère de <chaîne> qui est dans l'<expression>. Si une <variable> est donnée, la position de fin lui est assignée.
OUL() Ou logique<nombre> ← OUL( <nombre> , <nombre> )Retourne le nombre résultant du OU logique, bit à bit des deux nombres. 
OUL(10,7)=15 car 01010 OUL 00111 = 01111
OXL() Ou exclusif logique<nombre> ← OXL( <nombre> , <nombre> )Retourne le nombre résultant du OU EXCLUSIF logique, bit à bit des deux nombres. OXL(10,7)=13 car 01010 OXL 00111 = 01101
POS() Position<nombre> ← POS( <chaîne1> , <nombre> , <chaîne2> )Retourne la position de la sous-chaîne <chaîne2< dans la <chaîne1< en commençant à partir de la position indiquée. La première position dans une chaîne est 1.
PTR() Pointeur<nombre> ← PTR( <chaîne> , <nombre> [ , <expression> ] )Si l'expression optionnelle n'est pas donnée, alors PTR(<chaîne>,<nombre>) retourne la valeur assignée au paramètre variable dans GRL : la position du premier caractère non alphabétique après la position indiquée dans la chaîne. Si l'expression optionnelle est donnée, PTR retourne la valeur assignée au paramètre variable dans SCH : la position du première caractère suivant la sous-chaîne extraite par SCH(<chaîne>,<nombre>,<expression>).
RAC() Racine carrée<nombre> ← RAC( <nombre> )Retourne la racine carrée du nombre.
RCC() Relation comparative chaînes<nombre> ← RCC( <chaîne1>,<chaîne2> [,<chaîne3>] )Avec 2 arguments, compare deux chaînes et retourne -1,0,+1 selon que codice_15 ou codice_16 ou codice_17, respectivement. Avec 3 arguments, le troisième argument donne l'ordre lexicographique que l'on veut. <chaîne3> doit être une chaîne de 256 caractères.
REP() Répeter la chaîne<chaîne> ← REP( <chaîne>,<nombre> )Retourne une chaîne formée de la répétition <nombre> fois de la <chaîne>. REP('X',3) --> 'XXX'
SCH() Sous-chaîne<chaîne> ← SCH( <chaîne> , <nombre> , <expression> [ , <variable> ] )Retourne une sous-chaîne de la <chaîne>, commençant à la position indiquée par <nombre> et finissant à la position indiquée par l'<expression>, qui peut être un nombre, ou une chaîne auquel cas la position de fin est le premier caractère de <chaîne> qui est dans l'<expression>. Si une <variable> est donnée, la position de fin lui est assignée.
SIN() Sinus<nombre> ← SIN( <nombre> )Retourne la valeur du sinus du nombre passé en paramètre.
SKP() Saut<nombre> ← SKP( <chaîne1> , <nombre> [ , <chaîne2> ] )Si <chaîne2> n'est pas donnée, alors retourne la position dans <chaîne1> de la première lettre après la position indiquée, sinon retourne la position dans <chaîne1> du premier caractère qui n'est pas dans <chaîne2>.
TAN() Transforme en majuscule<nombre> ← TAN( <nombre> )Retourne la valeur de la tangente du nombre passé en paramètre.
TEM() Temps<nombre> ← TEM()Retourne le nombre de secondes écoulées depuis le début du jour (00:00:00).
TMA() Transforme en majuscule<chaîne> ← TMA( <chaîne> )Transforme la chaîne en majuscule. Retourne une nouvelle chaîne ou change celle passée ?
TMI() Transforme en minuscule<chaîne> ← TMI( <chaîne> )Transforme la chaîne en majuscule. Retourne une nouvelle chaîne ou change celle passée ?
Préprocesseur.
LSE2000 intègre un préprocesseur.
Déclaration de symboles.
Déclaration de symbole de préprocesseur.
 #DECLARER "MONSYMBOLE"
Generation de messages.
Messages d'erreurs.
Provoque une erreur à la compilation.
 #ERREUR "MONERREUR"
Messages d'avertissement.
Provoque un avertissement à la compilation.
 #AVERTISSEMENT "MONAVERTISSEMENT"
Messages d'information.
Affiche une information à la compilation.
 #MESSAGE "MONMESSAGE"
Exemples de programme.
Un simple programme de tour d'Hanoi en LSE (LSE2000). 
 ** TOURS D'HANOI
 PROCEDURE &HANOI(ENTIER N, ENTIER SRC, ENTIER DST, ENTIER TMP) LOCAL N,SRC,DST,TMP
 SI N=0 ALORS RETOUR FINSI
 &HANOI(N-1,SRC,TMP,DST)
 AFFICHER['PORTER ',U,' SUR ',U,/] SRC,DST
 &HANOI(N-1,TMP,DST,SRC)
 FIN
 AFFICHER[U,/] 'TOURS D"HANOI'
 ENTIER Nbr
 AFFICHER[U,X] 'Nombre de disque:';LIRE Nbr
 &HANOI(Nbr,0,1,2)
 AFFICHER[U,/] 'fin'
Un simple programme de menu en LSE (LSE2000)
 ** UN SIMPLE MENU A L'ANCIENNE
 ** UTILISANT L'INSTRUCTION SELON-ALLER EN-SINON EN
 ENTIER X
 0 AFFICHER [U,/] 'Entrez le numero de l"item voulu'
 AFFICHER [U,/] '0 Choix 0'
 AFFICHER [U,/] '1 Choix 1'
 AFFICHER [U,/] '2 Choix 2'
 LIRE X
 SELON X ALLER EN 1,2,3 SINON EN 0
 1 AFFICHER [U,/] 'Vous avez choisi 0!'
 TERMINER
 2 AFFICHER [U,/] 'Vous avez choisi 1!'
 TERMINER
 3 AFFICHER [U,/] 'Vous avez choisi 2!'
Liens externes.
Site Officiel de LSE2000