Cours Modula

Cours de Certains Modula-3 utiles Interfaces en PDF


Télécharger Cours de Certains Modula-3 utiles Interfaces en PDF

★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


Cours de Certains Modula-3 utiles Interfaces en PDF

...

L'histoire

Niklaus Wirth, ETH, Suisse

1970 Pascal

1975 Modula

1979 Modula-2, première mise en œuvre sur PDP-11

1980 Définition du langage, Rapport technique

1981 Compilateurs hors ETH

Oberon

  • langue du système d'exploitation
  • moins d'emphase en temps réel

Modula-3

  • DÉC
  • orienté objet
  • ramassage des ordures 2

Objectifs

  • Faciliter la construction de grands programmes. Le concept de module. Compilation séparée.
  • Soyez un langage de programmation de systèmes proches.

Contrôle sur l'allocation. ADRESSE. ..

  • Soutenir la programmation simultanée. NEWPROCESS,

TRANSFERT, IOTRANSFER

  • Une syntaxe plus systématique qu'en Pascal

Modula-2

Capitales

Les mots réservés sont écrits avec CAPITALES.

Le compilateur distingue les majuscules des non majuscules.

commentaires

Peut être imbriqué.

(* Ceci est un commentaire *)

(* (* *) *)

Types de données

ENTIER, CARDINAL, BOOLEAN, CHAR

VAR ch: CHAR;

ch: = 'a';

ORD ('A') = 65

CHR (65) = 'A'

RÉEL

VAR x: REAL;

x: = 5; (* Faux *)

x: = 5,0; (* Correct *)

Types d'énumération

TYPE

optype = (plus, moins, fois, diviser);

VAR

op: optype;

...

op: = plus;

INC (op); (* moins *)

DEC (op); (* plus encore *)

INC (op, 3); (* diviser *)

op: = VAL (optype, 2); (* fois *)

ORD (moins); (* 1 *)

Tableaux

(* Modula-2 *) (* Pascal *)

TABLEAU [1..10] D'INTEGRE; tableau [1..10] de nombre entier;

...

Type de type

Indice = [1..10]; Indice = 1..10;

VAR var

a: ARRAY Index OF INTEGER; a: tableau [Index] de nombre entier;

...

ARRAY [1..m], [1..n] OF REAL tableau [1..m, 1..n] of real;

Les cordes

Représenté comme ARRAY OF CHAR

Module de bibliothèque Strings

Records

TYPE

PersonType = RECORD

nom: ARRAY [0..79] OF CHAR:

âge: [0,110];

sexe: (homme, femme);

FIN;

VAR

anders: PersonType;

...

anders.age: = 28;

Enregistrements avec variante

TYPE

ComponentType = (moniteur, imprimante);

StringType = ARRAY [0..19] OF CHAR;

MechanismType = (dotMatrix, laser);

SystemComponent = RECORD

fabricant: StringType;

modèle: StringType;



Type de cas: ComponentType OF

moniteur: couleur: BOOLEAN;

numLines, numColumns: CARDINAL |

imprimante: mécanisme: MechanismType;

vitesse: CARDINAL

FIN;

FIN;

VAR

composant: SystemComponent;

...

composant.manufacturer: = 'IBM';

composant.kind: = imprimante;

composante.vitesse: = 10000;

Le champ tag peut être omis

RECORD

ÉTUI: BOOLEAN OF

TRUE: a: INTEGER; |

FAUX: b: REAL

FIN

FIN;

Un enregistrement peut avoir plus d'une variante.

Les variantes peuvent être imbriquées.

Set Types

Comme en Pascal

Pointeurs

VAR

p, q: POINTEUR AU CARDINAL;

c: CARDINAL;

...

c: = p ^;

q ^: = c;

q ^: = p ^;

q: = p;

NEW (p) alloue de la mémoire pour un objet dynamique du type pointé par p.

DISPOSE (p) libère la mémoire.

Pour utiliser NEW et DISPOSE, il faut importer STORAGE.ALLOCATE et STORAGE.DEALLOCATE

Types de procédure

TYPE

WriteProcedure = PROCEDURE (INTEGER);

...

PROCEDURE WriteDecimal (i: INTEGER);

COMMENCER

...

END WriteDecimal;

PROCÉDURE WriteHex (i: INTEGER);

COMMENCER

...

FIN WriteHex;

...

VAR

WP: WriteProcedure;

COMMENCER

WP: = WriteDecimal;

WP (10);

WP: = WriteHex;

WP (10);

FIN; 12

Les déclarations

Affectation

a: = b + 3;

Répétition

PENDANT i <= limite DO

...

FIN;

RÉPÉTER

...

JUSQU'À i> limite;

Conditions

SI a = b ALORS

...

ELSIF a <b ALORS

...

AUTRE

...

FIN;

Choix multiple

CASE couleur DE

vert: ... |

bleu: ... |

rouge: ...

AUTRE

...

FIN

14

Itération

POUR i: = 1 TO n DO

...

FIN;

POUR i: = 1 À n PAR 2 DO

...

FIN;

Appel de procédure

P (a, b)



Appel de fonction

x: = F (a, b) + 3;

En référence

