Programmation LSE

Un livre de Wikilivres.
Aller à : navigation, rechercher
link={{{link}}}
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.

Ébauche

Présentation[modifier | modifier le wikicode]

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 fonctionalité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 nombreuse formes de boucle qui s'ajoutent à la forme d'origine. L'ajout de nouveau type du genre «contenant»,soit les types ENSEMBLE et QUEUE, qui s'ajoute au seule 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 tel 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 et orienté aspect. Ainsi que diverses améliorations à la bibliothèque standard.

Enfin il faut se souvenir que LSE est insensible à la casse, ainsi PhoenixLSE, phoenixlse et pHoEnIxLsE seront reconnue comme étant la même chose. Notez également que les numéros de ligne obligatoire sous LSE-80 bien que facultative sous LSE-2000 demeurent reconnu ce qui facilite la migration d'ancien logiciel. Ils sont désormais traité comme des étiquettes lorsque des instructions mal-aimées comme ALLER EN sont utilisées.

Généralités[modifier | modifier le wikicode]

Dans cette section nous aborderons certaines généralités concernant LSE: les conventions et tout les petits détails importants.

Les Commentaires[modifier | modifier le wikicode]

Ligne de commentaire[modifier | modifier le wikicode]

Pour créer un commentaire sous LSE plusieurs options sont possible. 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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

Pour former une chaîne on l'écrit entre une paire d'apostrophe, par exemple : 'Ceci est une chaîne LSE'
Si votre chaîne contient des apostrophes il faut les doubler ainsi il ne seront pas pris comme marqueur de la fin mais bien comme caractère, par exemple on écrira 'Tableau dentier' 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[modifier | modifier le wikicode]

Les nombre réel 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 octal, 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[modifier | modifier le wikicode]

Les angles sont toujours exprimés en radian pour l'ensemble des fonctions trigonométriques de la bibliothèque standard.

Les fins de lignes[modifier | modifier le wikicode]

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 instruction 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[modifier | modifier le wikicode]

Types prédéfinis[modifier | modifier le wikicode]

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>.
FILE 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ée par un arobase (@) tandis que dans le cas d'une déclaration le nom de la procédure est précédée 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[modifier | modifier le wikicode]

AVEC SIGNE (LSE2000)

Ce qualificateur s'applique au type de valeur entière et force l'usage de nombre signé.
ENTIER AVEC SIGNE MAVARIABLE

SANS SIGNE(LSE2000)

Ce qualificateur s'applique au type de valeur entière et force l'usage de nombre non signé.
ENTIER SANS SIGNE MAVARIABLE

Types construits[modifier | modifier le wikicode]

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 SANS SIGNE[32]

Constantes[modifier | modifier le wikicode]

.VRAI.

Valeur booléenne vraie.

.FAUX.

Valeur booléenne fausse.

Opérateurs et Expressions[modifier | modifier le wikicode]

Opérateurs arithmétiques[modifier | modifier le wikicode]

← 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[modifier | modifier le wikicode]

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 inveré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[modifier | modifier le wikicode]

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

  1. 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[modifier | modifier le wikicode]

! Concaténation

<chaîne>←<chaîne1> ! <chaîne2>
Concatène les chaînes «chaîne1» et «chaîne2».

Opérateurs conditionels[modifier | modifier le wikicode]

SI ... ALORS ... SINON ... FINSI

<valeur>←SI<expression booléenne> ALORS <expression1> SINON <expression2>FINSI
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[modifier | modifier le wikicode]

! 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'ensembles.

Priorité des opérateurs[modifier | modifier le wikicode]

L'ordre le plus petit indique une priorité plus élevé.

  1. NON, DANS, ↑, SI-ALORS-SINON, SELON-CHOISIR-SINON
  2. /, %, *
  3. +, -
  4. =, <, <=, >, >=, #
  5. ET, ET QUE
  6. OU, OU QUE, NI, NI QUE, OX, !

Controles[modifier | modifier le wikicode]

Branchement[modifier | modifier le wikicode]

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 <#ligne>]

Selon la valeur de l'expression 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 ou la valeur de l'expression déborderais des choix. Si on omet cette dernière l'exécution continuera sont cour normal à la Ligne suivante.

SI <expression booléenne> ALORS <bloc1> [ SINON <bloc2> ] FINSI

Si l'expression booléenne <expression booléenne> est VRAI alors les instruction du bloc <bloc1> sont exécutées sinon ce sont celle 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 ecrire les instruction en les faisant suivre d'un séparateur ;

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

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> [[<expression2>]...] [[QUAND <expression1> [[<expression2>]...] <bloc>]...] QUAND AUTRE <bloc> FIN EVALUER

