LE LANGAGE PASCAL

.

OBJECTIFS

.

PASCAL

INTRODUCTION– HISTORIQUE

– DOMAINE D'APPLICATION

– AVANTAGES / DESAVANTAGES

DEFINITION DU LANGAGE– LES MOTS DU LANGAGE

– LES TYPES ET LES DONNEES

– LES INSTRUCTIONS

MODULARITE TURBO PASCAL CONSEILS CONCLUSION

HISTORIQUE 1968 CREATION PAR WIRTH

– 1970 PREMIER COMPILATEUR VERSION ZURICH

– BUT : ENSEIGNEMENT

1975 DEBUT DE NORMALISATION– UTILISATION CROISSANTE DANS L'INDUSTRIE

– 1976 VERSION UCSD P-CODE

1981 SECOND DRAFT ISO, NORMALISE BSI– 198X POPULARISATION DANS L'INDUSTRIE VIA TURBO-

PASCAL

1985 UTILISATION DECROISSANTE DANS L'INDUSTRIE– MAINTIENT DE LA COMPETITIVITE DE TURBO-PASCAL PAR

DES EXTENSIONS OBJETS

LES ENFANTS DE PASCAL

MODULA II – SUCCESSEUR CREE PAR WIRTH

– MODULAIRE

– UN CERTAIN SUCCES EN GB

ADA 83– CREE POUR LE DoD

– MODULAIRE

– GRANDES EXTENSIONS

DOMAINES D'APPLICATION

ENSEIGNEMENT– BUT INITIAL

– ADA PREFERE DANS L'ENSEIGNEMENT

PROGRAMMATION NON PROFESSIONNELLE– SUR PC

PASCAL

QUALITES :– LISIBILITE

– ENCOURAGE LES BONNE PRATIQUES

– BON NIVEAU DE VERIFICATION

DEFAUTS– PAS NORMALISE OU TROP TARD

– PORTABILITE

– INSUFFISANCES

– EN DECLIN

PASCAL

ZURICH VERSION DE BASE X: UCSD EXTENSIONS CLASSIQUE TP: EXTENSIONS TURBO PASCAL B.S.O.

– CROISE UTILISE A LA SFIM

– PEU PERFORMANT ET MODULAIRE

OREGON– CROISE UTILISE A LA SFIM

– PERFORMANT ET MODULAIRE

UNITES LEXICALES ENTIER

– 123, -123

REEL– 123.2, 123E-10

CARACTERE / CHAINE DE CARACTERES– 'C''est une chaine'

IDENTIFICATEURS– NOTATION_SFIM

– NotationBorland

COMMENTAIRES– { commentaire }

– (* commentaire *}

;

IDENTIFICATEURS

1er CARACTERE = A..Z– TP: '_'

ensuite : A..Z, 0..9, '_' MAJUSCULE = MINUSCULE MOT RESERVE OU IDENTIFICATEUR TRONQUE A N CARACTERES

STRUCTURE D'UN PROGRAMME PASCAL

PROGRAM NOM_DU PROGRAMME CONST

– DECLARATION DES CONSTANTES

TYPE– DECLARATION DES TYPES

VAR– DECLARATION DES VARIABLES

PROCEDURE|FUNCTION – DECLARATION D'UN SOUS-PROGRAMME

BEGIN– SUITE D'INSTRUCTION

END.

DECLARATIONS

NOM_CONSTANTE = VALEUR;– TP: NOM_CONSTANTE = EXPRESSION

– TP: NOM_CONSTANTE : TYPE = (...,...,);

NOM_TYPE = DECLARATION_DE_TYPE; NOM_VARIABLE : NOM_TYPE;

TYPES SIMPLES

– SCALAIRES

» BOOLEEN

» ENTIERS

» ENUMERATIONS

» CARACTERE

– REELS

COMPOSES– TABLEAUX

– ENREGISTREMENT

– ENSEMBLE

– POINTEURS

FICHIER

OPERATEURS SUR VARIABLES DE TOUS TYPES

AFFECTATION A := B; COMPARAISON = < <= >= > <> TP : @

TYPES ENTIERS

INTEGER– -MAXINT..+MAXINT

TP : INTEGER -32768..32767– SHORTINT -128..127

– LONGINT -214483648..2147483647

