Skip to content

Pseudocode 23 fr

Jump to bottom
Scover edited this page Dec 18, 2024 · 11 revisions

Pseudocode 23 (nom de code FVR-0)

Grammaire formelle

Il s'agit de la toute première révision de la norme Pseudocode. Santé !

Durée d'effet : année universitaire 2023 – 2024

N'utilisez ces informations que pour le bien, jamais pour le mal. Ne les exposez pas au feu. N'utilisez pas d'équipement lourd après les avoir lues, cela peut provoquer une somnolence. Ne lisez pas sous l'influence de l'alcool (bien que plusieurs rapports non confirmés indiquent que l'alcool améliore réellement la lisibilité). (...) Si vous avez du mal à comprendre une section particulière, relisez-la encore et encore et encore… Tenez-vous droit. Mangez vos légumes. Ne marmonnez pas. Norme Pascal (ISO 7185:1990, traduit de l'anglais)

Table des matières

Règles d'orthographe

Le Pseudocode est sensible à la casse. Les accents et les diacritiques sont significatifs, sauf dans les mots réservés (mots-clés et builtins). Cela signifie que la fonction intégrée écrireÉcran peut être orthographiée écrireEcran ou ecrireEcran, mais pas écrireécran.

Espaces blancs

Les espaces blancs sont considérés comme insignifiants. Cela signifie que les espaces supplémentaires, les tabulations et les sauts de ligne (ou tout autre caractère d'espacement Unicode) n'affectent pas la signification du code.

Par exemple, les instructions suivantes sont équivalentes :

x : entier ;

et

x   : 
      entier  
 ;

Identifiants

Les identifiants sont définis par l'expression régulière PCRE2 suivante : [\p{L}_][\p{L}_0-9]*

Explication : un identifiant se compose d'une ou plusieurs lettres Unicode, d'un trait de soulignement ou de chiffres. Le premier caractère ne peut pas être un chiffre.

Programme

programme ⟨nom⟩ c'est

Le programme est la construction la plus fondamentale, car il est présent dans tout fichier Pseudocode.

⟨nom⟩ est un identifiant indiquant le nom du programme.

Le programme commence après le c'est et continue jusqu'à la fin du fichier.

Commentaires

Les commentaires sont utilisés pour documenter le code et le rendre plus lisible. Il existe deux types de commentaires : sur une seule ligne et sur plusieurs lignes.

Les commentaires n'affectent pas la signification du programme, mais ils séparent les jetons, agissant effectivement comme des espaces.

Sur une seule ligne

Les commentaires sur une seule ligne commencent par // et continuent jusqu'à la fin de la ligne.

// Ceci est un commentaire sur une seule ligne

Sur plusieurs lignes

Les commentaires sur plusieurs lignes commencent par /* et se terminent par */. Ils peuvent s'étendre sur plusieurs lignes.

/* Ceci est un multiligne

clown comment
*/

Directives du compilateur

Les directives de compilateur sont des instructions spéciales exécutées au moment de la compilation.

assert

#assert ⟨expr⟩ ⟨message⟩

Assertion statique. Si ⟨expr⟩ est faux, le programme est arrêté et ⟨message⟩ est affiché. ⟨expr⟩ doit être implicitement convertible vers le type booléen. ⟨message⟩ est facultatif et doit être implicitement convertible vers le type chaîne.

Exemple

#assert faux
#assert 1 == 1 "Ceci ne devrait jamais échouer"

eval expr

#eval expr ⟨expr⟩

Affiche la valeur et le type d'une expression connue au moment de la compilation.

Exemple

#eval expr 1 + 1 // Affiche "entier: 2"

eval type

#eval type ⟨type⟩

Affiche les informations d'un type.

Exemple

#eval type entier // Affiche "entier"

Types

Les types définissent le type de données qu'une variable peut contenir.

Primitives

Les types primitifs sont les types les plus basiques. Ils sont utilisés pour représenter des valeurs simples, telles que les scalaires, des valeurs de vérité et les chaînes.

entier

Le type entier représente des entiers.

réel

Le type réel représente des nombres réels.

booléen

Le type booléen représente des valeurs booléennes. Les valeurs de véritées sont exprimées avec les mot-clés vrai et faux.

caractère

Le type caractère représente des caractères. L'encodage est défini par le langage cible.

chaîne

Le type chaîne représente des chaînes de longueur connue à l'exécution.

chaîne(N)

Le type chaîne(N) représente des chaînes de longueur connue à la compilation. N définit la longueur maximale de la chaîne. L'encodage est défini par le langage cible.

Tableaux

tableau[⟨longueur⟩] de ⟨type-element⟩

Les tableaux sont utilisés pour représenter des collections de valeurs de même type.

Les tableaux commencent à l'indice 1.

  • ⟨longueur⟩ est une expression unique ou une liste d'expressions séparées par des virgules qui s'évaluent au moment de la compilation à une valeur entier. Elles définissent la longueur de chaque dimension du tableau.
  • ⟨type-element⟩ est le type des éléments du tableau.

Tableaux multidimensionnels

La syntaxe des tableaux multidimensionnels n'est qu'un raccourci pour des tableaux de tableaux.

tableau[1, 2] de entier

Est un raccourci pour :

tableau[1] de tableau[2] de entier

Structures

structure début
    ⟨composant⟩ : ⟨type⟩;
    // …
fin

Les structures sont des types de données définis par l'utilisateur qui regroupent différents types de variables sous un seul nom. Cela est particulièrement utile pour gérer ensemble des données liées. Les structures implémentent les types en produit.

Le contenu d'une structure consiste en une liste de déclarations de variables.

Exemples (utilisant les alias de types) :

type t_personne = structure début
    nom, prenom : chaîne(50);
    age : entier;
fin;

type t_classe = structure début
    libelle : chaîne(20);
    eleves : tableau[35] de t_personne;
fin;

Déclarations

Les déclarations divisent le programme en parties nommées et réutilisables.

Programme principal

début
    // instructions…
fin

Le programme principal est le point d'entrée du programme.

Il doit y avoir exactement un programme principal.

Constantes

constante ⟨type⟩ ⟨nom⟩ := ⟨valeur⟩;

Les constantes désignent des valeurs connues au moment de la compilation.

⟨valeur⟩ est une expression connue au moment de la compilation ou un initialiseur.

Exemple

constante réel PI := 3.14159;

Initialiseurs

Les initialiseurs initialisent les variables ou les constantes de types composés (tableau ou structure).

Ils suivent principalement la syntaxe et les règles d'initialisation entre accolades du C.

constant tableau[10] de entier A = { 1,2,3,4,5,6,7,8,9,10 };

constante structure début
    x: entier;
    c: tableau [4] de caractère;
fin B := {
    1
};

Procédures

procédure ⟨nom⟩(⟨paramètres-formels⟩) c'est début
    // instructions…
fin

Les procédures regroupent et réutilisent des instructions qui exécutent une tâche spécifique.

Elles peuvent avoir zéro ou plusieurs paramètres formels.

Exemple

procédure sayHello(entF name : chaîne) c'est début
    écrireÉcran("Hello ", name);
fin

Fonctions

fonction ⟨nom⟩(⟨paramètres-formels⟩) délivre ⟨type⟩ c'est début
    // instructions…
    retourne ⟨valeur⟩;
fin

Les fonctions regroupent et réutilisent des instructions qui exécutent une tâche spécifique et renvoient une valeur.

Comme les procédures, les fonctions peuvent avoir zéro ou plusieurs paramètres formels.

Exemple

fonction add(entF a : entier, entF b : entier) délivre entier c'est début
    retourne a + b;
fin

Prototypes

Les prototypes pré-déclarent des fonctions et des procédures définies ailleurs. La syntaxe rappelle celle du C, avec la signature suivie d'un point-virgule. Exemple :

procédure sayHello(entF name : chaîne);
fonction add(entF a : entier, entF b : entier) délivre entier;

Contrairement au C, les noms de paramètres ne peuvent pas être omis.

Une fonction/procédure donnée peut être prototypée plusieurs fois, à condition que toutes les signatures soient identiques.

Alias ​​de type

type ⟨nom⟩ = ⟨type⟩;

Les alias de type dénomment un nouveau type, afin d'ajouter un niveau d'abstraction et d'améliorer la sémantique du code.

Exemple :

type t_pid = entier;

// Maintenant t_pid est un alias pour entier

Les alias de type sont couramment utilisés pour définir des types de tableau/structure complexes car ils évitent de répéter le type. Exemple :

type t_personne = structure début
    nom : chaîne(50);
    prenom : chaîne(50);
    age : entier;
fin;

type t_fileAttente = tableau[50] de t_personne;

Instructions

Les instructions sont les éléments de base d'un programme. Elles sont utilisées pour contrôler le flux d'exécution, effectuer des opérations et prendre des décisions.

No-op

L'instruction no-op ne fait rien. Elle se compose d'un seul point-virgule ;.

Builtins

Les builtins sont des sous-routines fournies par le compilateur.

IO

Builtins liés à entrée/sortie.

écrireÉcran
écrireÉcran(⟨arg1⟩, ⟨arg2⟩, …);

Le builtin variadique écrireÉcran affiche les arguments donnés sur la sortie standard, suivis d'un saut de ligne. Tous les types ne sont pas pris en charge, selon le langage cible.

Il peut également prendre zéro argument, auquel cas il affiche simplement un saut de ligne.

lireClavier
lireClavier(⟨variable⟩);

Le builtin lireClavier lit une valeur depuis l'entrée standard et l'affecte à la variable donnée. Tous les types ne sont pas pris en charge, selon le langage cible.

Fichiers

assigner
assigner(⟨nomLog⟩, ⟨nomExt⟩);

La procédure builtin assigner assigne un nom de fichier physique (extérieur) au nom de fichier logique fourni.

ouvrirAjout
ouvrirAjout(⟨nomLog⟩);

La procédure builtin ouvrirAjout ouvre le fichier fourni en mode ajout.

ouvrirÉcriture
ouvrirÉcriture(⟨nomLog⟩);

La procédure builtin ouvrirÉcriture ouvre le fichier fourni en mode écriture.

ouvrirLecture
ouvrirLecture(⟨nomLog⟩);

La procédure builtin ouvrirLecture ouvre le fichier fourni en mode lecture.

lire
lire(⟨nomLog⟩, ⟨variable⟩);

La procédure builtin lire lit une valeur binaire à partir d'un fichier et l'affecte à la variable fournie.

écrire
écrire(⟨nomLog⟩, ⟨expression⟩);

La procédure builtin écrire écrit en binaire la valeur de l'expression fournie dans le fichier.

FdF
FdF(⟨nomLog⟩);

La fonction intégrée FdF teste l'indicateur de fin de fichier sur le fichier fourni et renvoie vrai s'il est défini, faux sinon.

fermer
fermer(⟨nomLog⟩);

La procédure builtin fermer ferme le fichier fourni.

Affectations

⟨variable⟩ := ⟨expression⟩;

Les affectations changent la valeur d'une variable, qui peut être une variable locale, un élément de tableau, ou un composant de structure.

Instructions d'expression

Toute expression suivie d'un point-virgule est une instruction valide.

Variables locales

⟨nom⟩ : ⟨type⟩;
⟨nom1⟩, ⟨nom2⟩ : ⟨type⟩;

Déclare une ou plusieurs variables locales.

Les variables locales peuvent également avoir des initialiseurs.

⟨nom⟩ : ⟨type⟩ := ⟨expression⟩;
⟨nom1⟩, ⟨nom2⟩ : ⟨type⟩ := ⟨expression⟩;

Lorsque plusieurs variables sont déclarées, elles sont toutes initialisées à la même valeur.

Bloc anonyme

Un bloc anonyme définit une nouvelle portée. Syntaxe :

début
    // instructions…
fin

Flux de contrôle

Les instructions de flux de contrôle sont utilisées pour contrôler le flux d'exécution dans un programme. Elles permettent de prendre des décisions, de répéter des instructions et de passer à différentes parties du code.

Boucles

Les boucles vous permettent de répéter un bloc de code plusieurs fois.

Boucle tant que

tant que ⟨condition⟩ faire
    // instructions…
finfaire

La boucle tant que exécute des instructions tant que ⟨condition⟩ est vraie.

⟨condition⟩ peut être entourée de parenthèses.

⟨condition⟩ doit être une expression booléenne ou implicitement convertible en booléen.

Boucle faire tant que

faire
    // instructions…
tant que ⟨condition⟩

La boucle faire exécute les instructions à l'intérieur de la boucle au moins une fois, puis répète la boucle tant que ⟨condition⟩ est vraie.

⟨condition⟩ peut être entourée de parenthèses.

⟨condition⟩ doit être une expression booléenne ou implicitement convertible en booléen.

Boucle répéter jusqu'à

répéter
    // instructions…
jusqu'à ⟨condition⟩

La boucle répéter exécute les instructions à l'intérieur de la boucle au moins une fois, puis répète la boucle tant que ⟨condition⟩ est fausse.

⟨condition⟩ peut être entourée de parenthèses.

⟨condition⟩ doit être une expression booléenne ou implicitement convertible en booléen.

Boucle pour

pour ⟨variable⟩ de ⟨expr-min⟩ à ⟨expr-max⟩ faire [pas ⟨expr-pas⟩]
    // instructions…
finfaire

La boucle pour exécute les instructions à l'intérieur de la boucle pour chaque valeur de ⟨variable⟩ entre ⟨expr-min⟩ et ⟨expr-max⟩.

⟨variable⟩, ⟨expr-min⟩ et ⟨expr-max⟩ doivent être des expressions entières ou implicitement convertibles en entier.

⟨variable⟩ doit être déclarée avant la boucle.

⟨expr-pas⟩ est une expression entière optionelle. Elle définit l'incrément de la variante de boucle. Quand omise, la valeur effective est 1.

Alternatives

Les alternatives vous permettent d'exécuter différents blocs de code en fonction d'une condition.

Si

si ⟨condition⟩ alors
    // instructions…
sinonsi ⟨condition⟩ alors
    // instructions…
sinon
    // instructions…
finsi

L'instruction si exécute les instructions à l'intérieur du bloc alors si ⟨condition⟩ est vrai.

⟨condition⟩ peut être entouré de parenthèses.

⟨condition⟩ doit être une expression booléenne ou implicitement convertible en booléen.

Les blocs sinonsi sont facultatifs. Elles sont exécutées si le bloc si précédent est faux et que la ⟨condition⟩ du bloc sinonsi actuel est vrai.

Le bloc sinon est optionnel. Il est exécuté si tous les blocs si et sinonsi précédents sont faux.

Selon

selon ⟨expression⟩ c'est
    quand ⟨valeur⟩ =>
        // instructions…
    quand ⟨valeur⟩ =>
        // instructions…
    quand autre =>
        // instructions…
finselon

L'instruction selon exécute le bloc quand dont la ⟨valeur⟩ est égale à la valeur de ⟨expression⟩, ou le bloc quand autre si aucun des blocs quand ne correspond.

Le type de ⟨expression⟩ doit prendre en charge l'opérateur ==.

La ⟨valeur⟩ de chaque cas doit être connus au moment de la compilation et du même type que ⟨expression⟩.

Les cas ne définissent pas leur propre portée, donc attention aux collisions de noms de variables.

Expressions

Une expression est une combinaison de valeurs, de variables, d'opérateurs et de fonctions qui est évaluée pour produire un résultat. Les expressions sont des éléments fondamentaux en programmation et sont utilisées pour effectuer des calculs, prendre des décisions et manipuler des données.

Valeurs

Chaînes

Les littéraux de chaîne sont entourés de guillemets doubles ("). Ils ne peuvent s'étendre que sur une seule ligne.

Ils prennent en charge les séquences d'échappement.

Caractères

Les littéraux de caractères se composent d'un seul caractère entouré de guillemets simples (').

Ils prennent également en charge les séquences d'échappement.

Séquences d'échappement

Séquence d'échappement Signification
\a Alerte (bip, cloche)
\b Retour arrière
\e Caractère d'échappement
\f Saut de page
\n Saut de ligne
\r Retour chariot
\t Tabulation horizontale
\v Tabulation verticale
\\ Barre oblique inverse
\' Apostrophe ou guillemet simple
\" Guillemets doubles
\nnn L'octet dont la valeur numérique est donnée par nnn interprété comme un nombre octal
\xhh… L'octet dont la valeur numérique est donnée par hh… interprété comme un nombre hexadécimal
\uhhhh Point de code Unicode inférieur à 10000 hexadécimaux
\Uhhhhhhhh Point de code Unicode où h est un chiffre hexadécimal

TL;DR : identique au C, mais sans \? (car ce langage n'a pas de trigrammes).

Entiers

Les entiers sont des nombres sans point décimal. Les littéraux d'entier sont exprimés sous forme de séquence de chiffres décimaux.

Réels

Les littéraux de réel sont exprimés sous forme de séquence de chiffres décimaux avec un point décimal facultatif. Les chiffres avant le point décimal sont facultatifs.

Booléens

Les booléens sont soit vrai (true) soit faux (false).

Opérations

Le tableau suivant répertorie la priorité et l'associativité de chaque opérateur. Les opérateurs sont répertoriés de haut en bas, par ordre de priorité décroissant.

Priorité Opérateur Description Associativité
1 ()
[]
. 		Appel de fonction/procédure
Indice de tableau
Accès au composant de structures		 De gauche à droite
2 + -
NON
(type) 		Plus et moins unaires
Négation logique ou bit-à-bit
Cast		 De droite à gauche
3 * / % Multiplication, division et reste De gauche à droite
4 + - Addition et soustraction De gauche à droite
5 < <=
> >= 		Pour les opérateurs relationnels < et ≤ respectivement
Pour les opérateurs relationnels > et ≥ respectivement		 De gauche à droite
6 == != Pour les opérateurs relationnels = et ≠ respectivement De gauche à droite
7 XOR Disjonction exclusive (OU exclusif) logique ou bit-à-bit De gauche à droite
8 ET Conjonction (ET) logique ou bit-à-bit De gauche à droite
9 OU Disjonction (OU) logique ou bit-à-bit logique De gauche à droite

Lors de l'analyse d'une expression, un opérateur répertorié sur une ligne sera lié plus étroitement (comme par des parenthèses) à ses arguments que tout opérateur répertorié sur une ligne plus bas. Par exemple, l'expression a + b * c est analysée comme a + (b * c), et non comme (a + b) * c.

Les opérateurs qui se trouvent dans la même cellule (il peut y avoir plusieurs lignes d'opérateurs répertoriées dans une cellule) sont évalués avec la même priorité, dans la direction donnée.

Appels

nomFonction(⟨arg1⟩, ⟨arg2⟩, …)

Les appels sont utilisés pour invoquer des fonctions et des procédures. Ce sont des expressions qui donnent une valeur. Lors de l'appel d'une procédure, la valeur produite est de type void et ne peut pas être utilisée.

⟨arg1⟩, ⟨arg2⟩, … sont des paramètres effectifs.

Conversions

Voici un graphique des conversions autorisées entre les types.

flowchart LR
booléen -.faux &rarr; 0<br>vrai &rarr; 1.-> entier
entier -.0 &rarr; faux<br>&ne;0 &rarr; vrai.-> booléen
caractère -.définie par l'implémentation.-> entier
entier -.définie par l'implémentation.-> caractère
chaîneN["chaîne(<var>N</var>)"] --> chaîne
chaîneN ==Chaîne plus grande (<var>n</var> > 0)==> chaîneN2["chaîne(<var>N</var> + <var>n</var>) "]
entier --> réel
réel -.arrondir vers zéro .->entier
nomFichierLog
tableaux["<em>n'importe quel tableau</em>"]
structures["<em>n'importe quelle structure</em>"]
Loading
Forme du lien Type de conversion
Solide implicite
Pointillé explicite (avec syntaxe de conversion)
Épais affectation uniquement

Lorsqu'une conversion est définie par l'implémentation, le résultat dépend des règles de le langage cible.

Lorsque le résultat d'une conversion n'est pas spécifié, l'identité est supposée.

Paramètres

Paramètres formels

Les paramètres formels définissent les données qu'une fonction/procédure attend de l'appelant.

Syntaxe :

⟨mode-formel⟩ ⟨nom⟩ : ⟨type⟩

Paramètres effectifs

Les paramètres effectifs sont les valeurs effectives passées à une fonction/procédure, conformément à ses paramètres formels.

Syntaxe :

⟨mode-effectif⟩ ⟨nom⟩

Modes de paramètres

nom mode formel mode effectif description
entrée entF entE La valeur est copiée depuis l'appelant.
sortie sortF sortE La fonction/procédure initialise la valeur. La valeur est indéfinie avant d'être assignée.
entrée/sortie entF/sortF entE/sortE La fonction/procédure peut muter la valeur du côté de l'appelant.

🇺🇸 🇫🇷

Accueil

Le Zen du Pseudocode

Référence du langage Pseudocode

CLI compilateur

Clone this wiki locally