Compare la ou les expressions à la gauche de EVALUER avec celle ou celles à la gauche des QUAND et exécute le

bloc d'instruction du premier QUAND dont les expression correspondent à celles du EVALUER. Si aucune correspondance n'est trouvées alors c'est le bloc du QUAND AUTRE qui est exécuté.

EVALUER X Y
QUAND 255 255
    AFFICHER 'QUAND 255 255'
QUAND TOUS 255
    AFFICHER 'QUAND TOUS 255'
QUAND 255 TOUS
    AFFICHER 'QUAND 255 TOUS'
QUAND AUTRE
    AFFICHER 'QUAND AUTRE'
FIN EVALUER

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.

EVALUER BASEE SUR DES CONDITIONS QUI PEUVENT ETRE VRAIES OU FAUSSES : TRADUITE EN COBOL PAR EXEMPLE, PAR EVALUATE TRUE OR FALSE

EVALUER VRAI ou FAUX

    QUAND <conditions-1>

<instructions-1>

QUAND <conditions-2>

<instructions-2>


QUAND <conditions-n>

<instructions-n>

QUAND <AUTRE>

<instructions-AUTRE>

FIN EVALUER

Boucles[modifier | modifier le wikicode]

POUR varexpression1 [ PAS expression2 ] JUSQUA expression3 FAIRE bloc BOUCLER (LSE2000)
POUR varexpression1 [ 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 vrai ou qu'une instruction FINIR est rencontrer.

FAIRE bloc BOUCLER (LSE2000)

Boucle sans fin qui peu ê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 vrai ou qu'une instruction FINIR est rencontrer.

FAIRE #ligne POUR varexpression [ PAS expression ] JUSQUA expression
FAIRE #ligne POUR varexpression [ PAS expression ] TANT QUE expression

Exécute en boucle la ou les instructions qui suivent cette ligne jusqu'à la ligne pointé par étiquette #ligne inclusivement ce 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[modifier | modifier le wikicode]

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

RESULTAT <expression>

Retourne un résultat d'une fonction.

RETOUR

Retour d'une procédure.

TERMINER

Termine le programme.

Exceptions[modifier | modifier le wikicode]

A faire...

Déclaration d'un bloc[modifier | modifier le wikicode]

ESSAYER (LSE2000)

Défini le bloc associé à l'auditeur.

ERREUR (LSE2000)

Défini un auditeur pour toute les exception lancer à l'intérieur du bloc.

Lancement des exceptions[modifier | modifier le wikicode]

LANCER exception (LSE2000)

Lance une exception.

Procédures[modifier | modifier le wikicode]

Déclaration[modifier | modifier le wikicode]

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 si 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[modifier | modifier le wikicode]

Pour invoquer une procédure on précède son identificateur par & comme dans l'exemple suivant.

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

Variable[modifier | modifier le wikicode]

Comme indiqué dans le châpitre 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 un procédure se fait par le fait que le nom de la variable est précédée par un arobase (@) tandis que dans le cas d'une déclaration le nom de la procédure est précédée par une perluette (&). Lorsque l'on voudra invoquer une procédure désignée par une variable il suffira de précéder son nom par une perluette.

&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!

Programmation Orientée Objet[modifier | modifier le wikicode]

A faire...

CECI

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

Programmation Orientée Aspect[modifier | modifier le wikicode]

A faire...

Fonctions Standards[modifier | modifier le wikicode]

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 de arg, est retournée. Entre 0.0 et 1.0 si arg = 0.

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

ATG() Arc tangente
<nombre> ← ATG(<expression>)
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
<nombre> ← EQN( <chaîne> )
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.

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.

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.

LIRE() Lire depuis le terminal
LIRE...

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 passer ?

TMI() Transforme en minuscule
<chaîne> ← TMI( <chaîne> )
Transforme la chaîne en majuscule. Retourne une nouvelle chaîne ou change celle passer ?

Préprocesseur[modifier | modifier le wikicode]

LSE2000 intègre un préprocesseur.

Déclaration de symboles[modifier | modifier le wikicode]

Déclaration de symbole de préprocesseur.

#DECLARER MONSYMBOLE

Generation de messages[modifier | modifier le wikicode]

Messages d'erreurs[modifier | modifier le wikicode]

Provoque une erreur à la compilation.

#ERREUR MONERREUR

Messages d'avertissement[modifier | modifier le wikicode]

Provoque un avertissement à la compilation.

#AVERTISSEMENT MONAVERTISSEMENT

Messages d'information[modifier | modifier le wikicode]

Affiche une information à la compilation.

#MESSAGE MONMESSAGE


Exemples de programme[modifier | modifier le wikicode]

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
 *)
        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[modifier | modifier le wikicode]

Site Officiel de LSE2000