SYNTAXE DU PSEUDO-LANGAGE SYNTAXE DU PSEUDO-LANGAGELe terme identificateur couvre l'ensemble des éléments définis par le programmeur : type non standard, constante, variable, champ d'enregistrement, nom de programme, de procédure ou de fonction, paramètre formel, …
Sous réserve de respecter les règles suivantes, un identificateur peut être choisi librement en dehors des mots réservés du langage (bulles à fond jaune des diagrammes syntaxiques suivants) et des noms de ressources prédéfinies.
Note importante : Certains identificateurs qui ne sont pas réservés en Pseudo-Langage peuvent cependant l'être dans le langage Pascal utilisé en arrière-plan par Monia-PL. En cas d'erreur de compilation à priori difficilement compréhensible, il suffit parfois de changer l'intitulé d'un identificateur pour résoudre le problème…
[ Sommaire ]
|
Le type caractérise la taille mémoire d'une donnée (son encombrement) et le jeu de valeurs qu'elle peut prendre. Les types de base reconnus sont les suivants :
Booléen : type logique ne pouvant prendre que les valeurs VRAI ou FAUXOctet : valeur entière non signée sur 8 bits (0 .. 255)Caractère : valeur entière non signée sur 8 bits destinée au codage des symboles ASCIIEntier : valeur entière signée sur 16 bits (-32768 .. +32767)Entier court : valeur entière signée sur 8 bits (-128 .. +127)Entier long : valeur entière signée sur 32 bits (-2147483648 .. +2147483647)Mot : valeur entière non signée sur 16 bits (0 .. 65535)Mot long : valeur entière non signée sur 32 bits (0 .. 4294967295)Réel : valeur réelle simple précision (codage IEEE sur 32 bits)Réel double : valeur réelle double précision (codage IEEE sur 64 bits)Pointeur : adresse d'une donnée d'un type définiIl n'y a pas de distinction majuscules / minuscules pour ces types de base, les accents sont acceptés mais ignorés, la mise au pluriel est autorisée.
Voir aussi : types dérivés - types utilisateurs - [ Sommaire ]
|
L'identificateur d'une variable caractérise un emplacement mémoire permettant de stocker une donnée du type indiqué. La déclaration de variable correspond à la réservation de cet emplacement dans un des espaces de mémoire du programme.
Exemples :
VARIABLES Indice est un entier ;
x,y sont des réels doubles ;
Moyenne : réel ;
Voir aussi : identificateur - type - [ Sommaire ]
|
Les constantes permettent d'améliorer la lisibilité des programmes en favorisant l'écriture de mnémoniques adaptés en lieu et place de valeurs. Un identificateur de constante est à considérer comme une image de remplacement de sa valeur, ce n'est donc en aucun cas utilisable en écriture car une déclaration de constante n'entraîne aucune réservation de mémoire...
Par convention, les constantes sont écrites en lettres majuscules pour les distinguer des variables.
Exemples :
CONSTANTES VALMAX = 200 ;
TVA = 19.6 ;
Les constantes typées sont assimilables à des variables initialisées (soit la déclaration de la variable suivie de l'affectation d'une valeur). Elles se comportent ensuite comme des variables, leur valeur est donc modifiable.
Exemples :
CONSTANTES Compteur est un entier = 0 ;
Fin : booléen = FAUX ;
Voir aussi : identificateur - type
Les règles syntaxiques ci-dessous montrent comment définir des constantes pour les types de données standards :
[<signe>]<chiffre(s)0..9>$<chiffre(s)0..9|lettres(s)A..F>%<chiffre(s)0|1>[<signe>]<chiffre(s)0..9>[.<chiffre(s)0..9>][E|e[<signe>]<chiffre(s)0..9>]'<caractère_imprimable>'"<caractère(s)_imprimable(s)>"Exemples :
163 -12 1024
$13 $A001 $FFF400
%11 %01000001
1.618 -0.125 1.2e-4
'A' 'm' ' ' '='
"Monia" "Hello World !"
Quelques constantes standards sont disponibles sans qu'il soit nécessaire de les redéfinir dans les programmes :
VRAI # valeur 1 du type booléen
FAUX # valeur 0 du type booléen
CRLF # paire de caractères $0D (retour chariot) et $0A (saut de ligne)
TAB # caractère de tabulation horizontale $09
ModeLecture # mode d'ouverture/création d'un fichier en lecture seule ( cf. Créer/Ouvrir() )
ModeEcriture # mode d'ouverture/création d'un fichier en écriture seule
ModeLectureEcriture # mode d'ouverture/création d'un fichier avec accès complet
OrigineDébut # positionnement par rapport au début d'un fichier ( cf. Accéder() )
OrigineFin # positionnement par rapport à la fin d'un fichier
NULL # valeur particulière d'un pointeur ne pointant sur rien...
[ Sommaire ]
Les types dérivés sont des types de données définis suivant les besoins de programmation afin de modéliser des éléments plus ou moins complexes d'une application. Ils sont construits à partir des types de base ou d'autres types dérivés déjà déclarés.
Les alias sont de simples synonymes de types destinés à favoriser la lisibilité des programmes. Monia-PL (version 0.9 ou sup.) reconnaît les alias suivants, au singulier comme au pluriel :
pCaractère(s) # Pointeur de Caractère
pEntier(s) # Pointeur d'Entier
Fichier(s) # descripteur de fichier
|
Un tableau est une suite linéaire d'éléments de même type. Le nombre d'éléments est spécifié par un nombre fini, sous forme d'un intervalle (par mesure de compatibilité avec la réalité mémoire et les autres langages comme le C, il est conseillé d'utiliser un indice de début égal à 0).
Dans le cas d'un tableau à plusieurs dimensions, les indications de dimension sont séparées par une virgule. Il n'y a pas de limite théorique quant au nombre de dimensions…
Le nom d'un tableau (identificateur de la variable de type tableau) représente l'adresse de base du tableau, il est donc à considérer comme un pointeur typé sur le premier élément du tableau.
Voir aussi : type
|
Une énumération est un ensemble fini de valeurs définies sous forme de mnémoniques (par convention en majuscules). En réalité, il s'agit d'un ensemble ordonné d'entiers positifs dont le premier vaut 0.
|
A partir de la version 0.9, une chaîne est un tableau de caractères dont le premier indice est toujours égal à 0 (dans les versions précédentes, il était égal à 1 et l'octet situé à l'indice 0 était utilisé pour coder la longueur de la chaîne, avec une limite de taille égale à 255 caractères).
Le nombre N de caractères est spécifié sous forme d'une constante entière, il définit donc un intervalle d'indices allant de 0 à N-1. Si ce nombre est omis, la taille du tableau est arbitrairement fixée à 256.
chaine[ N ] équivalent à tableau[0..(N)-1] de Caractères
chaine équivalent à tableau[0..255] de Caractères
Attention : le cas échéant, il ne faut jamais d'espace entre le mot réservé Chaine et le crochet ouvrant...
Note : A partir de la version 0.9, par mesure de compatibilité avec les autres langages comme le C, Monia-PL considère une chaine comme une suite linéaire de caractères commençant à un emplacement mémoire donné par le nom de la chaine ou par un élément de type pCaractère, et se terminant par un caractère nul (octet de valeur 0).
|
L'enregistrement (ou structure de données) permet de regrouper sous forme d'une entité unique des champs de types différents.
Voir aussi : identificateur - type
Exemples de types dérivés :
tableau[0..7] d'octets
tableau[1..9,1..9] d'entiers
( ROUGE, VERT, BLEU )
enregistrement
nom : chaîne[30] ;
prénom : chaîne[30] ;
âge : octet ;
fin
[ Sommaire ]
|
La mise en place de types utilisateurs améliore la lisibilité des programmes en permettant de nommer une catégorie d'éléments avec un nom explicite relatif au besoin. Un type utilisateur est matérialisé par un identifiant utilisable comme alias d'un type existant, qu'il soit de base ou dérivé.
Voir aussi : identificateur - type
Exemples :
TYPES COORD = réel ;
POINT = enregistrement
x, y : COORD ;
fin
CERCLE = enregistrement
centre : POINT ;
rayon : COORD ;
fin
TYPES JOUR = ( LUN, MAR, MER, JEU, VEN, SAM, DIM ) ;
HEURE = enregistrement
hh, mm : entiers ;
fin
RDV = enregistrement
qui : chaîne[80] ;
quand : HEURE ;
fin
SEMAINE = tableau[JOUR,1..10] de RDV ; # max. 10 rdv par jour
AGENDA = tableau[52] de SEMAINE ; # toute l'année...
[ Sommaire ]
|
Un programme est constitué d'un en-tête, de déclarations globales puis de blocs de sous-programmes. L'ordre des blocs n'a pas d'importance à condition de respecter les règles de visibilité (tout ce qui est invoqué doit être défini au préalable).
Le programme principal est toujours placé à la fin.
Note importante : À partir de la version 0.9, le mot clé DEBUT doit être remplacé par
DEBUTPROG afin d'autoriser les mécanismes de redirection sur la ligne de commandes et l'affichage correct des caractères spéciaux
comme les tabulations… Sous Windows, ce nouveau marqueur de début de programme est cependant incompatible avec les ressources de
gestion du terminal (positionnement absolu du curseur, couleurs d'affichage,...) ; pour utiliser ces dernières, il faut conserver le
marqueur DEBUT.
Voir aussi : déclaration de variables - procédure - fonction - instruction
Le caractère # permet de marquer le début d'un commentaire. Il peut être placé à un endroit quelconque de la
ligne et le texte situé entre ce marqueur et la fin de la ligne est ainsi considéré comme commentaire.
Les accolades { } peuvent aussi être utilisées pour délimiter un commentaire sur plusieurs lignes.
|
L'en-tête d'un programme est constitué principalement du nom de celui-ci.
Les standards de codage imposent cependant la mise en place d'un cartouche d'identification regroupant des informations telles que le nom du fichier source, une description du programme, l'auteur, la date de création, la dernière date de mise à jour,…
Attention : le point-virgule qui suit l'identificateur du programme doit être impérativement le premier point-virgule rencontré dans le fichier ! La rédaction du cartouche est libre mais ne doit donc en contenir aucun…
Exemple minimal :
# ----------------------------------------------------------------
# Nom : <nom_fichier_source>
# Sujet : <description_succincte>
# Version : <version>
#
# Auteur : <nom_prénom>
# Création : <jj/mm/aaaa>
# Màj : <jj/mm/aaaa>
# ----------------------------------------------------------------
Voir aussi : identificateur
|
Le découpage d'une application en blocs assure une optimisation de la taille de celle-ci (ré-utilisabilité du code) et une meilleure lisibilité (chaque bloc assurant une tâche fonctionnelle bien délimitée). La mise au point des programmes est aussi facilitée car chaque bloc peut être validé séparément avant d'être exploité dans les applications.
Il convient de documenter chaque bloc en faisant précéder sa déclaration d'une information de la forme (exemple minimal) :
# ----------------------------------------------------------------
# <identificateur_bloc>
# <rôle>
# ----------------------------------------------------------------
# <description_arguments>
# ----------------------------------------------------------------
Voir aussi : procédure - fonction - déclaration de variables - instruction
|
La déclaration d'un bloc procédure est constituée de son identificateur et d'une éventuelle liste d'arguments.
Un appel de procédure est utilisé en tant qu'instruction et produit une délégation ponctuelle du traitement séquentiel du programme.
Voir aussi : identificateur - liste d'arguments
|
La déclaration d'un bloc fonction est constituée de son identificateur, d'une éventuelle liste d'arguments et du type de la fonction. Le type de la fonction correspond au type de retour de celle-ci.
L'appel d'une fonction entraîne le même processus de délégation qu'avec une procédure mais s'utilise cette fois dans une expression. L'appel à la fonction représente ainsi la valeur calculée et retournée par celle-ci, cette valeur étant du type spécifié.
Dans le code de la fonction, la spécification de la valeur à renvoyer se fait par une expression de la forme :
<identificateur> <- <expression> ;
ou <identificateur> est le nom de la fonction et <expression> une expression compatible avec le type de retour de la fonction.
Voir aussi : identificateur - expression - liste d'arguments - type
Pour qu'un programme soit compilable et donne lieu à la fabrication d'un exécutable, toute entité rencontrée par le compilateur doit être déclarée au préalable ceci est aussi valable pour les sous-programmes (procédures et fonctions).
En pratique, le corps d'un sous-programme doit donc précéder son appel. Une autre solution permettant de s'affranchir de l'ordre
des blocs consiste à placer en tête de programme, avant tout développement de code, et pour chaque sous-programme,
un ligne de déclaration terminée par le mot clé Prototype.
Syntaxe :
Procédure <identificateur>[(<liste_d'arguments>)] ; Prototype ;
Fonction <identificateur>[(<liste_d'arguments>)] : <type_de_retour> ; Prototype ;
|
Une liste d'arguments est placée à la suite de l'identificateur du bloc procédure ou fonction. Elle spécifie le modèle d'utilisation du bloc sous forme d'une liste de paramètres formels typés. Chaque argument peut être transmis par valeur (cas général) ou par adresse. Pour mémoire, un passage par adresse implique que la valeur de la variable transmise lors de l'appel du bloc est modifiable par celui-ci.
Voir aussi : identificateur - type - [ Sommaire ]
|
Un bloc d'instructions est un enchaînement constitué d'affectations de variables, d'appels de procédures et de structures fondamentales. Une affectation avec pour valeur de gauche l'identificateur d'une fonction est utilisée dans celle-ci pour fabriquer sa valeur de retour.
Voir aussi : variable - expression - fonction - procédure - structures fondamentales - [ Sommaire ]
|
Une condition est une expression simple ou composée évaluable de manière booléenne.
Voir aussi : expression - opérateurs - [ Sommaire ]
|
Une expression est une construction assemblée au moyen d'opérateurs dont l'évaluation de proche en proche vaut une valeur du type de la construction. Le mécanisme de transtypage permet de forcer l'évaluation d'une expression dans un type différent de celui d'origine.
Voir aussi : variable - type - constante - fonction - opérateurs - [ Sommaire ]
|
Le terme variable couvre ici toute construction représentative d'un emplacement mémoire, que ce soit le contenu ou l'adresse de celui-ci. Ces constructions sont utilisables dans les expressions.
L'adresse d'une donnée est décidée lors de sa création, elle n'est pas modifiable. Une construction de type adresse n'est donc pas exploitable en tant que valeur de gauche dans une instruction.
Voir aussi : identificateur - expression - [ Sommaire ]
Les opérateurs . et -> (ou ^.) d'accès aux membres de types dérivés (tableaux, enregistrements) sont toujours évalués les
premiers, tandis que l'opérateur d'affectation <- est traité en dernier dans une instruction. Les opérateurs de calcul sont répartis
en 4 groupes de priorité, de la plus forte à la plus faible :
@ , ^ , NON , NONb
* , / , DIV , MOD , ET , ETb , << , >>
+ , - , OU , OUb , OUEX , OUEXb
= , <> , < , > , <= , >=
Dans une expression, les parenthèses ( ) peuvent naturellement être utilisées pour modifier cet ordre de priorité.
Attention : Pour être reconnus, les opérateurs autres que ceux marqués par [*] doivent impérativement être encadrés par des espaces, ils ne doivent pas être collés aux opérandes... Ceci concerne aussi l'opérateur d'affectation.
+ addition [*]
- soustraction / changement de signe [*]
* multiplication [*]
/ division réelle [*]
DIV division entière
MOD reste de la division entière (modulo)
NONb négation binaire
ETb ET binaire
OUb OU binaire
OUEXb OU Exclusif binaire
<< décalage à gauche
>> décalage à droite
<- affectation
@ adresse de (préfixe) [*]
^ contenu de (suffixe) [*]
[] accès à un élément de tableau [*]
. accès au champ d'un enregistrement [*]
^. accès au champ d'un enregistrement pointé [*]
-> autre écriture de ^. [*]
= équivalent à [*]
<> différent de [*]
< inférieur à [*]
> supérieur à [*]
<= inférieur ou égal à [*]
>= supérieur ou égal à [*]
NON négation logique
ET ET logique
OU OU logique
OUEX OU Exclusif logique
+ concaténation [*]
Note : Les opérateurs relationnels permettent aussi de comparer alphabétiquement des chaînes de caractères.
Attention : par mesure de compatibilité avec les autres langages comme le C, l'usage direct des opérateurs sur les chaînes est déconseillé. A partir de la version 0.9, Monia-PL offre les ressources équivalentes sous forme de fonctions...
[ Sommaire ]
Les structures nécessaires et suffisantes en programmation structurée sont l'enchaînement, l'alternative, partielle ou complète, et les itérations.
La boucle est une écriture simplifiée d'une itération à condition initiale utilisée lorsque le nombre de fois à traiter les instructions est prédéfini. La structure de choix multiple est aussi une simplification d'écriture, mais cette fois d'une cascade d'alternatives...
L'enchaînement est une suite d'instructions traitées suivant leur ordre d'apparition.
|
La clause Sinon est facultative (alternative partielle).
Voir aussi : condition - instruction
|
Le blocs d'instructions peut ne jamais être exécuté si la condition est fausse dès le départ.
Voir aussi : condition - instruction
|
Le bloc d'instructions est exécuté au moins une fois.
Voir aussi : condition - instruction
|
Voir aussi : identificateur - instruction
|
Les délimiteurs Début et Fin sont superflus si le bloc d'instructions n'est composé que d'une unique
instruction terminée par un point-virgule.
La clause par défaut, si elle existe, doit être placée en dernier...
Voir aussi : expression - instruction - [ Sommaire ]
Les ressources reconnues par MoniaPL sont regroupées ci-dessous par catégories. La colonne de droite indique le prototype de la procédure ou fonction, suivi d'une courte description.
| Afficher() | Afficher(<expression1> [ : <taille_mini> [ : <nb_décimales> ] ] , <expression2> ... ) ; |
| procédure d'écriture d'une ou plusieurs données sur la sortie standard. | |
| Saisir() | Saisir(<variable1> [ , <variable2>, ... ] ) ; |
procédure de lecture d'une ou plusieurs données sur l'entrée standard, séparateurs de saisie : espace, tabulation, retour-chariot. |
|
| LireClavier() | LireClavier : caractère ; |
fonction bloquante de lecture d'un caractère en provenance du clavier. Attention, les touches spéciales renvoient 2 codes dont le premier vaut toujours 0. |
|
| ToucheDispo | ToucheDispo : booléen ; |
fonction qui retourne |
| NbrParam | NbrParam : mot ; |
fonction qui retourne le nombre d'arguments transmis sur la ligne de commande. |
|
| ValParam() | ValParam(<indice> ) : chaîne ; |
fonction renvoyant sous forme de chaîne le paramètre de la ligne de commande dont l'indice est spécifié en argument. |
| Abs() | Abs(<expression> ) : <type> ; |
fonction retournant la valeur absolue de <expression>, du même type (entier, entier long, mot ou réel ). |
|
| Arccos() | Arccos(x : réel ) : réel ; |
fonction retournant l'arc-cosinus de l'argument. |
|
| Arcosh() | Arcosh(x : réel ) : réel ; |
fonction retournant l'arc-cosinus hyperbolique de l'argument. |
|
| Arcsin() | Arcsin(x : réel ) : réel ; |
fonction retournant l'arc-sinus de l'argument. |
|
| Arctan() | Arctan(x : réel ) : réel ; |
fonction retournant l'arc-tangente de l'argument. |
|
| Arrondi() | Arrondi(x : réel ) : entier long ; |
fonction renvoyant la valeur arrondie de l'argument. |
|
| Arsinh() | Arsinh(x : réel ) : réel ; |
fonction retournant l'arc-sinus hyperbolique de l'argument. |
|
| Artanh() | Artanh(x : réel ) : réel ; |
fonction retournant l'arc-tangente hyperbolique de l'argument. |
|
| Carré() | Carré(<expression> ) : <type> ; |
fonction de calcul du carré de l'expression, du même type (entier, entier long, mot ou réel ). |
|
| Cos() | Cos(x : réel ) : réel ; |
fonction de calcul du cosinus de l'argument. |
|
| Cosh() | Cosh(x : réel ) : réel ; |
fonction retournant le cosinus hyperbolique de l'argument. |
|
| Exp() | Exp(x : réel ) : réel ; |
fonction retournant l'exponentielle de l'argument. |
|
| Ln() | Ln(x : réel ) : réel ; |
fonction retournant le logarithme naturel de l'argument. |
|
| Log() | Log(x : réel ) : réel ; |
fonction retournant le logarithme décimal de l'argument. |
|
| Pi | Pi : réel ; |
fonction renvoyant la valeur de pi = 3.1415926535897932385. |
|
| Plafond() | Plafond(x : réel ) : entier ; |
arrondi par excès de l'argument. |
|
| Plancher() | Plancher(x : réel ) : entier ; |
arrondi par défaut de l'argument. |
|
| Puissance() | Puissance(x : réel ; e : réel ) : réel ; |
fonction retournant x à la puissance e. |
|
| Racine() | Racine(x : réel ) : réel ; |
fonction de calcul de la racine carrée de l'argument. |
|
| Sin() | Sin(x : réel ) : réel ; |
fonction de calcul du sinus de l'argument. |
|
| Sinh() | Sinh(x : réel ) : réel ; |
fonction de calcul du sinus hyperbolique de l'argument. |
|
| Tan() | Tan(x : réel ) : réel ; |
fonction de calcul de la tangente de l'argument. |
|
| Tanh() | Tanh(x : réel ) : réel ; |
fonction de calcul de la tangente hyperbolique de l'argument. |
| Dec() | Dec(ADR x : <type> ) ; |
procédure de décrémentation (retrait de 1) de la variable spécifiée. |
|
| Inc() | Inc(ADR x : <type> ) ; |
procédure d'incrémentation (ajout de 1) de la variable spécifiée. |
|
| Max() | Max(a : entier ; b : entier ) : entier ; |
fonction retournant le plus grand des deux arguments. |
|
| Min() | Min(a : entier ; b : entier ) : entier ; |
fonction retournant le plus petit des deux arguments. |
|
| Pred() | Pred(<expression> ) : <type> ; |
fonction retournant la valeur précédente de <expression>, du même type (entier, octet ou caractère). |
|
| Succ() | Succ(<expression> ) : <type> ; |
fonction retournant le successeur de <expression>, du mêmetype (entier, octet ou caractère). |
| Ascii() | Ascii(<expression> ) : entier long ; |
fonction retournant la valeur ordinale de <expression> suivant le code ASCII. Le même résultat peut être obtenu avec un transtypage. |
|
| Caract() | Caract(x : octet ) : caractère ; |
fonction retournant le caractère dont le code ASCII est spécifié en argument. Le même résultat peut être obtenu avec un transtypage. |
|
| ChaineVersEntier() | ChaineVersEntier(s : chaîne ; def : entier ) : entier ; |
conversion d'une chaîne en valeur numérique entière. Retourne la valeur def (en général 0) lorsque la conversion est impossible. Le résultat est de type entier. |
|
| ChaineVersNombre() | ChaineVersNombre(s : chaîne ; def : réel double ) : réel double ; |
conversion d'une chaîne en valeur numérique. Retourne la valeur def (en général 0) lorsque la conversion est impossible. Le résultat est de type réel, la conversion entière du résultat peut être obtenue par les fonctions mathématiques d'arrondi. |
|
| Comparer() | Comparer(s1 : chaîne ; s2 : chaîne ) : entier ; |
comparaison lexicographique de deux chaînes de caractères. Retourne une valeur négative si s1 < s2, une valeur nulle si s1 = s2 ou une valeur positive si s1 > s2. |
|
| ComparerDébut() | ComparerDébut(s1 : chaîne ; s2 : chaîne ; n : entier ) : entier ; |
comparaison lexicographique des n premiers caractères de deux chaînes. Retourne une valeur négative si s1 < s2, une valeur nulle si s1 = s2 ou une valeur positive si s1 > s2. |
|
| Concaténer() | Concaténer(dest : chaîne ; source : chaîne ) : pCaractère ; |
ajoute la chaîne source à la fin de la chaîne dest et retourne l'adresse de début de dest. L'utilisateur doit s'assurer que la destination à une capacité suffisante. |
|
| Copier() | Copier(dest : chaîne ; source : chaîne ) : pCaractère ; |
copie les caractères de la chaîne source vers dest, jusqu'à occurrence d'un caractère nul, et retourne l'adresse de début de dest. L'utilisateur doit s'assurer que la destination à une capacité suffisante. |
|
| CopierDébut() | CopierDébut(dest : chaîne ; source : chaîne ; n : entier ) : pCaractère ; |
copie les n premiers caractères de la chaîne source vers dest, ajoute un caractère nul, et retourne l'adresse de début de dest. L'utilisateur doit s'assurer que la destination à une capacité suffisante. |
|
| Longueur() | Longueur(s : chaîne ) : entier ; |
fonction renvoyant le nombre de caractères de la chaîne spécifiée en argument. |
|
| Majuscules() | Majuscules(s : chaîne ) : pCaractère ; |
change tous les caractères de la chaîne s en majuscules et retourne un pointeur sur s. |
|
| Minuscules() | Minuscules(s : chaîne ) : pCaractère ; |
change tous les caractères de la chaîne s en minuscules et retourne un pointeur sur s. |
|
| NombreVersChaine() | NombreVersChaine(<expression> ) : Chaîne ; |
Conversion de l'expression numérique en une chaîne de caractères. |
|
| Position() | Position(s : chaîne ; motif : chaîne ) : pCaractère ; |
retourne un pointeur sur la première occurrence de motif dans la chaîne s, ou NULL en cas d'échec. |
|
| Val() | Val(s : chaîne ; ADR v : <type> ; ADR code : entier ) ; |
procédure de conversion vers v d'une chaîne s en valeur numérique du type de v. L'argument code vaut 0 en cas de succès, ou la position dans la chaîne du premier caractère qui empêche la conversion. |
| Allouer() | Allouer(taille : entier ) : pointeur ; |
fonction d'allocation dynamique d'une zone mémoire de taille octets avec initialisation de p sur la zone nouvellement allouée. Retourne |
|
| Libérer() | Libérer(p : pointeur ) ; |
procédure de libération de la zone pointée par p, préalablement allouée par la fonction précédente. |
Note : les ressources des versions précédentes Allouer( ADR p : <pointeur> ) et Libérer( ADR p : <pointeur> ) ne sont plus utilisables...
| EffacerEcran | EffacerEcran ; |
procédure d'effacement du terminal texte, le curseur est positionné en haut à gauche. |
|
| Curseur() | Curseur(x, y : octets ) ; |
procédure de positionnement du curseur. |
|
| CurseurX() | CurseurX : octet ; |
fonction qui retourne la position horizontale du curseur (1..80). Cette fonction est inopérante sous Linux, elle retourne toujours 0. |
|
| CurseurY() | CurseurY : octet ; |
fonction qui retourne la position verticale du curseur (1..25). Cette fonction est inopérante sous Linux, elle retourne toujours 0. |
|
| Fenêtre() | Fenêtre(x1, y1, x2, y2 : octets ) ; |
|
procédure de définition de la fenêtre active sur le terminal, avec 1 < x < 80 et 1 < y < 25 (sous Windows uniquement). |
|
| CouleurFond() | CouleurFond(c : octet ) ; |
procédure de sélection de la couleur d'arrière-plan. |
|
| CouleurTexte() | CouleurTexte(c : octet ) ; |
procédure de sélection de la couleur d'avant-plan. |
Codage des couleurs :
0 - Noir 1 - Bleu 2 - Vert 3 - Cyan
4 - Rouge 5 - Magenta 6 - brun 7 - Gris clair
8 - Gris foncé 9 - Bleu clair 10 - Vert clair 11 - Cyan clair
12 - Rouge clair 13 - Magenta clair 14 - Jaune 15 - Blanc
Le clignotement est obtenu en ajoutant 128 au code de la couleur...
Note importante : Sous Windows, cette catégorie de ressources n'est opérationnelle que lorsque le point
d'entrée du programme principal est Début. Elle est incompatible avec un programme commençant par DébutProg (version qui autorise par
contre les redirections sur la ligne de commandes et un affichage correct des caractères spéciaux comme les tabulations...).
| Accéder() | Accéder(fich : Fichier ; offset : entier ; origine : entier ) : entier long ; |
positionne le pointeur du fichier fich à la position offset relativement
au point de départ origine. Le point de départ peut valoir
|
|
| Créer() | Créer(nom : chaîne ; mode : entier ) : Fichier ; |
fonction de création du fichier spécifié par le chemin nom, avec écrasement si il existe déjà. Le fichier est ouvert par défaut
en mode lecture/écriture, l'utilisateur peut sinon utiliser les constantes prédéfinies |
|
| Ecrire() | Ecrire(fich : Fichier ; CONST source ; n : entier long ) : entier long ; |
écriture dans le fichier de descripteur fich de n octets copiés à partir de l'adresse indiquée par source. La source peut être de n'importe quel type. La fonction retourne le nombre d'octets réellement écrits ou -1 en cas d'erreur. |
|
| Existe() | Existe(CONST nom : chaîne ) : booléen ; |
retourne |
|
| Fermer() | Fermer(fich : Fichier ) ; |
fermeturedu fichier spécifié par son descripteur (ouvert au préalableavec |
|
| Lire() | Lire(fich : Fichier ; VAR dest ; n : entier long ) : entier long ; |
lecture dans le fichier de descripteur fich de n octets et copie à partir de l'adresse indiquée par dest. La destination peut être de n'importe quel type. La fonction retourne le nombre d'octets réellement lus ou -1 en cas d'erreur. |
|
| Ouvrir() | Ouvrir(nom : chaîne ; mode : entier ) : Fichier ; |
fonction d'ouverture du fichier spécifié par le chemin nom, qui doit
exister. Le mode d'ouverture est fixé par une des constantes
prédéfinies |
|
| Renommer() | Renommer(avant : chaîne ; après : chaîne ) : booléen ; |
change
le nom du fichier avant en après. Retourne |
|
| Supprimer() | Supprimer(nom : chaîne ) : booléen ; |
supprime le fichier spécifié par nom. Retourne |
| Aléatoire | Aléatoire : réel ; |
fonction retournant un nombre pseudo-aléatoire compris entre 0 et 1. |
|
| Aléatoire() | Aléatoire(n : mot ) : mot ; |
fonction retournant un nombre pseudo-aléatoire entier compris entre 0 etl'argument spécifié. |
|
| InitAléatoire | InitAléatoire ; |
procédure d'initialisation du générateur pseudo-aléatoire (à partir de l'heure et la date du système). |
|
| Taille() | Taille(<expression> ) : entier ; |
fonction calculant la taille en octets de <expression> qui peut être une constante, un type, une variable... |
|
| Délai() | Délai(ms : mot ) ; |
procédure de temporisation suivant la durée en milli-secondes spécifiée. |
|
| DateSystème | DateSystème : chaîne ; |
procédure fournissant la date courante système (format JJ/MM/AAAA). |
|
| HeureSystème | HeureSystème : chaîne ; |
procédure fournissant l'heure courante système (format HH:MM:SS). |
[ Sommaire ]
Les programmes de démonstration ci-dessous illustrent la syntaxe utilisable pour la manipulation de données des divers types standards et dérivés, la structure des programmes avec les notions de visibilité des variables, et la manipultion de fichiers.
Ces programmes sont disponibles après installation de MoniaSuite dans le sous-répertoire des exemples.
PROGRAMME Demo_1 ;
CONSTANTES MAX = 74 ;
x : entier long = MAX + $1A ;
VARIABLES y : mot ;
z : entier ;
u : octet ;
v : entier court ;
DEBUTPROG
y <- %1010111000110101 ; # ... ou $AE35
z <- y ;
Afficher("x = ", x, CRLF ) ; # "x = 100"
Afficher("y = ", y, CRLF ) ; # "y = 44597"
Afficher("z = ", z, CRLF ) ; # "z = -20939"
z <- -1 ;
y <- z ;
Afficher("y = ", y, CRLF ) ; # "y = 65535"
Afficher("z = ", z, CRLF ) ; # "z = -1"
y <- $FFF1 ;
z <- y ;
Afficher("z = ", z, CRLF ) ; # "z = -15"
Afficher("z = ", mot(z), CRLF ) ; # "z = 65521"
u <- octet(-4) ;
v <- u ;
Afficher("u = ", u, CRLF ) ; # "u = 252"
Afficher("v = ", v, CRLF ) ; # "v = -4"
z <- v ;
Afficher("z = ", z, CRLF ) ; # "z = -4"
Afficher("z = ", octet(z), CRLF ) ; # "z = 252"
Afficher("z = ", mot(z), CRLF ) ; # "z = 65532"
FINPROG
[ Sommaire ]
PROGRAMME Demo_2 ;
CONSTANTE BEL = $07 ;
VARIABLES c : caractère ;
x : octet ;
y : entier court ;
DEBUTPROG
c <- 'A' ;
Afficher("c = ", c, CRLF ) ; # "c = A"
x <- octet(c) ;
Afficher("x = ", x, CRLF ) ; # "x = 65"
x <- x + 4 ;
c <- caractère(x) ;
Afficher("c = '", c, "'", CRLF ) ; # "c = 'E'"
y <- BEL ;
Afficher("y = ", '"', y, '"', CRLF ) ; # "y = "7""
c <- caractère(y) ;
Afficher("c = ", c, CRLF ) ; # "c = " beep!
y <- y + %01000000 ;
Afficher("y = ", Caract(y), CRLF ) ; # "c = G"
c <- Caract( y + 1 ) ;
Afficher("y = ", Ascii(c), CRLF ) ; # "y = 72"
FINPROG
[ Sommaire ]
PROGRAMME Demo_3 ;
CONSTANTES c = 10 ;
x = 0.123 ;
VARIABLES a,b sont des booléens ;
DEBUTPROG
a <- VRAI ;
b <- FAUX ;
Afficher("a = ", a, CRLF ) ; # "a = TRUE"
Afficher("b = ", b, CRLF ) ; # "b = FALSE"
Afficher("a = ", entier(a), CRLF ) ; # "a = 1"
Afficher("b = ", entier(b), CRLF ) ; # "b = 0"
a <- booléen( c < 5 ) ;
Afficher("a = ", a, CRLF ) ; # "a = FALSE"
b <- booléen( x >= 0 ) ET NON a ;
Afficher("b = ", b, CRLF ) ; # "b = TRUE"
FINPROG
[ Sommaire ]
PROGRAMME Demo_4 ;
VARIABLES x : réel ;
y : réel double ;
z : entier ;
DEBUTPROG
y <- -1.256e+4 ;
x <- y - 1.77 ;
Afficher("x = ", x:1:2, CRLF ) ; # "x = -12561.77"
Afficher("y = ", y:1:0, CRLF ) ; # "y = -12560"
y <- y / Pi ;
x <- y ;
Afficher("x = ", x, CRLF ) ; # "x = -3.997972168E+03"
Afficher("y = ", y, CRLF ) ; # "y = -3.99797217045841E+0003"
z <- Arrondi( -x / 10 ) + 1 ;
Afficher("z = ", z, CRLF ) ; # "z = 401"
FINPROG
[ Sommaire ]
PROGRAMME Demo_5 ;
TYPES MOIS = ( JAN,FEV,MAR,AVR,MAI,JUN,JUL,AOU,SEP,OCT,NOV,DEC ) ;
RVB = ( ROUGE,VERT,BLEU ) ;
VARIABLES m : MOIS ;
x : entier ;
couleur : RVB ;
état : ( ARRET,MARCHE,PANNE ) ;
DEBUTPROG
m <- MAI ;
x <- entier(m) + 1 ;
Afficher("x = ", x, CRLF ) ; # "x = 5"
état <- ARRET ;
Afficher("état = ", entier(état), CRLF ) ; # "état = 0"
POUR couleur <- ROUGE JUSQU'A BLEU FAIRE
Afficher(entier(couleur), " " ) ; # "0 1 2 "
FINP
Afficher(CRLF ) ;
FINPROG
[ Sommaire ]
PROGRAMME Demo_6 ;
TYPE JOUR = ( LUN,MAR,MER,JEU,VEN,SAM,DIM ) ;
CONSTANTE Travail : tableau[JOUR] de booléens =
( VRAI,VRAI,VRAI,VRAI,VRAI,FAUX,FAUX ) ;
VARIABLES TableMul est un tableau[1..10,1..10] d'entiers ;
i,j sont des entiers ;
DEBUTPROG
Afficher("lun = ", Travail[LUN], CRLF ) ; # "lun = TRUE"
Afficher("dim = ", Travail[DIM], CRLF ) ; # "dim = FALSE"
POUR i <- 1 JUSQU'A 10 FAIRE
POUR j <- 1 JUSQU'A 10 FAIRE
TableMul[i,j] <- i * j ;
Afficher( TableMul[i,j]:4 ) ; # affichage de la table
FINP # de multiplication
Afficher(CRLF) ;
FINP
FINPROG
[ Sommaire ]
PROGRAMME Demo_7 ;
CONSTANTE ch est une chaîne = "ABCDEF" ;
VARIABLES i est un entier ;
p , s sont des pCaractères ;
DEBUTPROG
Afficher( "N = ", Longueur(ch), CRLF ) ; # "N = 6"
POUR i <- 0 JUSQU'A Longueur(ch) FAIRE
Afficher( ch[i] ) ; # "ABCDEF"
FINP
Afficher(CRLF) ;
p <- @ch[4] ;
p^ <- Caract(0) ;
ch[1] <- 'Z' ;
Afficher(ch, CRLF ) ; # "AZCD"
ch <- "Matin" + TAB + "Midi" + TAB + "Soir" + CRLF ;
Afficher( ch ) ;
Majuscules( ch ) ;
Afficher( ch ) ;
Afficher("Indice de TIN = ", Position( ch, "TIN" ) - ch ) ;
Afficher(CRLF) ;
s <- Allouer( 40 * taille( caractère ) ) ;
Copier( s, "Hello" ) ;
Concaténer( s, " World" ) ;
Afficher( s, " !", CRLF ) ; # "Hello World !"
Libérer( s ) ;
FINPROG
[ Sommaire ]
PROGRAMME Demo_8 ;
TYPES DATE = ENREGISTREMENT
Jour : 1..31 ;
Mois : 1..12 ;
Année : entier ;
FIN
PERSONNE = ENREGISTREMENT
Nom : chaîne[30] ;
Prénom : chaîne[30] ;
Sexe : ( F , M ) ;
DateNaissance : DATE ;
FIN
PERSONNES = PERSONNE ; # alias ...
VARIABLES lui , elle sont des PERSONNES ; # ... pour l'orthographe !
DEBUTPROG
elle.Nom <- "TOURNEL" ;
elle.Prénom <- "Marie" ;
elle.Sexe <- F ;
elle.DateNaissance.Année <- 1990 ;
lui.Nom <- "AIMAR" ;
lui.Prénom <- "Jean" ;
lui.Sexe <- M ;
lui.DateNaissance.Mois <- 6 ;
Afficher(elle.Prénom, " ", elle.Nom, " né" ) ;
SI ( elle.Sexe = F ) ALORS
Afficher("e") ;
FINSI
Afficher(" en ", elle.DateNaissance.Année, CRLF ) ;
FINPROG
[ Sommaire ]
PROGRAMME Demo_9 ;
CONSTANTES NbEtudiants = 20 ;
ESP = ' ' ;
# reprendre les déclarations de type du programme Demo_8 ...
VARIABLES Classe : tableau[1..NbEtudiants] de PERSONNES ;
pEtudiant : pointeur de PERSONNE ;
DEBUTPROG
pEtudiant <- @Classe[1] ;
pEtudiant^.Nom <- "MENVUSSA" ; # ^. ou ->
pEtudiant^.Prénom <- "Gérard" ;
Afficher(Classe[1].Prénom, ESP, Classe[1].Nom, ESP ) ;
Afficher("1er de la classe !", CRLF ) ;
FINPROG
[ Sommaire ]
PROGRAMME Demo_10 ;
TYPES pElem = POINTEUR d'Elément ; # type 'lien'
Elément = ENREGISTREMENT # type 'maillon'
Valeur : entier ; # donnée utile
Suivant : pElem ; # lien
FIN
VARIABLES p : pElem ;
e1 , e2 , e3 : Elément ;
v : pointeur d'entier ;
DEBUTPROG
p <- @e1 ; # assemblage et
e1.Valeur <- 1 ; # remplissage
e1.Suivant <- @e2 ; # des maillons
e2.Valeur <- 2 ;
e2.Suivant <- @e3 ;
e3.Valeur <- 3 ;
e3.Suivant <- NULL ;
TANT QUE ( p <> NULL ) FAIRE # parcours et
Afficher(p^.Valeur, TAB ) ; # affichage de
p <- p^.Suivant ; # "1 2 3 "
FINTQ
Afficher(CRLF) ;
p <- @e1 ;
v <- @e1.Valeur ;
p^.Suivant^.Valeur <- 4 ;
e2.Suivant^.Valeur <- 6 ;
v^ <- 2 ;
e2.Suivant <- p ;
p <- @e2 ;
e2.Suivant^.Suivant <- @e3 ;
TANT QUE ( p <> NULL ) FAIRE # parcours et
Afficher(p^.Valeur, TAB ) ; # affichage de
p <- p^.Suivant ; # "4 2 6 "
FINTQ
Afficher(CRLF) ;
FINPROG
Un pointeur est une variable dont la valeur est une adresse. Ceci permet d'accéder indirectement à une donnée, au travers de son adresse.
Un pointeur peut contenir une adresse quelconque (pointeur générique), il peut donc pointer une donnée de n'importe quel type. Un pointeur générique est polyvalent et reflète la réalité physique de la machine (il n'y a effectivement pas de différence entre l'adresse d'un entier et l'adresse d'un nombre réel...).
Un pointeur peut aussi être typé, pour accéder à une donnée d'un type explicitement défini. En langage évolué, le typage des pointeurs permet aux outils de développement (compilateurs,...) de vérifier l'utilisation correcte de ces pointeurs et de réaliser automatiquement des calculs sur ceux-ci.
@v se lit "adresse de v" )p^ se lit "contenu pointé par p" )[ Sommaire]
PROGRAMME Demo_11 ;
CONSTANTE NB = 5 ;
# reprendre les déclarations de type du programme Demo_10 ...
VARIABLES pDébut : pElem ; # lien sur début de chaîne
p,q : pElem ;
i : entier ;
DEBUTPROG
pDébut <- NULL ;
POUR i <- 1 JUSQU'A NB FAIRE # création d'une liste chaînée
p <- Allouer( taille( Elément) ) ; # de NB maillons
p^.Valeur <- NB - i ; # avec attachement des maillons
p^.Suivant <- pDébut ; # en amont...
pDébut <- p ;
FINP
p <- pDébut ;
TANT QUE ( p <> NULL ) FAIRE # parcours de la liste
Afficher(p->Valeur,TAB) ;
p <- p->Suivant ;
FINTQ
Afficher(CRLF) ;
p <- pDébut ;
TANT QUE ( p->Suivant->Valeur < 2 ) FAIRE
p <- p->Suivant ;
FINTQ
q <- p->Suivant ; # suppression d'un maillon
p->suivant <- q->Suivant ;
Libérer(q) ;
p <- pDébut ;
TANT QUE ( p <> NULL ) FAIRE # parcours de la liste
Afficher(p^.Valeur, TAB ) ;
p <- p^.Suivant ;
FINTQ
Afficher(CRLF) ;
FINPROG
Par opposition aux variables statiques, les variables dynamiques n'ont pas d'emplacement mémoire fixé à l'avance, elles ne sont pas explicitement déclarées dans le programme.
À partir de deux ressources -allocation d'un espace mémoire, et libération d'un espace mémoire dans le tas-, le programmeur a la possibilité de prévoir la création puis la destruction de données au cours de l'exécution du programme.
Les données ainsi créées sont accessibles via un pointeur initialisé lors de l'opération d'allocation.
L'allocation dynamique de mémoire permet de travailler sur des entités dont on ne connaît pas le nombre à l'avance. Les données dynamiques sont en général organisées sous forme de structures chaînées telles que listes, arbres, ...
Session type :
[ Sommaire ]
PROGRAMME Demo_12 ;
VARIABLES i , j : entiers ; # variables globales
# bloc fonction
FONCTION Moulinette( i : entier ) : entier ;
VARIABLES j , k : entiers ; # variables locales
DEBUT
k <- 0 ;
POUR j <- 1 JUSQU'A i FAIRE
k <- k + j * i ;
FINP
Moulinette <- k ; # résultat de la fonction
FIN
# programme principal
DEBUTPROG
i <- 123 ;
j <- Moulinette( i ) ;
Afficher( i , " mouliné = ", j, CRLF ) ;
FINPROG
À l'intérieur du bloc fonction, les arguments de celle-ci sont assimilables à des variables locales automatiques initialisées avec les valeurs transmises lors de l'appel de la fonction.
Moulinette(), l'argument i est considéré comme variable locale ; i peut donc être modifiée à
l'intérieur de la fonction. D'après la règle de portée lexicale, la variable i globale n'est plus accessible lors de l'exécution de
la fonction. Il en est de même pour la variable locale j.[ Sommaire ]
PROGRAMME Demo_13 ;
VARIABLE i : entier ; # variable globale
# procédure avec passage d'argument par valeur
PROCEDURE Proc1( i : entier ) ;
DEBUT
i <- i + 100 ;
FIN
# procédure avec passage d'argument par adresse
PROCEDURE Proc2( ADRESSE j : entier ) ;
DEBUT
j <- j + 100 ;
i <- i + 100 ;
FIN
# procédure sans argument
PROCEDURE Proc3 ;
VARIABLE j : entier ; # variable locale
DEBUT
j <- 50 ;
Afficher("avant : ", i, TAB, j, CRLF ) ;
Proc1( j ) ;
Proc2( j ) ;
Afficher("après : ", i, TAB, j, CRLF ) ;
FIN
# programme principal
DEBUTPROG
i <- 0 ;
Proc3 ;
FINPROG
En général, un bloc procédure ou fonction travaille à partir des valeurs qui lui sont transmises lors de l'appel, le bloc ne peut dans ce cas modifier les variables du bloc appelant où ont été prélevées les valeurs transmises. C'est le passage de paramètres par valeur conforme à la notion de programme propre dans le sens où il limite les effets de bord.
En cas de nécessité, une fonction peut modifier le contenu d'une variable extérieure si elle en connaît l'adresse. C'est le passage de paramètres par adresse.
[ Sommaire ]
PROGRAMME Demo_14 ;
VARIABLE i : entier ;
somme, r : réels ;
err : entier ;
DEBUTPROG
somme <- 0 ;
Afficher( "Commande suivie de ", NbrParam, " arguments...", CRLF ) ;
POUR i <- 0 JUSQU'A NbrParam FAIRE
Afficher(i:2, " : ", ValParam(i), CRLF ) ; # forme par défaut (chaîne)
r <- ChaineVersNombre( ValParam(i), 0 ) ; # conversion numérique
somme <- somme + r ;
FINP
Afficher("somme calculée = ", somme:1:2 ) ;
FINPROG
[ Sommaire ]
PROGRAMME Demo_15 ;
CONST LF = 10 ; # marqueur de fin de ligne
Log = "demo_15.log" ; # fichier journal
VARIABLE fich, ch : chaîne ;
f : fichier ;
c : caractère ;
i, num : entier ;
DEBUTPROG
fich <- ValParam(1) ; # fichier à ouvrir
SI ( NON Existe( fich ) ) ALORS
Afficher("Fichier non trouvé...", CRLF ) ;
SINON
f <- Ouvrir( fich, ModeLecture ) ;
i <- 0 ;
num <- 1 ;
TANT QUE ( Lire( f, c, 1 ) <> 0 ) FAIRE # lecture d'un caractère
ch[ i ] <- c ;
Inc( i ) ;
SI ( Ascii(c) = LF ) ALORS # fin de ligne ?
ch[ i ] <- caractère(0) ;
Afficher( num:3, " : ", ch ) ; # affichage avec numéro
i <- 0 ;
Inc( num ) ;
FINSI
FINTQ
Fermer( f ) ;
SI ( Existe( Log ) ) ALORS # ouverture du journal
f <- Ouvrir( Log, ModeEcriture ) ;
SINON
f <- Créer( Log ) ;
FINSI
Accéder( f, 0, OrigineFin ) ; # positionnement à la fin
Copier( ch, DateSystème ) ; # et remplissage...
Concaténer( ch, " " ) ;
Concaténer( ch, HeureSystème ) ;
Concaténer( ch, " - " ) ;
Ecrire( f, ch, Longueur( ch ) ) ;
Concaténer( fich, " " ) ;
Ecrire( f, fich, Longueur( fich ) ) ;
ch <- NombreVersChaine( num - 1 ) ;
Concaténer( ch, " lignes" ) ;
Concaténer( ch, CRLF ) ;
Ecrire( f, ch, longueur( ch ) ) ;
Fermer( f ) ;
FINSI
FINPROG
Dans cet exemple, un argument est attendu sur la ligne de commande. Il doit indiquer le nom d'un fichier texte à ouvrir. Le programme effectue une lecture caractère par caractère, et affiche le contenu du fichier ligne par ligne en numérotant celles-ci. Il assure aussi la mise à jour d'un fichier journalisant les opérations réalisées.
[ Sommaire ]
|
|
édition 23/11/2012 - Copyright © 2006-2012 Alain Menu |
version 0.38.97