Post on 25-Jan-2016
description
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