Section courante

A propos

Section administrative du site

Une synopsis

Cette page est un aperçu de Pascal pour les lecteurs n'étant pas déjà familiarisés avec le langage de programmation. Ceux ayant déjà utilisé le UCSD Pascal, ils peuvent l'ignorer. Ceux n'ayant utilisé que d'autres langages de programmation, ou d'autres dialectes de Pascal, devraient la lire afin de se faire une idée du langage et de l'implémentation UCSD.

Un programme Pascal est relativement formel, comparé à d'autres langages de programmation tels que BASIC, FORTRAN ou PL/1. Les restrictions de Pascal exigent du programmeur une plus grande discipline, mais les avantages incluent :

Toutes ces choses tendent à rendre un programme moins sujet aux erreurs et plus facile à maintenir. L'exactitude et la maintenabilité sont les objectifs de la programmation structurée, et Pascal a été conçu pour promouvoir un tel style.

Cette page est informelle et a pour but de transmettre la «saveur» d'un programme Pascal sans entrer dans les détails. Ce que nous décrivons ici devrait vous donner une idée de ce à quoi vous pouvez vous attendre dans la page qui suit.

La forme d'un programme

Le texte d'un programme Pascal commence par un titre, suivi d'une séquence facultative de déclarations, puis d'une liste d'instructions entourées des mots BEGIN et END, et se termine par un point.

Voici un programme trivialement simple :

  1. Program Hello;
  2. BEGIN
  3.  WriteLn('Bonjour, mon premier programme');
  4. END.

Déclaration

Toutes les données d'un programme Pascal ont un «type» donné.

