Structure d'un programme Pascal . Tutoriel Langage Pascal pour Atari ST (Pure Pascal, HiSpeed Pascal) et Turbo Pascal

Accueil

Lexique

Unités

Algorithmes

TUTORIEL

Sommaire Tutoriel

Structure d'un programme Pascal, sommaire

Premier programme en Pascal
Structure de base d'un programme Pascal
Définitions constante et variable
Délimitations de constantes chaînes
Constantes typées (spécifique à certains compilateurs)

Premier programme Pascal

Comme tout tutoriel de langage de programmation, on commencera par présenter l'affichage de "bonjour"

Program monprogramme;
Begin
    writeln('Hello world');
End.

Structure de base d'un programme Pascal

Un programme Pascal de base, selon la norme, s'écrit sous la forme:

Program monprogramme;
Begin
    {
    Détail du programme
    }
End.

Dans un programme Pascal, tout ce qui se trouve entre accolades ({ et }) est un commentaire et n'est pas compilé et exécuté. Il existe un autre moyen d'utiliser les commentaires, entre (* et *). Vous pouvez alors insérer un commentaire dans un autre commentaire.

Toute instruction, fonction, procédure, déclaration etc, toute ligne de code en Pascal, se termine par le point virgule ";" excepté juste avant la clause "else" et le "end" de fin de programme. Le point virgule indique au compilateur que la commande en cours s'achève ici.

La taille des lignes de scripts Pascal est limitée dans la grande majorité des compilateur (146 caractères pour Turbo Pascal 5, 255 caractères pour Pure Pascal etc). Si une ligne dépasse cette limite, votre compilateur vous rapellera à l'ordre. Attention aux caractères de fins de lignes qui diffèrent suivant les compilateurs et dépendant de leur environnement (entre Unix ou DOS).

Un programme Pascal peut commencer par le mot clé program suivi d'un identifiant. Dans la majorité des compilateurs, la ligne "Program" peut être omise! Dans les faits, la commande "Program" ne sert à rien (sauf à "nommer" le fichier programme compilé)! En cas de passage de Paramètres (qui est un "texte" fourni par un utilisateur dans une ligne de commande ou par un autre logiciel), cela se fait par 2 fonctions, au moins présent depuis Turbo Pascal 5 (et la majorité des compilateurs) : ParamStr et ParamCount et ce, sans présence du mot clé "program".

Dans un programme Pascal, tout élément est insensible à la casse! C'est à dire que le code ci-dessus, aurait pu être écrit...

ProGRam MonPrograMme;
begiN
    {
    Détail du programme
    }
END.

... sans erreur de compilation, contrairement aux autres langages de programmation (C, Java, PHP, JavaScript Python etc), sensibles à la casse, ainsi que pour MODULA 2 (le successeur de Pascal). Un autre langage que le pascal, le BASIC des années 80, est, lui-aussi, insensible à la casse.
Le coeur d'un programme pascal est compris entre les mots Begin et END.. NOTEZ bien que le end de fin de programme se termine ici par un POINT alors que dans tous les autres blocs d'un programme pascal, end se termine par un POINT-VIRGULE.

Un programme Pascal complet, a la structure suivante:

Program monprogramme;
USES {liste d'unités pascal};
CONST
    {
    Déclarations de constantes
    }
TYPE
    {
    Déclarations de types
    }
VAR
    {
    Déclarations de variables
    }
{
Déclarations de fonctions et procédures
}

Begin
    {
    Détail du programme
    }
End.

La clause USES sert à déclarer la liste des unités (équivalent des librairies en C) à utiliser dans le programme.
Les déclarations de constantes, types, variables, fonctions et procédures sont optionnels et ne doivent être utilisés que si vous en avez la nécessité. En langage Pascal, le programme doit être structuré dans cet ordre. Les déclarations de variables doivent être définis avant le coeur du programme dans l'ordre indiqué ici. Le langage Pascal permet ainsi une bonne lisibilité du code.
En Langage C : les variables sont déclarées avant le coeur du programme mais sans le mot clé "var". Il n'y a pas de déclarations de types en C, juste la définition de structures.

Nous approfondirons les TYPEs, VARs, fonctions et procédures dans d'autres pages du tutoriel.

Pour les éléments de langage Pascal (Identifiants, Valeurs numériques, Constantes, Commentaires et Longueurs de lignes), je vous invite à consulter cette page issus de la documentation de Pure Pascal mais applicables à tous les compilateurs Pascal.

Définitions constante et variable

Constante : une constante est un identifiant ayant toujours la même valeur SCALAIRE. En général, les compilateurs remplacent les occurences d'un identifiant dans un programme par la "valeur" qui lui est attribué. Cette valeur est un texte qui lui même sera interprété tel que défini dans le langage. Exemple:

CONST
    reel = 'reel';
    PI = 3.14159;
VAR
    bidul: real;
    texte: string[5];
begin
    bidul:=PI;{PI sera remplacé par 3.14159}
    texte := reel; {reel sera remplacé par 'reel'}
end.

Les constantes n'existent pas dans tous les langages de programmation. Elles servent, par exemple, à ne pas retaper une valeur précise à chaque fois qu'on en a besoin (comme Pi dans cet exemple. Attention! Dans Pascal, Pi est déjà prédéfinie!).

Variable : dans tous langages de programmation, une variable est un emplacement mémoire réservé par le programme, pouvant changer de valeur à tout moment, avec un type attribué lors de la création de cette variable. Suivant le langage, la variable nécessite soit d'avoir un type déclaré au préalable (Pascal, C, Java, Modula 2) ou pas (PHP, JavaScript, Python). Dans les langages à typage prédéfini, il existe des moyens de changer temporairement le type de ces variables (En Pascal, à l'aide de fonctions prédéfinies par les compilateurs). Dans les langages sans typage prédéfini, le langage utilise un processus pour accorder un type à la variable lors de son initialisation suivant le champs de types que ce langage gère. Exemple en Pascal :