– BYTE 0..255

– WORD 0..65535

+ - * DIV MOD ODD ABS SQR TP : NOT AND OR XOR SHL SHR

TYPE CARACTERE

CHAR CHR(NOMBRE) TYPE CHAR ORD(caractere) TP : +

TYPES BOOLEENS

BOOLEAN– (false, true)

TP : BOOLEAN = BYTEBOOL– WORDBOOL, LONGBOOL

AND NOT OR TP : XOR

AUTRES TYPES SCALAIRES

INTERVALLES– MIN..MAX

ENUMERATION– COULEUR = (BLEU, BLANC, ROUGE)

– VALEURS NON IMPOSEES ( 0,1,2,3...)

– BLANC..ROUGE SOUS-INTERVALLES

OPERATEURS SUR TYPES SCALAIRES

SUCC(VARIABLE) PRED(VARIABLE) ORD(VARIABLE)

TYPE REEL

REAL (6)– TP : SINGLE (4), DOUBLE(8), EXTENDED(10), COMP(8)

OPERATEURS– +-*/

– SQR, SQRT

– SIN, COS, TAN

– EXP, LN

– TRUNC, ROUND

TP : CHAINES

STRING[N]– ARRAY[0..N] OF CHAR;

– TAILLE DYNAMIQUE

+ LENGTH

TABLEAUX

[PACKED]ARRAY[DEBUT..FIN,DEBUT..FIN,...] OF TYPE_ELEMENT;

TYPE MATRICE = ARRAY[-5..4, 1..10] OF REAL;

VAR M1,M2 : MATRICE; M1 := M2 M1[4] := M2[2] M1[4,2] := M2[2,2]

SET OF

TYPE ENSEMBLE = SET OF COULEUR VAR E1,E2,E3 : ENSEMBLE; E1 := [BLEU, BLANC] E1 := E2+E3 E1 := E2-E3 E1 := E2*E3 OK := BLEU IN E1

TYPE

RECORD

TYPE PERSONNE = RECORD

NOM : STRING[10];AGE : INTEGER;

END;VAR

LEON : PERSONNE;

LEON.NOM := 'LEON';

nom

age

WITHTYPE

PERSONNE = RECORDNOM : STRING[10];AGE : INTEGER;

END;VAR

LEON : PERSONNE;

WITH LEON DO BEGIN

NOM := 'LEON';AGE :=10;

END;

VARIANT RECORD

TYPE PERSONNE = RECORD

NOM : STRING[10];AGE : INTEGER;CASE CITOYEN : BOOLEAN OF

TRUE : (LIEU_NAISS : STRING[40]);FALSE:(PAYS : STRING[20];

LIEU_ARRIVEE : STRING[20];DATE_ARRIVEE : TDATE);

END;

VARIANT RECORD

NOM

AGE

CITOYEN

LIEU_NAISS PAYS

LIEU_ARRIVEE

DATE_ARRIVEE

FILE

FILE OF PERSONNE– HOMOGENE

– FORMAT BINAIRE

TEXT– FILE OF CHAR

– HETEROGENE

– FORMAT AFFICHABLE

ENTREES/SORTIES TOUS FICHIERS

RESET(F:FILE); REWRITE(F:FILE); PUT(F:FILE OF ELEMENT ,X:ELEMENT); FUNCTION GET(F:FILE OF

ELEMENT):ELEMENT; EOF(F:FILE);

ENTREES/SORTIES TEXT

READ(F, A, B, C); READLN(F, A, B, C); WRITE(F, A:LN, B:LN:DIGIT, C); WRITELN(F, A, B, C); EOLN(F);

POINTEUR

TYPE TLIEN = ^OBJET; VAR LIEN : TLIEN; NEW(LIEN); LIEN^=4 DISPOSE(LIEN); MARK RELEASE

LIEN

LIEN

ZONEDYNAMIQUE

NIL

LIEN NIL

LIEN 4

TYPE ANONYME

VAR LEON : RECORD

NOM : STRING[10];AGE : INTEGER;

END;

LEON.NOM := 'LEON';

TYPAGE FORT

TYPEX = INTEGER;Y = INTEGER;

VARA:X;B:Y;

BEGINA :=B;A := X(B); { EN TURBO PASCAL SEULEMENT }

