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, qui a été élaborée 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. Notez que les améliorations sur la norme de 1980 sont indiquées par un (LSE-2000).

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.

[modifier] Généralités

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

[modifier] Les Commentaires

[modifier] Ligne de commentaire

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

[modifier] 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 *)
(* CECI
EST
UN BLOC *)

[modifier] Chaîne de texte

Pour former une chaîne on l'écrit entre une paire d'apostrophe, par exemple : 'Ceci est une chaîne LSE'
Si votre chaine 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'

[modifier] Les nombres

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 11111111
• en hexadécimal on écrira FF

[modifier] Les angles

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

[modifier] Types et constantes

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

NOMBRE<var1>,<var2>,...

Ce type permet de déclarer une variable numérique (flottant).

QUEUE DE <type> <var1>[dim], <var2>...(LSE2000)

Ce type permet de déclarer une queue dont la longueur est définie par <dim> et composé d'éléments du type <type>.
QUEUE DE NOMBRE UNEQUEUE[5]

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]

[modifier] Qualificateurs

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

...

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

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

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.

[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 ... ALORS ... SINON ...

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

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

<valeur>← SELON <expression entière> CHOISIR <expression1>[,<expression1>,...] SINON <expression0>
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

[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, SELON-CHOISIR-SINON
   
2. /, *
   
3. +, -
   
4. =, <, <=, >, >=, #
5. ET, ET QUE
6. OU, OU QUE, NI, NI QUE, OX, !
   

[modifier] Controles

[modifier] 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 <#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> ALORS <bloc1> [ SINON <bloc2> ] FINSI

Si l'expression booléenne <expression> 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.

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

[modifier] Autres

BOUCLER (LSE2000)

Reprend la boucle courante et passe au pas suivant si c'est une boucle POUR.

BRISER (LSE2000)

Brise la boucle courante.

RESULTAT <expression>

Retourne un résultat d'une fonction.

RETOUR

Retour d'une procédure.

TERMINER

Termine le programme.

[modifier] Exceptions

A faire...

[modifier] Déclaration d'un bloc

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.

[modifier] Lancement des exceptions

LANCER exception (LSE2000)

Lance une exception.

[modifier] Procédures

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

[modifier] Invocation

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

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

[modifier] Programmation Orientée Objet

A faire...

[modifier] Programmation Orientée Aspect

A faire...

[modifier] 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 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 flottante ou entier).

E

formate un nombre avec exposant (virgule flottante 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 prochaine 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 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.

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.

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 caractè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 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 ?

[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

[modifier] Liens externes

Site Officiel de LSE2000