Programmation LSE

Un livre de Wikibooks.

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.

[modifier] 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, les améliorations sur le standard de 1980 sont indiquées. 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. LSE-2000 retient plusieurs éléments proposés par LSE-83.

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. Les exemples ont pour la plupart été testés sur l'implantation MicroLSE (LSE-80 d'où l'usage des numéros de ligne) cepandant il seront mis-à-jour lorsque j'aurrai en ma possession une version finale de PhoenixLSE (LSE-2000).

[modifier] Types et constantes

[modifier] Types

BOOLEEN<var1>,<var2>,...
Ce type permet de déclarer une variable booléenne, pouvant prendre les valeurs VRAI ou FAUX.

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>,<var2>,... (LSE2000)
Ce type permet de déclarer un ensemble composé d'éléments du type <type>.

NOMBRE<var1>,<var2>,...
Ce type permet de déclarer une variable numérique (flotant).

TABLEAU DE <type> <var1>[dim,...], <var2>...
Ce type permet de déclarer un tableau multi-dimensionné composé d'éléments du type <type>.

[modifier] Constantes

VRAI
Valeur booléenne vraie.

FAUX
Valeur booléenne fausse.

[modifier] Opérateurs et Expressions

[modifier] 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é parfois 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 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.

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

ETQUE Conjonction booléenne (LSE2000)

<booléen>←<expression-booléenne1> ETQUE <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.

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.

OUQUE Disjonction booléenne (LSE2000)

<booléen>←<expression-booléenne1> OUQUE <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.

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

[modifier] Opérateurs textuels

! Concaténation

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

[modifier] Opérateurs conditionels

SI expression ALORS expression1 SINON expression2 Conditionel

<valeur>←SI<expression booléenne> ALORS <expression1> SINON <expression2>
Retourne <expression1> si <expression booléenne> est VRAI et <expression2> sinon.

[modifier] 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'ensembles.

[modifier] Priorité des opérateurs

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

1. NON DANS ↑ SI-ALORS-SINON
   
2. ET ETQUE / *
   
3. OU OUQUE + - !
   

[modifier] Controles

[modifier] Branchement

ALLER EN <étiquette>

Continue l'exécution à la ligne spécifier par étiquette, consistait en un numéro de ligne à l'origine.

SI <expression> ALORS <bloc> [ SINON < bloc > ]

Pour mettre plusieurs instructions dans une branche, utiliser un bloc DEBUT...FIN.

Attention: Ne confondez pas l'instruciton de contrôle avec l'opérateur SI-ALORS-[SINON]. Consultez la section sur les opérateur pour de plus amples informations sur ce sujet.

[modifier] Boucles

FAIRE bloc POUR var ←expression [ PAS expression ] JUSQUA expression
FAIRE bloc POUR var ←expression [ PAS expression ] TANT QUE expression

Exécute en boucle la ou les instructions comprises dans <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 negatif) un pas de 0 provoque une boucle sans fin.
JUSQUA indique d'arrêter la boucle quand le résultat de <expression> est VRAI
TANT QUE indique d'arrêter la boucle quand le résultat de <expression> est FAUX

TANT QUE expression FAIRE bloc BOUCLER (LSE2000)

... desc. ...

FAIRE bloc BOUCLER (LSE2000)

Boucle sans fin qui peu être interrompue par un appel à FINIR

[modifier] Autres

BOUCLER (LSE2000)

Reprend la boucle courante.

FINIR (LSE2000)

Brise la boucle courante.

RESULTAT <expression>

Retourne un résultat d'une fonction.

RETOUR

Retour d'une procédure.

SUIVANT (LSE2000)

Reprend la boucle en passant au pas suivant.

TERMINER

Termine le programme.

...

[modifier] Procedures

[modifier] Programme

PROGRAMME(<liste de params> ) [: <type>] (LSE2000)
[ LOCAL <params locaux>
<variables locales>
<types locaux>
<constantes locales> ]

Cette procédure constitue le point d'entrée du programme. Elle répond au même spécification qu'une procédures ordinaire à l'exception qu'elle n'a pas d'identificateur.

[modifier] Ordinaire

PROCEDURE &<identificateur>(<liste de params> ) [: <type>]
[ LOCAL <params locaux>
<variables locales>
<types locaux>
<constantes locales> ]

Pour invoquer une procédure on précède son identificateur par & comme dans cette exemple:
unRésultat ← &MaProcédure(unParam, etUnAutre)

Un paramètre peut être passé par référence ou par valeur. La différence se fait si le paramètre formel est déclaré LOCAL ou non. Si il est déclaré local, il est alors passé par valeur autrement il est passé par référence.

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

[modifier] Fonctions Standards

ABS() Valeur absolue
<nombre> ← ABS(<expression>)

Retourne la valeur absolue de l'expression numérique «expression».

ALE() Valeur absolue
<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,...]

Affiche sur la console:

/

formate un passage au début de la ligne suivante (CR,LF).

X

formate un espace.

C

formate un retour au début de ligne, retour de chariot.

L

formate un passage à la ligne suivante.

U

formate une valeur quelconque.

F

formate un nombre sous forme décimale (virgule floatante ou entier).

E

formate un nombre avec exposant (virgule floatante ou entier). une chaîne se formate elle même.

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.

Si une étoile est donnée comme facteur de répétition, la prochaîne expression est prise comme facteur de répétition.

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

(+ 1 2 3 ) --> 6

     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 envoit un signal au système qui interromp le programme).

CCA() Conversion en chaîne
<chaîne> ← CCA( <expression-arthmetique> )
Converti l'expression arithmetique en sa representation 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 convertion 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() equivalent chaîne
<chaîne> ← EQC( <nombre> )
Retourne dans une chaîne le caractère de code ASCII indiqué par le nombre.

EQN() equivalent 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 resultant 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'exponetiel 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.

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

OUL() Ou logique
<nombre> ← OUL( <nombre> , <nombre> )
Retourne le nombre resultant 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 resultant 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 premièr 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.

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.

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 caracgtère qui n'est pas dans <chaîne2>.

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 chaine ou change celle passer ?

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

[modifier] Préprocesseur

LSE2000 intègre un préprocesseur.

[modifier] Déclaration de symboles

Déclaration de symbole de préprocesseur.

#DECLARER MONSYMBOLE

[modifier] Generation de messages

[modifier] Messages d'erreurs

Provoque une erreur à la compilation.

#ERREUR MONERREUR

[modifier] Messages d'avertissement

Provoque un avertissement à la compilation.

#AVERTISSEMENT MONAVERTISSEMENT

[modifier] Messages d'information

Affiche une information à la compilation.

#MESSAGE MONMESSAGE

[modifier] Exemples de programme