END.

BLOC

BEGIN END

TANT QUE

WHILE CONDITION DO ACTION;

REPETER

REPEAT ACTION UNTIL CONDITION;

BOUCLE

FOR INDICE := DEBUT TO FIN DO ACTION(INDICE); FOR INDICE:=FIN DOWNTO DEBUT DO ACTION(INDICE);

CONDITION

PAS DE ';'

IF CONDITION THENACTION;

IF CONDITION THENACTION

ELSEAUTRE_ACTION;

CONDITION{ commentaire sur l'instruction complète }IF ( i = 2 )THENBEGIN { commentaire sur la branche } action2;ENDELSE IF ( j = 3 )THENBEGIN { commentaire sur l'autre branche } action;END.

AIGUILLAGE

case valeur_testee of cas_1 : traitement_1;

cas_2, cas_3 : traitement_2; . . . cas_n : traitement_n;

else traitement_autres_cas; END

TP

GOTO LABEL

PROCEDURE X;LABEL 10,20; { IDENT AUTORISE EN TURBO PASCAL}BEGIN

10:.........GOTO 10

END;

PROCEDUREPROGRAM DEMO;VAR A,B : INTEGER;

PROCEDURE SUB( X : INTEGER; { EN ENTREE } VAR Y: INTEGER) { EN SORTIE }BEGIN Y:=X; X:=2;END;

BEGIN SUB(A,B);END;

FONCTIONPROGRAM DEMO;VAR A,B : INTEGER;

FUNCTION FNC( X : INTEGER { EN ENTREE } ):INTEGER; { EN SORTIE }BEGIN FNC := X;END;

BEGIN A := FNC(B);END;

FORWARDPROCEDURE A(X:INTEGER); FORWARD;

PROCEDURE B;BEGIN A(4);END;

PROCEDURE A;BEGIN B; END;

EXTERNAL

TP: APPEL AUTRES LANGAGES

PROCEDURE A(X:INTEGER); EXTERNAL;

PROCEDURE EN PARAMETRE