VAR
    surface, perimetre : real;
    i : byte;
    rayon_cercle : array [0..20] of real;
    tab_nom : array [0..20] of String;

Délimitations de constantes chaînes

Il existe 2 branches de compilateurs Pascal concernant les caractères définissant les limites de chaînes:

La branche "Turbo Pascal" (dont Pure Pascal, Free Pascal/Delphi et Hispeed Pascal) qui a choisi de délimiter les constantes de type "char" et "string" uniquement avec des guillemets simples. Exemple:
```
var
   Toto : string[20];
begin
    Toto:='Marcel';{Utilisable sur tous les compilateurs Pascal}
end.
```
La branche "Watcom Pascal" dont fait partie Alice Pascal sur Atari/PC, et qui se dit "compatible avec la norme ISO Pascal de 1983" peut délimiter les constantes chaînes soit avec des doubles guillemets, soit avec des guillements simples. Les constantes de type char sont délimitées par des guillemets simples uniquement. Exemple :
```
var
   Toto : string[20];
begin
    Toto:="Marcel";{Utilisable par un nombre limité de 
    compilateurs tels Alice Pascal ou Watcom}
end.
```

Il en résulte que, pour rendre vos programmes pascal compatibles avec tous les compilateurs, il est préférable d'utiliser le simple guillemet pour délimiter les constantes chaînes.

Constantes typées (spécifique à certains compilateurs)

Le compilateur Pure Pascal (ainsi que Free Pascal/Delphi) permet la déclaration de constantes typées. Il est un des seuls à proposer cette structure en Pascal (Turbo Pascal 7 ne le propose même pas!)! Pour comprendre ce que font les constantes typées, compilez et exécutez ce programme sous Pure Pascal (ou free pascal/delphi):

const
    tableau1 : array [ 0 .. 3 ] of byte = ( 0, 2, 3, 1 );
    tableau2 : array [ 0 .. 3 ] of word = ( 5, 32, 1300, 250 );
var
    montab :  array [ 0 .. 3 ] of byte;
    i:byte;
begin
    writeln('Valeur de l''élément tab1[1] : ',tableau1[1],
        ', de taille ',sizeof(tableau1[1]));
    writeln('Valeur de l''élément tab2[3] : ',tableau2[3],
        ', de taille ',sizeof(tableau2[3]));
    for i:=0 to 3 do
        montab[i]:=tableau1[i];
    writeln('Valeur de l''élément montab[2] : ',montab[2],
        ', de taille ',sizeof(montab[2]));
    montab[2]:=59;
    writeln('Valeur de l''élément montab[2] modifié : ',montab[2],
        ', de taille ',sizeof(montab[2]));
    readln;
end.

Les constantes typées permettent de stocker des valeurs sur des variables "constante" ayant des types prédéfinis.

Elles sont un moyen rapide d'initialiser, par exemple, un tableau ou des variables de types structurés comme cela se fait avec les langages de scripts tels PHP ou JavaScript, à part qu'ici, cela nécessite de créer des variables à initialiser avec les valeurs de ces constantes (comme indiqué dans cet exemple). En fait c'est le seul moyen d'initialiser rapidement avec des scalaire, des éléments de variables tableaux sans devoir les initialiser élément par élément : par exemple, si vous voulez initialiser une grille de sudoku dans un programme Pascal sans passer par un fichier. Cependant il est plus judicieux pour des grosses séries de données de passer par des fichiers si vous n'avez besoin que d'une unité de tableau à la fois.

Il est possible de changer les valeurs de ces "constantes typées", pour garder une certaine compatibilité avec Turbo Pascal, bien que cela soit déconseillé. Dans ce cas, si l'option du compilateur adéquat est cochée, lors de la compilation, le compilateur vous avertira par un warning que cette allocation de valeur n'est pas recommandée.

Ainsi, sur la déclaration précédente, vous pouvez très bien écrire, dans le corps du programme:

{... corps du programme ...}
tableau1[1]:=28;
{... etc ...}

Sommaire Tutoriel