Programmation LSE

En travaux

Cette page est en travaux. Tant que cet avis n'aura pas disparu, veuillez en considérer le plan et le contenu encore incomplets, temporaires et sujets à caution. Si vous souhaitez participer, il vous est recommandé de consulter sa page de discussion au préalable, où des informations peuvent être données sur l'avancement des travaux.

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 : 'Ceci est une chaîne LSE'.

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 'Tableau d''entier'. Pour produire une chaîne à partir d'un code de caractère on le place entre une paire de point, par exemple .65. équivaudra à 'A'.

Les nombres

Les nombres réels peuvent être écris de deux façons essentiellement :

soit sous la forme:10.1234
soit sous la forme 1.01234E1

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 :

en décimal on écrira 255
en octal on écrira 0377
en binaire on écrira 0b11111111
en hexadécimal on écrira 0xFF

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>.
ENSEMBLE DE CHAINE UNENSEMBLE[3]← {'bleu', 'blanc', 'rouge'}

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.
FILE DE NOMBRE UNEFILE[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.
PILE DE NOMBRE UNEFILE[5]

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.
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>.
TABLEAU DE NOMBRE ESPACETEMPS[5,5,5,5]

Qualificateurs

NATUREL (LSE2000)

Ce qualificateur s'applique au type de valeur entière et force l'usage de nombre entier exclusivement positif.
ENTIER NATUREL MAVARIABLE

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.
RÉEL ÉTENDU MAVARIABLE

Types construits

TYPE <montype> EST <type>(LSE2000)

Permet de déclarer un type construit nommé <montype> comme équivalent de sa déclaration.
TYPE MONTYPE EST TABLEAU DE ENTIER NATUREL[32]

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.

Opérateur de multiplication

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

# Différent de

<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>IS
Retourne <expression1> si <expression booléenne> est VRAI et <expression2> sinon.

SELON ... CHOISIR ... SINON ...FIN

<valeur>← SELON <expression entière> CHOISIR <expression1>[,<expression2>,...] SINON <expression0>FIN
Retourne <expression1> si la valeur de <expression entière> est 0, <expression2> si elle est 1, etc. et <expression0> sinon.
MAVALEUR←SELON X CHOISIR 3.25,4.67,8,97 SINON 0.1 FIN

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

NON, DANS, ↑, SI-ALORS-SINON, SELON-CHOISIR-SINON
/, %, *
+, -
=, <, <=, >, >=, #
ET, ET QUE
OU, OU QUE, NI, NI QUE, OX, !

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 ;

SI U=V ALORS U←0;V←255; SINON U←U+1;V←V-1; FIN SI

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.

unRésultat ← &MaProcédure(unParam, etUnAutre)

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.

&MaVariableProcédure

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
FIN

* ASSIGNATION VARPROC ← PROCVAR * INVOCATION
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:

/: formate un passage au début de la ligne suivante, retour de chariot puis saut de ligne.
B: formate un entier sous une forme binaire (LSE-2000)
C: formate un retour au début de ligne, retour de chariot.
F: formate un nombre sous forme décimale (virgule flottante ou entier).
E: formate un nombre avec exposant (virgule flottante ou entier). une chaîne se formate elle même.
H: formate un entier sous forme hexadécimale (LSE-2000)
L: formate un passage à la ligne suivante.
O: formate un entier sous forme octale (LSE-2000)
U: formate une valeur quelconque.
X: formate un espace.
'..': incorpore une chaîne dans le formatage

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.

Exemple

10 FAIRE 20 POUR I<-1 JUSQUA 10
20 AFFICHER [/,*X,*'*'] I,11-I
30 TERMINER

affiche:

 **********
  *********
   ********
    *******
     ******
      *****
       ****
        ***
         **
          *

Exemple 2

A<-1;B<-2;C<-3;D<_A+B+C;AFFICHER [/,'(+ ',3U,') --> ',U] A,B,C,D

affiche:

(+ 1 2 3 ) --> 6

Exemple 3

AFFICHER [/,5X,5'Q',/,5'-*']

affiche:

     QQQQQ
-*-*-*-*-*

LIRE

LIRE() Lire depuis le terminal
LIRE...

Programmation Orientée Objet

CLASSE

Type permettant de déclarer une classe.

CLASSE maClasse
    type    identificateur
    :
    METHODE mamethode(params formels):type_de_retour LOCAL ...
FIN CLASSE

CECI

Variable réservée qui désigne l'objet courant.

+ à venir

Fonctions Standards

PS: pas encore révisé pour LSE2000
ABS() 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.

exemple

CHAINE A;A←'BONJOUR MONSIEUR, COMMENT ALLEZ VOUS?'
AFFICHER A ; AFFICHER MCH(A,9,8,'MADAME')

BONJOUR MONSIEUR, COMMENT ALLEZ VOUS?
BONJOUR MADAME, COMMENT ALLEZ VOUS?

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 chaîne1<chaîne2 ou chaîne1=chaîne2 ou chaîne1>chaîne2, 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.

Exemple

10 CHAINE CROISSANT,DECROISSANT;CROISSANT←' ';DECROISSANT←' '
20 FAIRE 24 POUR I←0 JUSQUA 255
22 CROISSANT←CROISSANT!EQC(I)
24 DECROISSANT←DECROISSANT!EQC(255-I)
30 AFFICHER ['CROISSANT: ',U,/]RCC('ABC','DEF',CROISSANT)
40 AFFICHER ['DECROISSANT: ',U,/]RCC('ABC','DEF',DECROISSANT)

Affiche:

CROISSANT: -1
DECROISSANT: 1

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 DHANOI'
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 litem 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