PROCEDURE DERIVER(FUNCTION FNC(X:REAL):REAL;BEGIN ....END;

FUNCTION F1(Y:REAL):REAL;BEGINEND;

BEGIN DERIVER(F1);END;

TABLEAUX VARIABLES EN PARAMETRE

FUNCTION ADD(TAB :ARRAY[MIN..MAX:INTEGER]OF INTEGER):INTEGERVAR I,R:INTEGER;BEGIN

R := 0;FOR I:=MIN TO MAX DO

R:=R+TAB[I];END;

IMBRICATION/VISIBILITEPROGRAM P;

CONST A = 3; TYPE B = CHAR; VAR C : B; PROCEDURE X;

– CONST A = 4; TYPE B = INTEGER; VAR C : B;

– PROCEDURE Y;

» CONST A = 5; TYPE B = REAL; VAR C : B;

» PROCEDURE Z; BEGIN END

» BEGIN

» END

– BEGIN

– END;

BEGIN END.

PASCALLANGAGE NON MODULAIRE

UN SEUL SOURCE– MAINTENANCE

EXTENSION INCLUDE– {$I definitions.def }

– COMPILATION LONGUE

EXTENSION REFERENCE EXTERNE– NON PORTABLE

– DUPLICATION DES DEFINITIONS (SAUF PARTAGE PAR INCLUDE)

MODULARITE A LA SFIMEN PASCAL CROISE

M1.DEF

M1.PAS

M2.DEF

M2.PAS

include M1.DEF include M2.DEFinclude M1.REF

M1.REF M2.REF

trans_def_ref trans_def_ref

MODULARITE A LA SFIM

CROISE OREGON CROISE BSO DIGITAL

MODULARITE A LA SFIM

INTERFACE

CORPS

M1.DES

M1.PAS

BASE

DE

DONNEES

OSCAR

M1.ORE

Déclarations

importations

exportations

%include 'M1.PAS'

COMPILATION

UNITE TURBO-PASCAL

UNITE P;

INTERFACEUSES CRT,DOS;{ DECLARATIONS GLOBALES/EXPORTEE}

IMPLEMENTATIONUSES WINDOW;{ CODE DES SOUS-PROGRAMMES }

BEGIN{ INIITIALISATION }

END;

APPELS CROISES

INTERFACE

IMPLEMENTATION IMPLEMENTATION

INTERFACE

TURBO-PASCAL

MODULARITE INSPIRATION ADA ORIENTATION OBJET INSPIRATION C++ TURBO-VISION : BIBLIOTHEQUE ORIENTEE

OBJETS DOS TEXTE OBJECT-WINDOW : BIBLIOTHEQUE

ORIENTEE OBJETS WINDOWS BGI : BIBLIOTHEQUE GRAPHIQUE DOS

RECURSIVITE

FUNCTION FACTORIELLE(N:INTEGER):INTEGERBEGIN

IF(N=1)THENFACTORIELLE := 1;

ELSEFACTORIELLE := FACTORIELLE(N-1)*N;

END;

ARBRESTYPE LIEN=^NOEUD;NOEUD= RECORD

CLEF : T_CLEFINFO : T_INFO;

AVANT, APRES : LIEN;END;

VAR ARBRE:LIEN = NIL;

FUNCTION RECHERCHE(COURANT:LIEN,CLEF:LIEN):T_INFO;BEGIN

IF COURANT = NIL THENRECHERCHE := AUCUNE_INFO

ELSE IF COURANT^.CLEF = CLEF THENRECHERCHE := COURANT^.INFO

ELSE IF COURANT^.CLEF < CLEF THENRECHERCHE := COURANT^.AVANT

ELSERECHERCHE := COURANT^.APRES;

END;

CONSEILS LISIBILITE

TYPER ET DEFINIR DES CONSTANTES NOMMAGE LISIBLE PREFIXER LES GLOBAUX PAR LE NOM DE

L'UNITE– SFIM : CRT_AFFICHE(...)

– TP: CRT.AFFICHE(....)

INDENTER ET COMMENTER PAS DE GOTO SEPARER LES SOUS-EXPRESSIONS NOM_UNITE.NOM POUR LES EXTERNES

CONSEILS COMMUNICATION

LIMITER LES VARIABLES GLOBALES TRANSMETTRE PAR PARAMETRE UTILISER DES RECORD POUR LIMITER LE

NOMBRE DE PARAMETRES TRANSMETTRE PAR VARIABLE POUR LES

GROS OBJETS

CONSEILS SECURITE

PREVOIR LES CAS AUTRES (ELSE DANS CASE ET IF)

UTILISER LES () CONTROLER LES PARAMETRES D'ENTREE LA MEMOIRE N'EST PAS INEPUISABLE

– RECURSIVITE

– ALLOCATION DYNAMIQUE

TRAITER LES CAS D'ERREUR

CONSEILS SOUPLESSE

PARAMETRER LES LIMITATIONS– EX TAILLE DE TABLEAUX

NE PAS LIMITER– UTILISER DES LISTES DYNAMIQUES

CONSEILS MISE AU POINT

PREVOIR DES TRACES PREVOIR UN PROGRAMME DE TEST DES

UNITES

CONSEILS UNITES

CREER DES TYPES RECORD– LES CHAMPS SONT LIES LOGIQUEMENT

– LES COMMUNICATIONS SONT GLOBALES

DEFINIR LE TYPE– UNE SEULE VARIABLE -> DANS L'IMPLEMENTATION

– PLUSIEURS VARIABLES -> DANS L'INTERFACE

REGROUPER DANS L'UNITE– LES SOUS-PROGRAMMES AGISSANT SUR LE TYPE

LES UNITES UTILISATRICES PEUVENT– CREER DES CONSTANTES/VARIABLES DU TYPE

– N'AGISSENT SUR LA VARIABLE QUE VIA LES SOUS-PROGRAMMES DE L'UNITE PROPRIETAIRE

CONSEILS USAGETURBO-PASCAL

UTILISER LES UNITES UTILISER LES OBJETS

PASCAL OR NOT PASCAL

PASCAL– ALLERGIE A LA SYNTAXE DU C

– ADA NON DISPONIBLE

– PROGRAMMATION OCCASIONNELLE

NOT PASCAL– C : PORTABILITE

– ADA : PROJET LOURD

– C++ : PROGRAMMATION PROFESSIONNELLE

– BASIC : INTEGRE A OUTILS