Certains types font partie du langage de programmation (on dit qu'ils sont «prédéclarés»). Il y a les types numériques Integer, Real et LongInt (entier long). Il y a le type logique Boolean et le type caractère Char. Les séquences de caractères peuvent être représentées par le type STRING.

Il existe des constantes de différents types :

Valeur Types
1523 integer
3.14159 real
'G' char
'Bonjour' string

Des noms symboliques («identificateurs») peuvent être attribués aux constantes :

  1. Const
  2.  Year=1523;
  3.  Pi=3.14159;
  4.  Initial='G';
  5.  Message='Bonjour';

Dans un programme Pascal, toutes les variables doivent être déclarées. Le type d'une variable ne change jamais :

  1. Var
  2.  yr_date:Integer;
  3.  Factor:Real;
  4.  Letter:Char;
  5.  Greeting:String;

(Ce type de variable en Pascal est beaucoup plus strict que dans certains autres langages (par exemple, FORTRAN, PL/1). Pour qu'un programme soit compilé avec succès, les variables doivent être traitées selon les règles de leur type.)

Le programmeur peut définir de nouveaux types scalaires. Un scalaire est une séquence finie de valeurs portant des noms symboliques :

  1. Var WeekDay:(Sun,Mon,Tue,Wed,Thu,Fri,Sat);

Des sous-intervalles de scalaires sont également disponibles :

  1. Var
  2.  WorkDays:Mon...Fri; { Intervalle de WeekDay }
  3.  Rating:1..10; { Intervalle d'Integer }

En plus des types simples, des scalaires et des sous-intervalles, Pascal fournit les types structurés ARRAY, RECORD et SET. Un ARRAY est un tableau de valeurs (toutes d'un même type) regroupées sous un nom unique. Un enregistrement est un groupe de valeurs, éventuellement de types différents. Un SET est une collection de valeurs extraites d'un seul type de base.

Des structures dynamiques telles que des listes chaînées et des arbres de recherche peuvent être créées à l'aide de «pointeurs». Un pointeur est une variable pointant vers une autre variable d'un type donné. La variable pointée n'a pas de nom ; elle est allouée ou désallouée selon les besoins.

Enfin, de longues séquences de valeurs peuvent être contenues dans un FILE Dans UCSD Pascal, un FILE est associé à une entité physique telle qu'un fichier sur disque ou un périphérique.

Évaluation

De nouvelles valeurs peuvent être calculées en combinant des valeurs existantes dans des « expressions ». Le résultat d'une expression est d'un type particulier. Différents opérandes sont définis pour différents types.

Les expressions numériques et les opérateurs numériques suivent des conventions algébriques courantes :

a + b + c
1.5 * ((i-1)) * 2)
1 + 2 - 3 * 4

Des opérateurs relationnels peuvent être utilisés. Les expressions avec des opérateurs relationnels renvoient un résultat de type Boolean :

  1. Date = Today
  2. Date <> Yesterday { <> indique non-égalité }
  3. Profit > 10000

Pascal fournit également quelques fonctions intrinsèques, pouvant apparaître dans des expressions :

  1. PI * Sqr(radius)
  2. Sqrt(Sqr(b) - 4*a*c)
  3. Odd(factor) { Une fonction booléenne }

Les fonctions peuvent également être définies par l'utilisateur.

Pour initialiser une variable ou modifier sa valeur, une affectation peut être utilisée. Le symbole de l'affectation est ':='. Par exemple :

  1. is_odd:=Odd(factor);
  2. area:=Width*Height;
  3. round_area:=PI*Sqr(radius);

Chacune de ces lignes est appelée «instruction d'affectation». Le point-virgule (':') est utilisé pour séparer les instructions, comme indiqué.

Action

En général, les instructions en Pascal sont exécutées en commençant par la première instruction du programme principal et en continuant jusqu'à la fin. Les instructions de contrôle de flux peuvent être utilisées pour modifier l'ordre dans lequel les instructions sont exécutées en prévoyant des décisions et des répétitions. Des fonctions et des procédures peuvent être utilisées pour diviser le programme en parties intelligibles et améliorer son organisation.

L'instruction IF est utilisée pour une décision simple à double sens (True/False) :

  1. If Profit > 10000 Then plan_party;
  2. If Profit > 10000 Then plan_party
  3.                   Else call_meeting;

L'instruction CASE est utilisée pour les décisions à plusieurs voies :

  1. Case Month of
  2.  Apr,Jun,Sep,Nov:Days:=30;
  3.  Jan,Mar,May,Jul,Aug,Oct,Dec:DSys:=31;
  4.  Feb:If LeapYear Then Days;=28
  5.                  Else Days:=29;
  6. End;

Il existe trois structures de boucle en Pascal. L'instruction WHILE a le format la plus générale suivant :

  1. While Not_Done do Fix_It;

L'instruction REPEAT est comme un WHILE, mais s'exécute toujours au moins une fois :

  1. Repeat
  2.  Fix_It
  3. Until Fixed;

L'instruction FOR utilise une variable de contrôle et se répète un nombre donné de fois :

  1. For I:=1 to 10 do Clear;

Le Pascal inclut également des moyens de réaliser des ramifications comme dans BASIC ou FORTRAN, mais ceux-ci ne sont généralement utilisés que dans des situations d'urgence, voire pas du tout.

Une PROCEDURE est une portion de code autonome. Le format d'une procédure ressemble beaucoup à celle d'un programme :

  1. Procedure Bonjour;Begin
  2.  WriteLn('Bonjour, comment allez-vous ?');
  3. End;

... et elle est appelée par une instruction se composant simplement du nom de la procédure :

  1. Bonjour;

Des paramètres peuvent être passés à une procédure lorsqu'elle est appelée :

  1. Procedure Area(Height,Width:Integer;Var Result:Integer);Begin
  2.  Result:=Height*Width;
  3. End;

Cela pourrait être appelé par une déclaration telle que :

  1. Area(12,5,Rectangle);

Dans cet exemple, Width et Height sont des paramètres de valeur, tandis que Result est un paramètre variable. Dans le code appelant la procédure, les paramètres de valeur ne sont pas affectés, tandis que les paramètres variables peuvent être modifiés par la procédure (dans l'exemple, 'Rectangle' sera défini sur la zone que la procédure calcule).

Une FUNCTION ressemble beaucoup à une procédure (PROCEDURE), sauf qu'elle renvoie un résultat :

  1. Function Area(Height,Width:Integer):Integer;Begin
  2.  Area:=Height*Width;
  3. End;

Comme nous l'avons vu, une fonction est appelée en l'utilisant dans une expression :

  1. Rectangle:=Area(12,5);

... ou :

  1. If Area(New_Height,New_width) <> 0 Then Print_result;

Pascal permet la récursivité. Une procédure ou une fonction peut s'appeler elle-même. Certains algorithmes sont beaucoup plus élégants lorsqu'ils sont exprimés de manière récursive ; Pascal peut les implémenter directement.

Communication

Les entrées/sorties simples (de caractères) sont réalisées avec les procédures intrinsèques READ, READLN, WRITE et WRITELN. Les fonctions booléennes intrinsèques EOF (fin de fichier) et EOLN (fin de ligne) sont fournies pour le contrôle.

Si aucun autre fichier n'est spécifié, ces valeurs intrinsèques d'entrées/sorties font référence aux fichiers standards INPUT ou OUTPUT. Dans UCSD Pascal, INPUT et OUTPUT sont tous deux équivalents à la console du système.

Les entrées/sorties de fichier (enregistrement) utilisent READ, WRITE, EOF, PUT et GET. Dans UCSD Pascal, un fichier utilisé dans un problème peut faire référence à un fichier de disque système ou à un périphérique d'entrée/sortie. L'accès aléatoire est disponible avec la fonction intrinsèque SEEK.

Le UCSD Pascal permet aux périphériques d'être contrôlés directement (et rapidement) par un certain nombre d'éléments intrinsèques, notamment UNITREAD et UNITWRITE.

En UCSD Pascal, un fichier peut également être déclaré sans type et manipulé par les intrinsèques BLOCKREAD et BLOCKWRITE Ceux-ci sont principalement utilisés pour transférer rapidement de grandes quantités de données.

Modularité

Le code devant être utilisé par plusieurs programmes peut être compilé séparément. Un tel paquet de code est appelé UNIT (unité). Un UNIT se compose d'une partie INTERFACE, d'une partie IMPLEMENTATION et d'un code d'initialisation/de terminaison facultatif (les unités (UNIT) sont une extension UCSD Pascal).

Une partie INTERFACE contient des déclarations et des entêtes de procédure ou de fonction. Ceux-ci peuvent être utilisés par le programme (ou une autre unité) qui USES l'unité.

Une partie IMPLEMENTATION contient d'autres déclarations et le code de la procédure et des fonctions ayant été déclarées dans la partie INTERFACE. Toutes ces informations sont strictement privées pour l'unité.

Il est possible de modifier la partie IMPLEMENTATION d'une UNIT (pour améliorer un algorithme, par exemple) et de la recompiler. Si la partie INTERFACE n'a pas été modifiée, les programmes et les unités utilisant l'unité peuvent continuer à le faire : il n'est pas nécessaire de les recompiler également.

Plusieurs unités peuvent être regroupées dans un seul fichier de code (souvent appelé bibliothèque).

Les unités (UNIT) peuvent également être utiles pour «diviser» un programme trop long pour être compilé en un seul morceau.

Divers

Cette section décrit certaines fonctionnalités ne concernant que UCSD Pascal.

Une procédure ou une fonction peut être déclarée comme une procédure ou une fonction de segment, auquel cas le système peut la remplacer indépendamment du programme principal. Cela peut être utile lors de l'exécution de programmes volumineux occupant beaucoup d'espace au moment de l'exécution.

La concurrence est disponible dans les versions ultérieures du p-System. Une portion de code s'exécutant simultanément est appelée un PROCESS. Un PROCESS ressemble à une procédure. Il n'est pas appelé, mais une instance de celui-ci est mise en exécution par un appel à l'intrinsèque START. Les processus peuvent être coordonnés par les intrinsèques SIGNAL et WAIT.

Il est possible d'écrire une procédure ou une fonction en langage assembleur et de l'appeler à partir d'un programme Pascal. Cela se fait en la déclarant EXTERNAL. La routine du langage assembleur («code natif») est responsable de la conformité aux conventions d'appel de Pascal.

Enfin, il existe un certain nombre d'«options de compilation» permettant :

Exécution

Une fois qu'un programme UCSD Pascal a été compilé, il est exécuté sur le p-System à l'aide des commandes R(un ou eX(excute).

Pendant l'exécution d'un programme, un certain nombre de choses peuvent provoquer ce que l'on appelle une «erreur d'exécution». Une erreur d'exécution peut être provoquée par un bogue dans le programme ou par une erreur commise par la personne exécutant le programme. Lorsqu'une erreur d'exécution se produit, le système interrompt le programme et affiche un message sur la console ressemblant à ceci :

Divide by zero
Segment TEST     Proc# 1     Offset# 6
Type <space> to continue

Si le programme est en panne, il faut le réparer. Si l'opérateur du programme est en panne, le programme peut (généralement) être redémarré par la commande U(ser-restart.

Les descriptions des commandes p-System et la liste complète des erreurs d'exécution possibles peuvent être trouvées dans la section UCSD p-System.



Dernière mise à jour : Lundi, le 29 juillet 2024