AVEC p DO

...

FIN; 15

Déclarations non en Pascal

Boucle infinie

BOUCLE

...

FIN;

Sortie de boucle infinie

SORTIE;

Retour de procédure

RETOUR a + b;

Retour alternatif de procédure

REVENIR

Les déclarations non trouvées dans Modula-2 vont à L1;

Procédures

Procédures fonctionnelles et procédures "ordinaires"

Deux types de paramètres formels: paramètres variables et paramètres de valeur

Paramètres variables précédés de VAR

Une modification d'un paramètre formel variable affecte le paramètre réel (les valeurs sont transmises en dehors de la procédure). (Appel par référence)

Un paramètre de valeur obtient sa valeur en copiant la valeur du paramètre actuel.

Paramètres du tableau ouvert

PROCÉDURE Somme (s: TABLEAU DE CARDINAL): CARDINAL;

VAR

i, somme: CARDINAL;

COMMENCER

somme: = 0;

POUR i: = 0 À HIGH (s) DO

somme: = somme + s [i];

FIN;

RETOUR somme;

FIN Somme;

Appelé par

VAR

v: = ARRAY [m..n] OF CARDINAL;

...

k: = somme (v);

v [m] est mappé sur s [0]

v [n] est mappé sur s [n-m]

HAUT (s) = n - m

Seul le premier index d'un tableau multidimensionnel

Programmation de systèmes

TYPE

MOT

OCTET

ADRESSE

(* affectation compatible avec tous les types de pointeurs *)

PROCEDURE ADR (x: AnyType): ADDRESS;

(* Retourne l'adresse de x *)

TAILLE DE PROCÉDURE (VAR v: AnyType): CARDINAL;

(* Retourne la taille nécessaire pour v *)

PROCEDURE TSIZE (AnyType): CARDINAL;

(* Retourne la taille nécessaire pour une variable du type donné *)

Plus NEWPROCESS, TRANSFER, IOTRANSFER 20

Modules

La principale différence entre Pascal et Modula-2

  • Un programme est constitué de modules.
  • L’un des modules est le programme principal.
  • Les autres sont des modules de bibliothèque.
  • Compilé séparément.
  • Les modules locaux sont des modules définis à l'intérieur d'autres modules.

- pas tellement utilisé.

21

Les modules agissent comme des murs.

Les entités déclarées à l'intérieur d'un module ne sont visibles à l'extérieur du module que si elles ont été exportées par le module.

Pour qu'un autre module utilise une entité exportée, le module doit importer l'entité.

Un module peut importer de plusieurs autres modules.

Un programme complet Modula-2 consiste en un ensemble de modules interconnectés = graphe de dépendance.

Modules de bibliothèque

Deux parties: une partie définition et une partie implémentation.

La partie définition spécifie les entités exportées par le module.

Constitue l'interface visible de l'extérieur du module.

La partie implémentation contient la déclaration complète de l'entité, c'est-à-dire l'implémentation. Module principal

Nom du module ";"



{importation}

{déclarations}

[COMMENCER

StatementSequence]

FIN nom "."

25

Importation

Les éléments pouvant être importés par un autre module doivent être définis dans le module Définition (exporté par défaut) import = [FROM name] IMPORT Liste de noms ";" namelist peut contenir des modules, procédures, variables, types, constantes

"Déqualification" sélective

IMPORT M1;

DE M1 IMPORT x, y;

x et y peuvent être référencés directement. Autres entités exportées de

M1 peut être référencé avec M1.entity

Modules de définition

DEFINITION MODULE nom ";"

{importation}

{définition}

FIN nom ";"

définition =

CONST {constante décl. ";"} |

TYPE {name ["=" type] ";"} |

VAR {nom: type ";"} |

ProcedureHead ";"

27

Modules d'implémentation

CompilationUnit =

DéfinitionModule |

[MISE EN ŒUVRE] ProgramModule

ProgramModule = nom du MODULE ";"

{importation}

{déclaration}

[COMMENCER

StatementSequence]

FIN nom "."

Exemple

MODULE D'IMPLANTATION TreeConstructor;

...

COMMENCER

...

FIN TreeConstructor.

Types opaques

Un type de données dont la structure est masquée dans un module.

La valeur d'un type opaque doit être un pointeur.

Ainsi, le compilateur sait combien d’espace doit être alloué à une variable de type opaque.

DEFINITION MODULE TreeConstructor;

À partir de RuleHandler IMPORT

GetConsequent, GetAntecedent;

...

TYPE TreePtr;

PROCÉDURE MakeTree (VAR T: Treeptr);

PROCÉDURE Traverse (T: TreePtr);

FIN TreeConstructor.

MODULE D'IMPLANTATION TreeConstructor;

...

TYPE

Arbre = RECORD

...

FIN;

TreePtr = POINTER TO Tree;

...

FIN TreeConstructor.

Compilation séparée

Une modification dans un module de définition signifie que tous les modules importés à partir du module de définition modifié doivent être recompilés.

Ensuite, tous les modules importés à partir des modules recompilés doivent être recompilés, etc.

Une modification dans un module d'implémentation entraîne uniquement une recompilation de ce module.



44