Cartea de Programare

dr. Tudor Blnescu, erban Gavril, conf. dr. Horia Georgescu, dr.
Marian Gheorghe,
Liviu Sofoea, prof. dr. Ion "Vduva
IPffiOGlMMAMEA N LMBAHELIE
PASCAL TURBO
PASCAL
volumul I
Limbajul Pascal. Concepte fundamentale
(Q)
EDITURA TEHNICA
Bucureti, 1992
Copyright 1992, Editura

Tehnic Toate drepturile asupra
acestei ediii snt* rezervate
editurii
Adresa : Editura Tehnic

Pia{a Presei Libere, 1 33
Bucureti, Romnia cod 79738
Redactor: Ing. Silvia

Cndea
( .pena : grafi cian Simona
Dumilrescu
Tehnoredactor : Ing. Silvia
Cundea
Coli de tipar: 17; Bun de tipar: 24.1.92 C.Z.:
681.3.06
ISBN: 973-31-0430-2; ISBN: 973-31-0431-0
Comanda nr. 49
Tiraj : 20 000 exemplare
B024779
Tiparul: IMPRIMERIA ARDEALUL" CLUJ

UnivarsiUUH
d.->
St a t A l C B
R
u o i: o "
iJiblioieca tiinifica Fond
didactic
Limbajul Pascal
- Concepte fundamentale
Un limbaj de programare este un sistem de notaii pentru reprezentarea

algoritmilor. Exprimai n aceast form, algoritmii pot fi executai de ctre calculatorul
electronic sau comunicai altor programatori. Primele limbaje de programare au fost
limbajele main, care foloseau o notaie foarte deprtat de cea uzual sau
matematic. Odat cu dezvoltarea activitii de programare a aprut necesitatea de a
transcrie un proces de calcul ntr-un limbaj ct mai apropiat de modul n care a fost
elaborat algoritmul ce-l descrie, sau apropiat de limbajul natural. Astfel au aprut
limbajele de nivel nalt (FORTRAN, COBOL, ALGOL, PL/I, BASIC, APL, Pascal, C, Aia
etc).
Dac limbajele FORTRAN i COBOL snt cele mai folosite n problemele de
calcule tiinifice i n cele comerciale, limbajul Pascal a devenit n ultimul timp "lingua
franca" a comunitii informatice din mediul universitar, integrnd cu mult succes un
numr mic de faciliti ntr-un corpus puternic i eficient. Acest limbaj a fost definit n
1971 de profesorul Niklaus Wirth de la Universitatea Tehnic din Zurich [Wi71a,
Wi72J. Numele limbajului este cel al matematicianului i umanistului francez Blaise
Pascal (1623 - 1662), care a conceput la vrsta de numai 18 ani prima main simpl
de calculat.
Cteva din caracteristicile ce au impus limbajul snt: simplitatea i claritatea
acestuia, obinute printr-o riguroas selecie a conceptelor de programare; posibilitatea
de a atinge o anumit disciplin a programrii ce conduce la programe robuste i
eficiente, prin obligativitatea impus declarrii obiectelor utilizate (tipuri, constante,
variabile) precum i prin facilitile oferite de instruciuni ce permit un bun stil de
programare (instruciuni compuse - begln . . . end, instruciuni condiionale - l f . . .
then. . .else, caso, instruciuni iterative - while, repeat. . .vntll, fox). La noi n ar,
importante investigaii privind implementarea sau/i utilizarea limbajului Pascal au
fost efectuate de colective din nvmntul superior (Institutul Politehnic din Timioara
[Ci82, Ci85], Institutul Politehnic din Bucureti [Io83, Se84], Universitatea din Iai
[Ru87J).
Prezentarea limbajului Pascal din lucrarea de fa urmrete att nucleul su,
aa cum rezult din monografiile lui Jensen i Wirth [JeWi74, JeV/i85], ct i extensiile
din varianta Oregon [Pa81]. Un compilator pentru acest limbaj este disponibil pe
minicalculatoarele din familia Independent - Coral. n textul lucrrii marcm extensiile
limbajului prin scrierea cu italice a prii care semnaleaz acest fapt.
Lucrarea se adreseaz cititorilor care snt oarecum familiarizai cu proble
matica programrii calculatoarelor i cu noiunile de baz ale informaticii teoretice. Ea

poate servi ca suport de curs studenilor facultilor de matematic i tn aceeai
msur poate fi parcurs cu folos i de absolvenii acestor faculti i ai seciilor de
specialitate din institutele tehnice t economice.
In abordarea anumitor concepte ale limbajului Pascal am ncercat s
introducem un instrument matematic care s confere mai mult exactitate i claritate
prezentrii Astfel, tipurile de date au fast n general definite utiUzSnd instrumente din
teoria structurilor algebrice [AUr78], sintaxa limbajului este exprimat fie n notaia
BNF, fie prin diagrame sintactice, iar anumite elemente de semantic jac apel la
modele ale semanticii axiomatice de tip Hoare [HoW73].
Lucrarea este structurat astfel: o introducere, 7 capitole i 4 anexe.
Primele noiuni despre programarea n limbajul Pascal snt expuse n
introducere. Capitolul 1 prezint elementele lexicale i sintactice ale limbajului n
capitolul 2 snt abordate tipurile de date simple, structurau! i tipul pointer, variabilele,
constantele, etichetele i expresiile. Instruciunile limbajului snt prezentate n capitolul
3. in capitolul 4 snt prezentate conceptele de procedur, funcie i program care permit
descrierea modular-structurat a proceselor de calcul de mare complexitate. Printre
aplicaiile mai importante prezentate aici amintim: construcia tabelelor de analiz
sintactic n cazul gramaticilor de preceden simpl; folosirea recursiei n cadrul unor
algoritmi cu reluare ('backtracking algorithms") i pentru analiza sintactic recursiv
descendent Capitolul 5 conine o prezentare formalizat a semanticii, utiUznd
modele axiomatice. Mecanismele dezvoltate aici snt aplicate la proiectarea
programelor prin metoda rafinrii succesive i verificarea corectitudinii tn capitolul 6
snt prezentate facilitile de depanare simbolic ale compilatorului Pascal-Oregon,
utile i pentru nvarea interactiv a limbajului Capitolul 7 ofer cteva informatii
referitoare la punerea n lucru a compilatorului Pascal sub sistemul de operare RSX.
Anexele i 2 conin lexicul i respectiv sintaxa limbajului Pascal n notaia BNF;
anexa 3 conine diagramele de sintax O list a constantelor, tipurilor i variabilelor
predefinite, precum i o scurt prezentare a procedurilor i funciilor predefinite se afl
n anexa 4. _, , Adresm cele mai sincere mulumiri colegei Silvia Pepelea care, cu
rbdare, pricepere i contiinciozitate, ne-a asistat n redactarea acestui text
Autorii
Limbajul Pascal
INTRODUCERE................................................................................................
1. VOCABULARUL I SINTAXA LIMBAJULUI ................................................... 5

1.1. Mulimea de caractere............................................................................... 5
- 1.2. Vocabularul limbajului.................................................................. 6
1.3.Sintaxa limbajului......................................................................... 8
1.3.1................................................................Form
alismul BNF............................................................................ 8
1.3.2................................................................Diagr
ame sintactice ...................................................................... 10
1.4. Exerciii........................................................................................ 11
2. TIPURI DE DATE, VARIABILE, CONSTANTE, ETICHETE, EXPRESII ---------2.1. Tipuri de date simple.....................................................................
13
14
2.1.1................................................................Tipur
i de date predcfmitc................................................................. 14
2.1.2................................................................Tipur
i de date enumerare................................................................ 19
2.1.3................................................................Tipul
de date subdomeniu................................................................ 20
2.2. Tipuri de date structurate............................................................. 21
2.2.1................................................................Tipul
de date array (tablou).............................................................. 21
2.2.2................................................................Tipul
de date record (nregistrate)..................................................... 26
2.2.3................................................................Tipul
de date set (mulime)............................................................... 30
2.2.4................................................................Tipul
de date file (fiier).................................................................... 32
2.2.4.1.Fiiere secveniale........................................... 33
2.2.4.1.1. Operaii de intrare/ieire ............... 33
2.2.4.12........................................ Fiie
re text .................................................................38
2.2.4.13.
Fii
erele standard input i output . . . .
44
2.2.4.2. Asocierea fiierelor Pascal cu fiiere externe . . . 44
2.2.4.3. Fiiere cu acces direct..................................... 46
2.3.............................................................................Tipul
de date pointer (referin)..................................................................... 47
2.4.............................................................................Tipur
i de date recursive................................................................................ 49
2.5.......................Expresii..........................................................'. ($t)
2.6.............................................................................Exer
ciii ......................................................................................................................54
3. NSTOUCRJNI............................................................................................. 57
3.1.Instruciuni simple....................................................................... 57
3.1.1................................................................Instr
uciunea dc atribuire.............................................................. 57
3.1.2................................................................mstr
uciunea apel de procedur..................................................... 59
3.1.3................................................................Instr
uciunea de transfer necondiionat ......................................... 59
3.1.4................................................................Instr
uciunea de efect nul............................................................... 62
,3.2.Instruciuni structurate................................................................. 62
Limbajul Pascal
3.2.1................................................................Instr
uciunea compus...................................................................
62
3.2.2................................................................Instr
uciuni iterative......................................................................
63
3.2.2.1....................................................Instr
uciunea while ..........................................................
63
3.2.2.2....................................................Instr
uciunea repeat..........................................................
66
3.2.2.3....................................................Instr
uciunea for ...............................................................
68
3.2.3.Instruciuni condiionale ...............................................
71
3.2.3.1....................................................Instr
uciunea if..................................................................
71
3.2.3.2....................................................Instr
uciunea case ............................................................
73
3.2.4.....................................................................................................Instruciunea with
74
3.3.............................................................................Exe
mple....................................................................................................
76
3.4.............................................................................Exer
ciii .....................................................................................................................80
4. PROCEDURL FUNCII, PROGRAME, MODULE ..........................................
84
nisme de abstractizare n Pascal..........................................................
84
4.1.............................................................................Meca
4.2.............................................................................Func
ii
.....................................................................................................................84
4.2.1................................................................Decl
ararea funciilor......................................................................
84
ul funciilor.............................................................................
85
4.2.2................................................................Apel
4.2.3................................................................Exe
mple ....................................................................................................86
4.3. Proceduri...................................................................................... 90
4.3.1................................................................Decl
ararea procedurilor................................................................. 90
4.3.2...............................................................Apelul
procedurilor.......................................................................... i
90
4.3.3................................................................Exe
mple ................................................................................................... 91
4.4. Programe...................................................................................... 92
4.4.1................................................................For
me sintactice; exemple . .'........................................................ 92
4.4.2................................................................Stru
ctura static a programelor..................................................... 93
4.4.3................................................................Dom
enii de vizibilitate a declaraiilor.............................................. 94
4.4.3.1...........................................Dom
enii de vizibilitate ale declaraiilor de identificatori
..................................................................................95
4.4.3.2.
98
Domenii de vizibilitate pentru alte declaraii . . . .
4.4.3.3....................................................Cont
ext asociat unei uniti de program............................. 99

4.5.Comunicarea ntre uniti de program ....................................... 100
4.5.1...............................................................Comu
nicarea prin identificatori globali .......................................... 100
4.5.2...............................................................Comu
nicarea prin parametri.......................................................... 101
4.5.2.1..................................................Para
metri valoare............................................................ 101
4.5.2.2..................................................Para
metri variabil.......................................................... 102
4.5.2.3..................................................Para
metri formali funcie / procedur.............................. 103
4.5.2.4.................................................. Tablo
uri ca parametri........................................................ 106
4.5.2.5.................................................. Struc
tura dinamic a programelor .................................... 107
4.5.3.Efecte secundare la execuia funciilor i procedurilor . . . . 108
4.5.3.1.
Atribuiri asupra variabilelor globale.............. 109
4.5.3.2.Atribuiri asupra parametrilor formali varia
bil.............................................................. 109
4.5.3.3.Parametri actuali cu acelai nume pentru parametri formali variabil distinci..................... 110
4.5.4. Recursie .....................................................................
111
4.5.4.1..................................................Recurs
ia indirect .............................................................. 111
4.5.4.2..................................................Recurs
ia direct ............................................................... 112
4.5.4.3. Recursia i metoda relurii ("backtracking") . . .
125
4.5.4.4..................................................Aplica
ie: analiza sintactic recursiv descendent ... 131
4.5.4.5. Aplicaie:
calculul
relaiilor
de
preceden .......................................................... 139
4.6. Module....................................................................................... 150
4.6.1. Definirea si utilizarea modulelor in Pascal Oregon........ 150
4.6.1.1..................................................Compi
larea separat........................................................... 151
4.6.1.2..................................................Modul
e externe.................................................................. 151
4.6.1.3..................................................Modul
principal................................................................... 153
4.6.2. Comunicarea ntre module........................................... 154
4.6.2.1............................................Comunicare
a prin variabile globale .................................... 154
4.6.2.2......................................... Comu
nicarea prin apel de funcii / proceduri externe
................................................................................154
10
Limbajul Pascal
4.7. Exerciii......................................................................................
155
5. REPREZENTAREA FORMALIZAT A SEMANTICII.......................................
158
ucere.................................................................................................
158
e axiomatice de tip Hoare...................................................................
159
a instruciunii de efect nul....................................................
162
5.1...........................................................................Introd
5.2...........................................................................Sistem
5.2.1...............................................................Axiom
5.2.2...............................................................Axiom
a instruciunii de atribuire ................................................... 162

5.2.3...........................................Regula consecinelor .
...................................................................163
5.2.4...............................................................Regul
a instruciunii compuse........................................................ 163
5.2.5...............................................................Regul
a instruciunii if.................................................................... 164
5.2.6...............................................................Regul
a instruciunii while.............................................................. 165
5.2.7...............................................................Regul
a instruciunii repeat............................................................ 171
5.2.8...............................................................Proble
ma terminrii programelor ................................................... 174
5.2.9...............................................................Regul
a instruciunii for ............................................................... 176
5.2.10.............................................................Regul
a funciilor............................................................................ 177
5.2.11.............................................................Regul
a apelului dc procedur ........................................................ 178
5.3............................................................................Metod
a de programare top-down.................................................................. 180
5.4............................................................................Exerci
ii ...................................................................................................................192
6. DEPANATORUL SIMBOLIC.........................................................................
196
deraii generale..................................................................................
196
6.1...........................................................................Consi
6.2...........................................................................Come
nzile de baz ale depanatorului.......................................................... 197

6.3. Comenzi de depanare ................................................... 198
6.3.1. Comenzi relative la crearea/distrugerea punctelor de
ntrerupere (breakpoints)..................................... 198
6.3.1.1. Comenzi relative la crearea/distrugerea punctelor de
ntrerupere ce controleaz execuia
unui program.................................................
6.3.1.2. Comenzi relative la crearea/distrugerea punctelor de ntrerupere pentru variabile...................
198
199
6.3.2...............................................................Comen
zi ce controleaz execuia programului......................................... 200
6.3.3...............................................................Comen
zi pentru trasarea execuiei........................................................ 201
6.3.4...............................................................Comen
zi relative la date......................................................................
201
6.3.5...............................................................Comen
zi informative.......................................................................... 202
6.3.6................................. Macrocomenzi..................,
203
6.3.7...............................................................Comen
zi referitoare la stiva programului................................................ 204
6.4. Lista comenzilor ............................................................................ 206
7. UTILIZAREA COMPILATORULUI PASCAL-OREGON-----------------_ .. .------------ 201
7.1...........................................................................Punere
a n lucru a compilatorului Pascal-Oregon................................................ 207
7.2...........................................................................Opiun
i de compilare...................................................................................... 208
7.3...........................................................................Exemp
le ...................................................................................................................209
7.4. Directive comentariu..................................................................... 211
7.5. Directiva % include ........................................................................ 212
Anexa 1. VOCABULARUL LIMBAJULUI PASCAL.....................................,............. 219
Anexa 2. SINTAXA LIMBAJULUI PASCAL N NOTAIA BNF..................................... 221
Anexa 3. DIAGRAMELE SINTACTICE PENTRU LIMBAJUL PASCAL.......................... 226
Anexa 4. CONSTANTE, TIPURI, VARIABILE, FUNCTH, PROCEDURI
PREDEFINITE ................................................................................... 233
4.1...........................................................................Const
ante ...................................................................................................................233
4.2...........................................................................Tipuri
...................................................................................................................233
4.3...........................................................................Variab
ile ...................................................................................................................233
4.4...........................................................................Funci
i
...................................................................................................................233
4.5...........................................................................Proce
duri ...................................................................................................................235
4.6...........................................................................Lista
simbolurilor echivalente......................................................................... 236
RSPUNSURI LA EXERCIII.............................................................................. 237
BIBLIOGRAFIE................................................................................................ 255
12
Limbajul Pascal
INTRODUCERE
Acest capitol prezint cteva exemple de programe n limbajul Pascal, precum i unele caracteristici ale limbajului, avnd drept scop formarea unei viziuni de
ansamblu asupra acestuia nainte de a-i cunoate detaliile. n ncheiere snt
descrise pe scurt comenzile necesare executrii unui program scris n limbajul Pascal-Oregon sub sistemul de operare RSX-11M. Acest limbaj a fost proiectat i
implementat de ctre firma Oregon Software.
Menionm c la citirea i scrierea datelor n exemplele din acest capitol se
utilizeaz doar mediile standard de intrare / ieire, in implementarea Pascal-Ore-gon
acestea fiind terminalul utilizatorului.
Primul exemplu este un program numit Mesaj care scrie un ir de caractere.

Pe unele linii ale programului apare un comentariu, delimitat prin acoladele { i }.
program Mesaj; (programul numit Mesaj}
begin
{inceputul secvenei de instruciuni}
writeln( ' Primul program in limbajul Pascal')
{instruciunea writeln ...scrie irul de
caractere "Primul . . . " si apoi trece la
linia urmtoare a ecranului terminalului}
end.
{sfirsitul programului}
Urmtorul program numit suma, citete dou numere ntregi, calculeaz
suma acestora i scrie rezultatul.
program Suma;
var x , y, z : integer;
begin
{declara variabilele intregi

x, y, z }
read(x);
readln(y);
{citete o valoare in x }
{citete o valoare in y si trece la linia
urmtoare a ecranului} z := x + y ;
de atribuire; z primete
valoarea x + y }
writeln(z)
{este scris z }
{instruciune
Din exemplele anterioare se poate desprinde urmtoarea structur a unui program

n limbajul Pascal:
program NUME;
. { d e c l a r a i i de v a r i a b i l e }
begin
. { i n st r u c i u n i ce p ot }
. { u t i l i z a a c e ste v a r i a b i l e }
~|
} antet de p r o g r a m
\ p a r te a d e c l a r a t i v J
1
|
\ i n st r u c i u n e a
|
J
end.
compus
Prin urmare, un program este alctuit n general dintr-un antet de program, o parte
declarativ n care snt descrise toate entitile folosite i o instruciune compus.
Instruciunea compus poate conine la rndul ei, alte instruciuni (condiionale,
iterative, etc.).
Spre exemplu, pentru a calcula valoarea absolut a unui numr real x se folosete
instruciunea condiional if, dup cum urmeaz:
program Valabs;
var x : r e a l ;
begin
readln(x);
if x < o
then x : = - x ;
{se declara var iabila reala x}
{ s e c i te te x }
{daca x < 0 }
{atunci i se atr ibuie lui x
v a l o a r e a - x , a l t fe l x . r a m i n e n e s ch i m b a t }
w r i te l n C a b s ( x ) , x ) { s i n t s c r i s e m e s aj u l " a b s ( x ) = "
s i valoarea.x }
end.
Dintre instruciunile iterative ale limbajului Pascal vom alege spre exemplificare
instruciunea for care este folosit n programul urmtor pentru a calcula suma a n elemente
aflate ntr-un vector:
program Suma_n_elem;
const n - 10;
{ s e introduce constanta 10, c u numele n } var i : integer;
v : array [ l . . n ] of r e a l ; { s e d e c l a r a un ve c to r v c u
n componente numere r e a l e }
suma : r e a l ;
procedura Adun ( x : xe a l ; var y : r e a l ) ;
{Procedura Aduna c a l c u l e a z x + y s i intoaxce r e z u l t a t u l in y; detalii
despre proceduri in capitolul 4 i begin
y:= y + x
end;
{ Ad u n a }
begin { p r o g r a m p r i n c i p a l }
for i : = l to n do { p e n t r u i de la 1 la n j r e a d l n ( v [ i ) ;
c i te te v a l o a r e a v [ i ] , c i te una de p e o linie}
suma : - 0;
for i : = 1 to n do {pentru v a l o r i l e succesive
ale lui i}
Adun( v [ i ] , s u m a ) ; { a d u n a la suma a l i - l e a
element a l l u i v )
w r i te l n ( ' s u m a ' , suma)
end.
{se
n programul care urmeaz, ilustrm utilizarea instruciunii iterative while

pentru a calcula numerele Fibonacci mai mici dect 100.
program F i b o n a c c i ; var J , K
: i n te ge r ; begin
14
Limbajul Pascal
end.
J : = 0;
K : = 1;
->r-':
while K < 100 do begin
{ c i t t i mp u l t i m u l numr
F i b o n a c c i o b i n u t e ste
mai m i c dect 100}
w r i te l n ( K ) ;
{scr ie valoarea numr ului
Fibonacci}
K ; = K + J;
{ K v fi u r m to r u l n u m r
Fibonacci}
J := K - J
{ J este valoarea a n te r i o a r a
a lui K}
end { w h i l e }
Presupunem c textul unui program Pascal se afl ntr-un fiier creat cu

ajutorul unui editor de texte (EDT, EDI, etc). Pentru ca programul s devin executabil, acest text este" prelucrat succesiv de compilator i de editorul de task-uri.
Spre exemplu, dac programul Fibonacci se afl ntr-un fiier numit 7IBO.
PAS, atunci compilarea sa se face n urma lansrii comenzii
PAS FIBO
Rezultatul compilrii este depus n fiierul FIBO . OBJ , care va fi prelucrat
de editorul de task-uri. Acesta se activeaz prin comanda
F T B PROG /FP /CP " FIBO, LB[1,1]PASLIB /LB
Programul n format executabil este obinut n fiierul PROG. TSK i poate
fi lansat n lucru prin comanda:
HUN PROG
Alte detalii n legtur cu compilarea programelor pot fi gsite n capitolul 7.
Pentru programatorii familiarizai cu alte limbaje de programare, menionm cteva din caracteristicile limbajului Pascal:
1. Declararea variabilelor este obligatorie.
2. Anumite cuvinte cheie (de exemplu hegin, end) snt rezervate, neputnd
fi utilizate ca identificatori.
* 3. Tipurile de date disponibile n Pascal snt: simple (tipuri de date ntregi,
reale, logice, caractere, enumerare, subdomeniu), structurate (tipuri de date tablou,
nregistrare, mulime, fiier), pointer. Limbajul permite definirea de ctre utilizator a
unor tipuri noi.
4.Tablourile pot avea dimensiuni i limite arbitrare, dar constante, ale
indicilor.
5.Instruciunile pot fi etichetate. Etichetele snt ntregi fr semn i trebuie
s fie declarate.
6. Procedurile i funciile pot fi apelate recursiv.
7. Toate obiectele (constante, tipuri, variabile, etichete, proceduri, funcii)
trebuie s fie declarate nainte de utilizare, cu urmtoarele dou excepii:
- identificatorul de tip din definiia unui tip de date pointer (vezi 2.3);
- identificatorii de proceduri i funcii pentru care exist o directiv forward
(vezi 4.6.4.1).
Vocabularul oricrui limbaj de programare conine cele mai simple

elemente cu semnificaie lingvistic, iar sintaxa limbajului definete modul n care
se combin elementele vocabularului pentru a obine fraze corecte (instruciuni,
secvene de instruciuni, declarri de tipuri, variabile, constante, etichete, funcii,
proceduri etc).
1.1. Mulimea de caractere

Elementele vocabularului snt alctuite din caractere. Orice caracter este
reprezentat n calculator, n mod urne, printr-un numr natural cuprins ntre 0 i 127,
numit cod ASCII. Astfel, codul unui caracter de pe linia 1 i coloana c dm tabela de
mai jos este 81+c. Spre exemplu, codul caracterului 2 este 50. Mulimea de
caractere a limbajului Paseal-Oregon conine urmtoarele elemente: ale acestei
023456,70 |nulsohstxetx eotenqack bel1

Ibshtlfvtf crsosi 2 |
dle deldc2dc3 dc4naksynetb 3 |
can emsubescfsgs us4 !- -..5 |l6 j7
|'8' 9 ' 1 m 1I m *
t ' <'* ST '' >'' ?'8 |'''A''B''C''D':
'E'' F'' G' 9
1' H' 10 |'p''Q' 'r.''s''t* -'u''v'.11 |i ' X ' 'Y' [''V* *
1 12 |I I I 'a' .',b' ,c'd''ef %''g' 13,. j\ -K'
i''X'k' 1''m''h''o' 141 'p'15del
Se face distincie ntre caracterele neimprimabile (caracterul

del i cele de pe primele patru linii, care au codul cuprins
ntre 0 i 31) i caracterele imprimabile
mulimi: literele alfabetului latin (mari sau mici), cifrele arabe, caracterul * '
(spaiu), '+*, *-', '>', etc.
16
Limbajul Pascal
1.2. Vocabularul limbajului

Cele mai simple elemente, alctuite din caractere i care au semnificaie lingvistic
snt unitile lexicale. Acestea fonneaz vocabularul limbajului. Distingem urmtoarele
uniti lexicale:
- simboluri speciale;
- identificatori;
- numere;
- iruri de caractere;
- etichete;
- comentarii;
- directive.
Simbolurile speciale snt:
+
{
<
>
*
(
@
>
<>
>=
J
<=
:=
.0)
i cuvintele cheie:
and
array
begin
case
const
div
do
downto
else
end
file
for
function
goto
if
in
of
labei
or
mod
origin
nil
otherwise
not
packed
procedure
program
record
repeat
set
then
to
type
until
var
while
with
(2)
Cuvintele cheie snt rezervate, adic snt utilizate n programe doar cu

semnificaia dat explicit prin definiia limbajului. Celelalte simboluri speciale snt
folosite ca operatori i delimitatori.
Identificatorii snt nume asociate constantelor, variabilelor, tipurilor de
date, procedurilor i funciilor. Primul caracter al numelui este o liter sau '$* iar
celelalte snt litere, cifre, '$', sau *_' Exemple: x i , Suma______x_y, $PRET____NOU.
Numerele pot fi de tipul integer sau de tipul real.
Numerele de tipul integer desemneaz numere ntregi i snt scrise n
reprezentare zecimal, precedate sau nu de semnele *+* sau Spre exemplu, valoarea
ntreag 23 poate fi reprezentat prin numerele +23, 23, 023 etc. n Pascal Oregon
numerele de tipul integer pot fi reprezentate i n baza 8, irul de cifre octale fiind
urmat n acest caz de litera B (sau b). Spre exemplu +27 B , 27 b i 027 B snt
reprezentri ale valorii 23.
Numerele de tipul real desemneaz numere raionale cu numr finit de

zecimale. n mod uzual ele snt reprezentate prin numere fracionare (n baza 10) cu
partea""fracionar separat de partea ntreag prin punct,,Spre exemplu prin
3.1415 este reprezentat aproximarea prin lips a numrului %. Punctai zecimal
trebuie s fie precedat i urmat de cel puin o cifr zecimal. Astfel, 1. sau .1 snt
reprezentri eronate pentru 1.0 i respectiv 0.1.
n scrierea numerelor de tipul real se poate utiliza i un factor de scal.
Acesta este un numr de tipul integer, precedat de litera E (sau e). El apare dup un
numr de tipul integer sau un numr fracionar i are urmtorul efect: valoarea
numrului de tipul real este valoarea numrului ntreg sau a celui fracionar,
nmulit cu 10 la puterea dat de factorul de scal.
Spre exemplu 31415 E -4, 314.15 E -2, 0.31415 E 1, 0.31415 E +leta.,
reprezint aceeai aproximare a numrului 7 C .
Numerele de tipul real pot fi precedate de semnele + sau -.
irurile de caractere snt iruri de caractere imprimabile, delimitate de
apostrof. n irul de caractere, apostroful apare dublat.
Exemple:
' i r de c ar a c te r e IMPRIMABILE '
' APOSTROFUL ESTE ' ' '
Etichetele snt iruri de cifre zecimale.
Exemple: 1, 01,20, 0. De notat c 1 i 01 reprezint aceeai etichet.
Comentariile snt iruri de caractere precedate de { i urmate de }.
Directivele snt cuvintele rezervate forward, externai, nonpascal (vezi
capitolul 4) i %include (vezi capitolul 7).
In scrierea oricrei uniti lexicale ce nu este literal alfanumeric nu se face
distincie ntre litere mari i litere mici. Astfel, identificatorul SUMA este identic cu
Suma, dar literalele alfanumerice 'SUMA' i 'Suma' snt distincte.
De asemenea orice unitate lexical (cu excepia comentariilor) se scrie pe
o singur linie.
' ;-,
Exemplu: Urmtorul mod de scriere a identificatorului SUMA: su MA . nu este
permis.
La scrierea consecutiv a identificatorilor, a cuvintelor cheie, a literalelor
numerice fr semn i a celor alfanumerice, nceputul unei uniti lexicale ar putea
fi luat n unele cazuri drept o continuare a celei precedente. n aceast situaie,
ntre ele se insereaz spaii (caracterul ' ') caractere de tabulare (ht din tabela
ASCII) sau de salt la rnd nou (f f i cr n aceeai tabel). Trebuie observat c
simbolurile speciale compuse de forma o, < = etc., identificatorii i literalele
numerice snt uniti lexicale ale programului; deci nu se pot introduce spaii ntre
caracterele componente.
Exemplu: nu se poate scrie < > , < = , su MA , I 23 pentru o , <=,
SUMA i 123 .
Uiii
13.
'.
.'
ii
Sintaxa limbajului
Prin sintaxa unui limbaj de programare se nelege, n general, un

ansamblu de reguli de agregare a unitilor lexicale pentru a forma structuri mai
complexe (instruciuni, declaraii, programe, etc). Spre exemplu, n introducere a
fost prezentat forma general a unui program Pascal: un antet, urmat de o parte
declarativ i de o instruciune compus. Pentru descrierea n detaliu a acestor
componente snt necesare desigur alte reguli. Prezentarea n limbaj natural a
acestor reguli poate conduce la neclariti sau la specificri incomplete. Ne-am
putea ntreba spre exemplu dac prezena antetului unui program este obligatorie
etc. De asemenea, prin aceast prezentare nu este posibil o verificare complet a
corectitudinii unui program.
n 1959 este prezentat de ctre J. Backus o descriere a sintaxei limbajului
Aigol60 printr-un ansamblu de reguli formale [Back59]. Notaia utilizat a devenit
cunoscut sub numele de notaie BNF (Backus-Naur-Form) i are aceeai putere
generativ [GR62] cu gramaticile independente de context introduse de N. Chomsky
[Ch59].
18
Limbajul Pascal
Au fost dezvoltate i alte variante echivalente de specificare a sintaxei,

precum formalismul de descriere a sintaxei limbajelor Cobol i PL/I [Sam78] i
diagramele sintactice pentru definirea sintaxei limbajului Pascal [Wi72] i FORTRAN
[ANSI78J.
1.3.1. Formalismul BNF

Deoarece majoritatea limbajelor de programare nu snt independente de
context [F166], prin notaia BNF se obine o descriere incomplet, referitoare doar la
aspectele de sintax ale limbajului. Cu toate acestea, datorit simplitii sale,
formalismul a cptat o larg popularitate, rspunznd att dezideratelor impuse de
fazele de proiectare i implementare a unui limbaj de programare, ct i cerinelor
utilizatorilor.
Varianta de formalism BNF utilizat n aceast prezentare folosete urmtoarele opt metasimboluri:
<
>
pentru a defini uhitile sintactice ale limbajului Pascal.

O unitate sintactic este o mulime de fraze alctuite din elemente ale
vocabularului.
Metasimbolurile snt utilizate pentru delimitarea numelui unei
uniti sintactice.
u
>;.Exemplu. Unitatea sintactic <program> are numele program i este
mulimea tuturor programelor Pascal; <expresie> este mulimea tuturor expresiilor
ce apar n programele Pascal.
Pe mulimea unitilor sintactice este definit o operaie de concatenare
prin
<uxv> - {xy | x din , y din <v>i
unde xy este o fraz obinut prin adugarea frazei y la sfritul frazei x. Aceast
operaie este asociativ i are elementul neutru <empty> (unitatea sintactic ce nu
conine nici o fraz).
Exemplu: dac + aparine lui <semn> i (a b) aparine lui <termen>
atunci + (a * b) este n <semn><termen>.
Metasimbolul ::= apare dup o unitate sintactic i are sensul "unitatea
sintactic este definit prin".
Exemplu. Definiiile urmtoare:
< te r m e n >
: : - < fa c to r > < r e st termen>
< r e st te r m e n ) : : ^ < o p e r a to r m u l t i p l ic a t i v >
< r e st te r m e n > : : - < e mpt y >
< fa c to r > < r e st

T
te r m e n >
"
au semnificaia: un termen este o succesiune de unul sau mai muli factori,

desprii printr-un operator multiplicativ.
Metasimbolul | este utilizat pentru a delimita ntre ele mai multe variante
de definire a unei uniti sintactice. Unitatea sintactic definit este obinut prin
reuniunea variantelor.
Exemplu. Unitatea sintactic <rest termen}.- <mai poate fi definit si

prin
'i
:
i
'
.
< r e st te r m e n ) : : < e mpt y > |

< o p e r a to r m u l t i p l i c a t i v ) < fa c tox > < r e st . te r m e n )
iar definiia
< o p e r a to r m u l t i p l i c a t i v ) ::- * | / | div | mod | and
precizeaz care snt cei cinci operatori multiplicativi.
; ,,
Metasimbolurile { i } denot repetarea posibil (de zero sau mai multe ori)
a simbolurilor pe care le delimiteaz. n general, <u) :.:= { <v) ) se folosete ca
prescurtare pentru definiia recuri v .-v : : = | < e mpt y )
v-.
Exemplu. Definiia unitii sintactice < termen > din exemplele anterioare
mai poate fi scris sub forma
< te r m e n > : : = < fa c to r > < o p e r a to r m u l t i p l i c a t i v ) < fa c to r >
Exemplu: Definiia
C i d e n t i fi c a to r > : : = < l i te r a > { < l i te r a >
| <cifra> ] _ }
are semnificaia: un identificator ncepe cu o liter; dup aceast liter poate urma
o secven finit de litere,cifre sau caractere *_*. Astfel, A, a l , A 1 B , Al_b snt
conforme cu aceast definiie, dar 2 A nu.
Metasimbolurile [ i 3 denot prezena opional a simbolurilor pe care le
limiteaz. Spre exemplu, definiia < unu > [ + | --] l definete unitatea sintactic ce
conine elementele +1, - l i 1.
O definiie n notaia BNF poate fi privit ca o expresie n care snt evaluai,
n aceast ordine de prioritate, operatorii concatenare, | i : : = , cu convenia
uzual n ceea ce privete parantezele ( , } i [ , ] .
Sintaxa limbajului Pascal, n notaie BNF, este dat n anexa 2.
Frazele unitii sintactice <program> se numesc programe Pascal corecte
sintactic.
Exemplu. Urmtoarele fraze
p r o g r a m A (I ) ; b e g i n e n d .
program A (I, O); begin begin end end.
snt programe Pascal corecte sintactic.
Simbolurile { , } , [ i ] utilizate n notaia BNF snt n acelai timp i
elemente ale vocabularului limbajului Pascal. Pentru a evita confuziile, n anexa 2
aceste simboluri, ca elemente ale vocabularului, snt redate prin simbolurile echivalente (* , * ) , ( . i respectiv . ). n programele Pascal pot fi utilizate ambele
variante.
n notaia BNF se poate specifica i vocabularul unui limbaj de programare
dac prin desemnm unitatea lexical u. Vocabularul limbajului Pascal este
descris in notaie BNF n anexa 1.
1.3.2. Diagrame sintactice
20
Limbajul Pascal
Prin diagrame sintactice se realizeaz o reprezentare mai intuitiv a

sintaxei unui limbaj independent de context dect cea dat de notaia BNF. Au fost
utilizate pentru prima dat pentru definirea sintaxei limbajului Pascal [Wi73J.
Notaia prin diagrame poate fi derivat din notaia BNF n modul urmtor.
1.4.
Exerciii
11
I -------> * --------1
--------->
1------- y <-----J
22
iar
Limbajul Pascal

--------1----> X -----1------>
L ______________I
Exemplu. Unitatea sintactica <r.ertnen> poate fi definit prin diagrama

< te r m e n >
-------1--------------> < fa c to r > ------------------------1------>
l - - - - < o p e r a to r m u l t i p l ic a t i v > < -----------1
iar <identif icator> prin
< x d e n t i fi c a to r >
-------------------------> < l i te r a > ----------1----------: --------------
i
< l i te r a > < -------j
< c if r a > <
<------U
Sintaxa limbajului Pascal este definit cu ajutorul diagramelor sintactice n

anexa 3.
I A . Exerciii
1. Limbajul Pascal are cuvinte rezervate. Dar FORTRAN? Dai exemple de limbaje care au
cuvinte rezervate.
2.
Care dintre urmtorii identificatori snt coreci: Pascal, PASCAL , $ PASCAL ,

1 P , p _ l . I d e n t i fi c a to r _ f o a r te _ l u n g _ d a r _ _ , $ 1 , $_ 1, P_-
PI ,
3. Limbajul Ada [Ada83] definete instruciunea if astfel:

 : : =
i f < c o n d i t i o n > then < s o q _ o f _ st m t s > endif
 : : - ( < e l s i f _ a l te r n a t i ve > }
[else < s e q _ o f _ st m t s > J < e l s i f _ a l te r n a t i ve > : : - e l s i f
< c o n d i t i o n > then < s e q _ o f _ st m t s >
Rescriei aceast notaie BNF prin diagrame sintactice echivalente.
4. Fie urmtoarele diagrame sintactice:
A
-----,----------------,----->
,--------> C "--------,----->
I- - - B <'
'------- c <-------1
Scriei n notaia BNF definiiile acestor diagrame.

5. Fie diagramele urmtoare:
" A -i i' -4i
I ----- B
'
-------------,-----------------------------------------------i--------------->
<-----
--------> C -----> D
Snt acestea echivalente cu

A
>
---- C < D <-l

6. Care dintre exemplele urmtoare snt programe Pascal corecte sintactic (vezi anexele 1
i 2) ?
a) program E X E M P L U ;
b)
const
type
const
var
c)
begin
- 1;
T = 0 .. 2;
C A;
X , Y : T;
:- A + 1;
: = A * C
end.
d) Programul obinut prin concatenarea exemplelor a, b i c.
TIPURI DE DATE, VARIABILE, CONSTANTE,

ETICHETE, EXPRESII
Un program n limbajul Pascal conine o descriere a aciunilor ce trebuie s

fie executate de calculator i o descriere a datelor ce snt manevrate de aceste
aciuni. Aciunile snt descrise prin instruciuni, iar datele prin declaraii (sau
definiii). Prin tip de date se nelege o mulime de valori. Pe tipurile de date ale
unui program se definesc o serie de operaii, rezultatul fiind o algebr multisortat
[ADJ77] avnd ca domenii aceste tipuriijSe disting trei categorii de tipuri de date:
sjmple (elementare), compuse (structurate) i de referin (pointer). n general,
tipurile de date snt definite explicit prin declaraiile type iar operaiile asociate prin
declaraiile f unction sau procedura i snt specifice programului n care ajpar.: Exist
ns tipuri de date elementare de interes mai general, numite tipuri predefinite a
cror definiie se consider cunoscut i nu cade n sarcina programatorului. O
serie de operaii relative la aceste tipuri snt de asemenea predefiit. .Valorile unui
tip de date snt referite prin variabile sau constante. Anumite constante snt
predefinite (vezi anexa 4).
O declaraie de tip este de forma
type I - T ;
unde I este un identificator numit numele tipului, iar T specificaia sa (vezi anexa
3, diagrama 3.7). Declaraia variabilelor este precedat de cuvntul cheie var, a
constantelor de cuvntul cheie const, iar a etichetelor, de ciivntul cheie labei (vezi
anexa 3, diagramele 3,8, 3.6, 3.5). Numele I poate fi folosit pentm referirea la tipul T
in declaraiile ulterioare de variabile sau pentru definirea altor tipuri.
Exista ns tipuri de date anonime, definite implicit prin declaraii de
variabile de forma
24
Limbajul Pascal
var v_l, . . . , v_n : T ;
Exemplu. Prin labei 1 , 1 0 ; type bin = 0. . 1; var bit. : b i n ;

c i f r a : 0 . . 9 ; const z e r o - 0 ; var i : i n te ge r ;
s-au definit: etichetele 1 i i o , tipul b i n cu elementele 0 i i, variabila b i t de tipul
bi n, variabila cifr de tipul anonim o. variabila i de tipul predefina integer precum
i constanta zero avnd valoarea 0.
2.1. Tipuri de date simple

Tipurile simple snt de trei categorii: predefinite, enumerare i subdomeniu.
Tipurile simple se mai numesc i tipuri scalare.
2.1.1. Tipuri de date predefinite

Exist cinci tipuri de date predefinite: integer, real, boolean, char i text.
- Tipul integer este o mulime de numere ntregi cuprinse ntre cel mai mic i
cel mat mare numr ntreg ce se pot reprezenta pe un calculator gazd al
limbajului. Valoarea maxim admis poate fi referit prin constanta predefinit
ataxint, iar valoarea minim este - m a x i n t . In implementarea Pascal - Oregon,
maxint este 32767, iar valoarea minim este -maxint -1. Elementele de acest tip
se reprezint n programele Pascal prin literale numerice de forma i, unde i este
numr ntreg n reprezentare zecimal (eventual precedat de semnul + sau -) sau
de forma i 13, unde i este numr ntreg n baza 8 (reprezentare octal,
eventual cu semn). Spre exemplu, elementul -15 al tipului integer poate fi
reprezentat prin literalele -15 sau - l7B.
Reprezentarea intern (fornui de memorare) a elementelor de acest

tip se face n cod complementar pe cuvinte de 2 bytes [PDP76J. Fie x
reprezentarea n baza 2 a unui numr ntreg. Reprezentarea n cod complementar a
lui x este
f x
rc(x) - j
d a c 0 < x < 0 111 3 11 11.1 i i i m
l _ 2 " - | x | dac x < 0 i 2 " - | x | 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 f x

dac 0 < x < 2i,-l
H
L 2 l t e + x dac 2" < x < o
De exemplu -9 se reprezint prin 2 l6-9, adic 177767 (n octal), iar 9 prin 000011
(n octal).
Rezult c cel mai mare numr reprezentabil n cod complementar este 2 lM, adic
32767 (maxint); cel mai mic numr este -21S, adic -32768. Tipul real este mulimea
de numere reale
{ x f x - 0 , x 0Xi. . . x - b* i x . s n t c i f r e n b a z a b i l,SeSl,J
unde baza b a sistemului de numeraie, limitele lt i 1 ale exponentului e i
numrul n + l de cifre ale prii fracionare snt dependente de implementare iar
x0*o pentru x*o. n cazul de fal, b = 2 , -128 e < 127, iar n - 2 3 (sau, opional,
n = 5 5 - vezi cap. 7, opiunea / DOUBLE ).
Elementele tipului real se reprezint n programe prin literale numerice de
formele i. f, i. f Es sau iEs, eventual precedate de semnul + sau -, unde i i f snt
numere zecimale ntregi fr semn reprezentnd partea ntreag i respectiv partea
fracionar a literalului numeric. Dac este specificat i factorul de scal s (zecimal
ntreg, eventual cu semn), atunci literalul reprezint valoarea real i, f io" sau ir
io?.
Spre exemplu, elementul -0,25 al tipului real poate apare n programe Pas cal n una din formele -0.25, -25E-2, -25.0E-2 etc.
Se observ c n programele Pascal elementele tipului real se presupun a fi
scrise n baza 10.
Reprezentarea (memorarea) acestora n calculator se face n virgul

mobil pe 2 cuvinte (32 bii - simpl precizie) sau pe 4 cuvinte (64 bii - dubl
precizie). Poziia binar 15 (prima din sting, n notaia uzual) a primului
cuvnt este a semnului, n poziiile 7-14 ale primului cuvnt se memoreaz
caracteristica (exponentul mrit cu 128), iar n rest se memoreaz mantisa
(partea fracionar fr prima poziie dup virgul; numrul real fiind
normalizat, aceast poziie este 1, cu excepia numrului real 0). De exemplu
+1.0 se scrie 0,1-2' (adic xc=l, b=2 i e-l); caracteristica este c = l?B+e ~ 2 7+.l =
o o o o o o i . Deci primul cuvnt al reprezentrii n calculator este o 10000001
o o o o o o o , iar al doilea cuvnt este o o o o o o o o o o o o o o o o (n baza 2). Reprezentarea
octal este 4 0200, respectiv o. n mod analog, -5.0 se va reprezenta prin numerele
octale 14 0 6 4 0 i o.
Cel mai mare numr real reprezentabil n simpl precizie este
0 , l l l l . l l l l l l J . l l l l l l l l l - l l . i l . ' 2.A-,*l- 2'27*1038.
Cel mai mic numr real pozitiv reprezentabil este
123
0,1-2'127=2
ip3%
.
Numerele reale de fonna o, l x t . . . x2, mpart intervalul n 223 subintervale de
lungime (l-^)'2"23=224. n consecin, eroarea maxim de aproximare a unui
numr real printr-un numr real reprezentabil este zS-2" 2* < IO"7. De aici rezult
o precizie de 7 cifre zecimale semnificative pentru numerele reale reprezentate n
precizie simpl.
--.
Tipul boolean conine dou elemente referite prin constantele predefinite
false i true. Operaiile predefinite ale acestui tip (and, or i not) definesc o
structur de algebr booleana.
Tipul char este o mulime finit i ordonat de caractere ce conine, printre
altele, litere, cifre i caracterul spaiu. n cazul de fa, toate caracterele ASCII
(vezi paragraful 1.1) aparin tipului ch a r.
n programe, un element al acestui tip se desemneaz prin includerea
caracterului ntre dou semne ' (apostrof). Spre exemplu, ' A ' , ' 0 ' , ' + ' , ' '
desemneaz litera A, cifra o, caracterul + i caracterul spaiu. Caracterul ' se
reprezint prin
26
Limbajul Pascal
Reprezentarea intern a unui element de acest tip se face pe I byte i

are
ca valoare codul ASCII al caracterului respectiv (paragraful LI). Primul caracter
al tabelei are numrul de ordine 0.
. c.
-Tipul text va fi prezentat n paragraful 2.2.4.1.2. Exist de asemenea o serie de operaii

predefinite n care snt implicate tipurile de date descrise anterior. Ele snt desemnate prin
operatori i funcii predefinite. Astfel, operatorii binari (adunare), - (scdere), * (nmulire)
i / (mprire) pot avea operanzi de tipul integer sau r e a l . n cazul operatorului /
rezultatul este totdeauna de tipul r e a l . Pentru +, - i * rezultatul este de tipul integer dac
ambii operanzi snt din integer i este de tipul real dac cel puin unul din operanzi este de
tipul r e a l . Pentru mprirea prin trunchiere a valorilor din tipul integer se utilizeaz
operatorul dlv. Astfel, a div b - n dac:
1) 2' 0- i n < n +1
sau
2) < 0 i n- l < g Sn.
Deci -13 div 2 este -6.
Fie a , b z , b*o. Se noteaz prin q ctul i prin r restul mpririi ntregi a lui a la
b (a - b * q + r, 0< = r < abs ( b ) ); He rem - a - ( a div b ) * b.
Dac a o sau b divide pe a, atunci q - a div b i r - rem. n caz contrar, q = a
div b - s ig n (b) i r = rem + abs ( b ) .
Pentru calculul expresiei r e m se poate utiliza operatorul nod. n limbajul standard
[JeWi85], a mod b m r e m dac ai.0 sau b divide pe a i a mod b = rem + b n caz
contrar. n implementarea Pascal-Oregon, a mod b - rem n ambele cazuri n
consecin, n implementarea Pascal-Oregon q i r se calculeaz prin instruciunile
urmtoare:
q : - a div b ; r : = a mod b; it ( a < 0)

and (r O 0) than begin
r : = r + abs( y ) ;
ii b < 0 then q : = q + 1 else q : = q - 1
end
n limbajul standard, q i r se calculeaz prin: q : = a div
b ; r : a mod b ; if. ( a < 0) and ( r O 0) then if b > 0
then q
q-1
else begin q : - q + l ; r : - r - 2 * b end
Exemplu:
begin
'4
end.
,
,
8 div
- 8 div
8 div
- 8 div
8 mod
3 );
3 );
( - 3 ) );
( - 3 ) );
3):
w r i te l n C 8 div 3 = w r i te l n C - 8 div 3 = w r i te l n C 8 div - 3 '

w r i te l n C - 8 div - 3 - ' w r i te l n C 8 mod 3 - ' w r i te l n ( ' - 8 mod 3 = ' ,
- 8 nod 3}.;:*. w r i te l n C 8 mod - 3 - ' , 8 nod ( - 3 ) ); w r i te l n C - 8 mod
- 3 - ' , - 8 nod ( - 3 ) ) ;
- -
' :' -ii .; * . TOt
ilustreaz aplicarea operatorilor div i mod.
;>'
V - -"
Operatorii relaionali uzuali , o (diferit de), <, < (mai mic sau egal), >, > conduc la
rezultate de tip boolean. Ambii operanzi trebuie s fie de acelai tip (integer, r e a l , char
sau boolean). Ca excepie, se admite in locul unui operand de tipul r e a l un operand de
tipul integer.
Pe tipurile integer i real relaia de ordine <* este cea uzual;
elementele tipului char snt ordonate prin valorile asociate n codul ASCII, iar
fa l s e < tiue.
.
Operatorii not, and i or se aplic asupra operanzilor de tip boolean, cu semnificaia
logic uzual. n plus, operanzii pot fi i de tip integer; rezultatul este tot de tip integer i
se obine prin aplicarea operatorilor respectivi asupra reprezentrii binare a

operanzilor bit cu bit. Spre exemplu, not a este - 2, 6 ox 3 este 7, 6 and 3 este 2.
Alte operaii snt implementate prin funcii pnedefinite. Spre exemplu, abs ( x ) este
valoarea absolut a lui x, iar sqr ( x ) este ptratul lui x. Tipul rezultatelor este acelai cu tipul
argumentului x, care poate fi integer sau real.
Urmtoarele funcii: s i n , c o s , a r c t a n , exp (exponeniala de baz e), In, s q x t
(rdcina ptrata) admit argumente de tipul Integer sau r e a l , dar rezultatul este totdeauna
de tipul real. Predicatul odd (x.;, cu argument de tip integer ia valoarea t r u e dac x este
impar i fa l s e n caz contrar. Trunchierea i rotunjirea numerelor reale se realizeaz prin
funciile trunc i respectiv round. Astfel, t r u n c ( x ) -n dac x este de tipul real, n numr
ntreg i nix<n+l n cazul cnd x kosaun- l < x S n n cazul cnd x < 0. De asemenea,
round ( x ) este t r u n c ( x +0.5) pentru x^o i trunc ( x - o . 5) pentru x <0.
Pentru tipurile integer, char i boolean exist funciile succ (succesor) i pred
(predecesor), cu semnificaia uzual. Funcia bijectiv ord, cu argument de tip char ia valori
de tip integer cuprinse ntre 0 i 127 i realizeaz codificarea caracterelor. Spre exemplu,
ord('0' ) = 4 8 , ord( ' 1' ) - 4 9 etc., o r d ( ' A ' ) = 6 5 , o r d ( ' B ' ) - 6 6 etc.. Inversa acestei funcii
este ch r. De fapt, relaia de ordine o pe mulimea char este definit astfel:
a <- b dac i numai dac ord ( a ) < - o r d ( b ) .
De asemenea, pred ( c ) -chr ( o r d ( c ) -1) i s u c c ( c ) =chr ( o r d ( c ) + l ) . Toate
aceste operaii snt prezentate sintetic n anexa 4.
Trebuie remarcat c tipurile de date snt mulimi finite, prin urmare cea mai mare
parte a operaiilor discutate anterior snt doar parial definite; spre exemplu, succ (maxint) ,
maxint+1, pred ( - maxint -1) etc, nu au sens. n general operaiile nu snt definite pentru
acele argumente care provoac depirea limitelor impuse de tipurile de date. Executarea
programelor n aceste situaii conduce la obinerea unor rezultate incorecte. Evitarea acestor
cazuri este n sarcina programatorului, deoarece numai o parte a lor este sesizat i
semnalat de calculator.
Tipurile de date i operaiile predefinite prezint o seric de abateri de la proprietile
matematice cunoscute. Astfel, tipul integer nu este considerat o submulime a tipului rea 1,
datorit modurilor diferite de reprezentare n calculator. Acest fapt este reflectat n programe
prin forma diferit a literalelor cate desemneaz elementele celor dou tipuri (spre exemplu,
numrul real 1 se reprezint prin 1.0).
Pentru a corecta aceast anomalie, operaiile asociate tipului real snt extinse astfel
nct admit i operanzi de tip integer; n acest caz, calculatorul realizeaz o conversie de la
reprezentarea integer la cea de tip real. Spre exemplu, operaia 1/2 este precedat de
conversia lui 1 n 1.0 i a lui 2 n 2.0. Aceast conversie nu cade n sarcina programatorului.
De asemenea, multe proprieti familiare ale operaiilor nu se mai pstreaz. Astfel,
adunarea ntregilor nu este totdeauna asociativ; spre exemplu, maxint+(maxint-maxint) d
rezultatul maxint, dar (maxint maxint) - maxint conduce la depirea limitelor tipului
integer. Totui, cu excepia cazului n care apare depirea limitelor, axiomele aritmeticii
numerelor ntregi se consider a fi satisfcute pentru tipul integer, cu operaiile predefinite
ataate. Deoarece depirea este semnalat de calculator, se poate presupune c un program
28
Limbajul Pascal
care s-a terminat fat aceast eroare a executat operaiile asupra tipului integer respectnd
proprietile matematice uzuale.
Situaia este mai complicat n cazul tipului real, deoarece astfel de abateri pot apare
n absena fenomenului de depire a limitelor. Pentru ilustrare, s considerm ca
reprezentare a tipului real mulimea {x | x-i o, XgXiXgX, io*}. Fie elementele x-o,9554-IO0, y
= 0,3000* 10 i z - -0,2555*10 de acest tip. Dac se evalueaz n aceast reprezentare
expresia x (y + z) se obine rezultatul corect 0.9999. ntr-adevr, s = y+ + z = 0,0445 i se
reprezint prin 0,4450*IO"1, iar x + s - 0.9999 i se reprezint prin o,9 9 9 9 io0. Pentru
expresia (x + y)+z, suma s=x+y-i,2554 i se reprezint prin 0,9995*10. Aceasta este o
aproximare a rezultatului corect Estimarea erorilor de calcul n cazul tipului real cade n
responsabilitatea programatorului.
Urmtorul exemplu ilustreaz utilizarea variabilelor de tipurile prezentate mai sus,
precum i a operatorilor i funciilor predefinite asociate.
Exemplu: var
7
a
b
c
d
: integer; "
! real;
: char;
: boolean;
bagin
b- 1.5; .-a- a + tr unc(b) round(b);a- a nod a

div a: ord('X'); bsucc(a) + b /b pred(succ(a));cwr ite(a, b, c, d)
chr(ord(c)); d- (b <- b)
andtrue;
c := 'X';
nd.
2.1.2. Tipuri de date enumerare

Un tip enumerare este o mulime ordonat de valori specificate prin identificatori.
Aceast specificare are forma
( i d e n t i fi c a to r _ l , . . . , i d e n t i fi c a to r _ n )
i induce o relaie de ordine astfel c
identificator_i < identificator_jj pentru i < j.
Spre exemplu, tipul predefinit boolean poate fi specificat i ca tip enumerare prin
typ boolean ( fa l s e , t r u e ) ;
Elementele unui tip de date enumerare E sint identificatori ce constituie mulimea valorilor
hii E. De exemplu, dac se definete tipul type EN - (unu, doi, trei);
atunci elementele acestui tip sint u n u , doi i trei.

Operaiile aplicabile elementelor de tip enumerare sint cele relaionale specificate n
paragraful anterior (<, < = etc). De asemenea, se pot aplica funciile predefinite succ, pred i
ord (astfel, ord (identif icator_l) - 0). Identificatorii ce apar n definiia unui tip de date
enumerare urmeaz regulile obinuite de valabilitate (vezi paragraful 4.5.4).
Exemplu:
type luni - ( i a n ,
luni;
feb, m a r, a p r, m a i, iun,
i u l , aug, sep, o c t , nov, d e c ) ; var L , X , Y, z :
b : boolean; begin
w r i te l n (ord( i a n ) ) ;
L : - feb;
X
pred(L);
Y
succ(X); b
X < Y;
w r i te l n ( b , fe b < o c t , i a n = dec)
end.
Observaie. Variabilele de tip enumerare nu pot apare in instruciunile de
intrare - ieire; ele pot ti utilizate, spre exemplu, pentru indexarea tablourilor.
2.1.3. Tipul de date subdomeniu

Un tip subdomeniu este o parte a unui tip deja definit. Tipul subdomeniu se poate
introduce pentru orice tip scalar n afar de r e a l . Specificarea acestui tip se tace
prin:
< c o n st a n t a > . . < c o n st a n t a >
unde prin cele dou constante se definete un interval^ ce conine valorile
subdomeniului.
Un subdomeniu se poate indica i ca un tip anonim asociat unor variabile n
declaraii de tipul:
var v__l, . . . , v_n : c_l. .c_2
Operatorii i funciile prdfini te care se pot aplica operanzilor de tip
subdomeniu snt cele asociate tipului n care acesta este inclus. n cazul implemen-
trii de fa se poate defini un tip ntreg fr senin care nu este un subdomeniu al

tipului prdfinit integer. Acest tip are ca mulime de valori numerele ntregi x, cu
proprietatea o. <= x < = 6 5 5 3 5 , iar operaiile cu care este nzestrat snt cele ale
tipului i n te ge r.
Exemplu. ,type T =
"IO..10;
natural = 0..65535;
m
begin
b : natural;
c, a :
a .. a ;
^ ;:,
a : 0 ; a : = succ( p r e d ( a ) ) ;
b
65535; b := pred(b)
c := 'a'; d = 'd';
+ 1;
,:. _
30
Limbajul Pascal
w r i te l n ( a , b , c , d ) ;
c : = chr( s u c c ( o r d ( c ) ) ) ;
d
chr(pred( o r d ( d ) ) ) ;
w i i te l n ( c d )
Observaie. Toate tipurile de date simple snt mulimi finite i ordonate de valori.
Tipurile de date simple diferite de r e a l se mai numesc i tipuri ordinale. O caracteristic a
acestor tipuri este prezena operaiilor predecesor (pred) i succesor (succ).
Pentru tipurile ordinale diferite de integer i care nu snt subdomenii ale acestuia se
poate aplica funcia bijectiv o r d care asociaz valorilor tipului numerele naturale 0,1 etc.
Relaia de ordine este cea indus de funcia ord i este notat prin <.
2.2. Tipuri de date structurate

Tipurile de date structurate snt agregri ale unor tipuri de date deja definite (simple
sau structurare). Tipurile de date structurate care se pot defini n limbajul Pascal snt
urmtoarele: azzay, record, set i file.
r&'* . - v-JidssKv ei -. ' .-ii-.- ;. ' 'ijtariti* *>f5>ifsc-..-; jmm Jv fi
9io : *j* .a s,
,.>a
2.2.1. Tipul de date array (tablou)
Re T un tip de date oarecare i I un tip scalar diferit de integer i r e a l . T se

numete tip de baz iar I mulime de indici.
.
Prin tip de date azzay cu indici din I i elemente din t se nelege mulimea de funcii
A = { x | x :; I > T ) , care se noteaz ( I --> T ) .
Elementele tipului azzay se numesc tablouri.
Un tip azzay poate fi specificat prin
sau
azzay ti] of T
packed azzay [ I ] of T
Tipurile I i T pot fi predefinite, anonime sau definiia lor trebuie s precead, n textul
programului, definiia tipului azzay.
Dac x este numele unei variabile sau constante de tip azzay, atunci elementul x ( i )
se noteaz n programe prin x [ i ] .
Atributul packed indic n general cerina de optimizare a spaiului de memorare
pentru elementele tipului azzay.
Un caz special l reprezint tipurile de date string (ir de caractere), declarate prin
packed azzay [I ] of char
eo
Elementele de tipul string, avnd acelai numr de componente pot s apar n

instruciuni de atribuire i de asemenea pot fi asociate cu operatori relaionali ( = , O , < , > ,
< = , >= ).
za?
write.
Elementele acestui tip pot s apar ca argumente n procedurile standard xead i

Exemplu. Prin programul
var a , b : packed arxay [ 1 . . 7 ] of ch a r ; begin
a :- ' l o n e s c u ' ; b
'Popescu'; if a < b
then w r i te l n ( b ) else w r i te l n ( ' e r o a r e ' )
nd.
se realizeaz atribuirea irurilor de caractere ' lonescu' , ' popescu' variabilelor a i respectiv
b, iar n urma executrii instruciunii if se tiprete irul de caractere ' Popescu'. Trebuie
menionat c dac a i b ar fi fost declarate tar atributul packed atunci expresia a < b i
instruciunea w r i te l n ( b ) nu ar mai fi avut sens, necesitind substituirea referirilor la
variabilele a, b cu referiri la componente ale acestora.
Optimizarea spaiului de memorie ocupat de elemente de tipul packed
azray poate provoca accesul ineficient la componentele acestora. Din acest motiv,
se recomand efectuarea unei operaii de despachetare a acestor elemente prin
invocarea procedurii predefinite unpack, nainte de prelucrarea elementelor lor.
Dup aceast prelucrare, spaiul de memorie ocupat de elementele respective poate
fi din nou optimizat prin operaia de mpachetare apelnd procedura predefinit
pack. Re
i.
. . . .
A : array (m . . n ] of T;
B : packed axzay [ u . . v ] of T;
in-m >= v- u . Dacm <= i <= n, atunci prin operaia de mpachetare pack (A, i , B) tabloul
B ia valorile B t j ] - A [ j - u + i ] pentru u <- j <= v, iar prin operaia de despachetare
unpack(B , A , i ) tabloul A ia valorile A [ j ] - B [ j + u - i ] , pentru i < = j <= i+vru.
Elementele tipului array pot apare n programe sub form de constante

structurate (vezi anexa 3, diagrama 3.9). Spre exemplu, dac A desemneaz un tip
array definit prin type A = axzay [ 1 . . 5 ] of integer, atunci A ( 1 , o, 2, -1, 3) este un
element al acestui tip.
Exemplu. Fie programul
type A
2E-1);
: A;
- arxay [ 1 . . 5 ] of r e a l ;
B - axzay [ - 1 . . 3 ] of r e a l ; corist ca - A (1.1,
cb - B ( l . l , 2 . 1 , 0 . 1 , 3 . 1 , 2 E - 1 ) ; Var
y
begin
2.1,
0.1,
3.1,
: B;
: 1. . 5 ;
w r i te l n ( c a [ l ] , c b [ l ] ) ; X ; =
ca; y := cb;
fox i : = 1 to 5 do
w r i te l n ( x [ i ] , y [ i - 2 ] )
end.
Snt definite aici dou tipuri azxay (a si B) ale cror elemente reprezint vectori, avnd
cte 5 componente numere reale. n timp ce componentele variabilei x i ale constantei ca snt
referite n program prin x [l ] , . . . , x [ 5 ] i respectiv ca [1], ca 12] etc., cele ale lui y i c b
snt referite prin y [ - 1 ], t . . , y [ 3 ] , respectiv c b [ -1], cb [ol, etc. Constantele ca i cb,
dei conin aceleai componente, snt totui de tipuri diferite.
Exemplu.
type T - ( r o u , verde, a l b a st r u ) ; vax e :
axxaytT] of integer; begin
e [ r o s u ] : = 1;
e [ s u c c ( r o u ) 3 '" succ ( e [ r o u ] ) ;
e [ a l b a st r u ] : = 3 ;
32
Limbajul Pascal
w r i te l n ( e [ ve r d e ] )
[valoarea 2}
end.
vax a , b : paeked axzay [ i . .1] of ch a r ;
d : paeked azzay VI -- 2 ] of char ; c : ch a r ;
begin
b [ l ] : = ' a ' ; [ ' a ' e ste constanta d e t i p ch a r } d
:= 'ab';
{ ' a b ' e ste c o n st a n t a de t i p st r i n g } w r i te l n ( b , d ) [ i r u r i de
c a r a c te r e i n w r i te }
end.
Trebuie subliniat c tipul char nu este identic cu tipul paeked axxay [ 1 . . 1 ] of char.
Astfel, instruciunea b 1 = ' a ' este incorect, deoarece b este variabil de tipul ir de
caractere, dar ' a ' este constant de tipul char. Din acelai motiv i instruciunea b : - c este
incorect.
n exemplele de mai sus, tipul de baz a fost de fiecare dat un tip prdfinit (deci
simplu). Considerm acum un exemplu n care tipul de baz este el nsui un tip structurat.
type N - axxay [ 1 . . 3 ] of r e a l ;
type M = axxay [1. . 2 ] of N;
const C - M ( N (1.1,
1. 2 , 1. 3 ) , N ( 2 .1, 2 . 2 , 2 . 3 ) ) ;
Elementele tipului M au cte 2 componente reprezenund la rndul lor vectori

cu 3 componente.
Fie o declaraie de forma
type T = array[ i ] of array[J] of B;
Elementele tipului T snt funcii avnd domeniul I i codomeniul
( J ----->B). Tipul T este deci mulimea de funcii ( i -------------> ( j ------> B ) ) . ntre
mmimileT i u * ( I x J--------------> B) exist o coresponden bijectiv, deoarece
unei funcii f e T i se poate asocia o funcie g e u, definit prin g ( i , j ) - f ( i ) ( j ) . n
astfel de situaii se poate folosi declaraia n form prescurtat: type U = array [ I , J ]
of B;
Trebuie subliniat c tipurile T i u snt considerate totui distincte. Componentele unei variabile sau constante x de tipul T sau u pot ns s apar n
programe n oricare din formele x [ i ] [ j] sau x [ i , j ] .
Forma prescurtat a declaraiei de tip array se aplic i n cazul general.
Astfel, o declaraie de forma
&
:-{
i- ;
array [T_0] of array[T_l,
T _k ] of T
se poate scrie ca
array [T_0, . . . , T_k] of T Deci x [ i _ o , i_i, . . . , i_k] are sensul x [i_p] [i_i, , i_k].
Exemplu.
. .
type B
= array [1. . 3 ] of r e a l ;
T = array [1. . 2 ] of B; .H.

U - "y 11. . 2 , 1. . 3 ] of r e a l ; const CT
-= T ( B (1.1, 1. 2 , 1. 3 ) , B ( 2 .1, 2 . 2 , 2 . 3 ) ) ;
CU 4 U ( ( l . l , 1. 2 , 1. 3 ) , (2.1, 2 . 2 , 2 . 3 ) ) ; var
VB : B ;
VT s T;
VU : ti;
begin
VT : = CT;
VU : = CU;
{ s e s c r i e de doua o r i valoarea 1.2} VU : =
U((10.1,10.2,10.3),
(20.1,20.2,20.3));
w r i te l n (VU[l,2})
end.
Constantele CT i cu au proprietatea CT [ i ] [ j ] = C T [ i , j ] - CU[ i , j ] = CU[ i ] [ j ]
pentru orice l <- i <= 2 s i 1 <= j <- 3. Ele snt totui de tipuri diferite; astfel, variabila
VT de tipul T nu poate lua niciodat valoarea c u (de tipul u) dar poate lua valoarea CT.
Exemplu. Mulimea matricilor ptrate de ordinul 2 cu elemente numere
reale poate fi definit prin
>
>r >
typa LINIE - azzay (1..2J of r e a l ; ' M2RA

- array [1. ,2] of LI N I E ;
sau prin
"' s:S.l.Si f^iftH^.
. hx&.
S^;^r.a.-., v.
WI
type M2RB
= azzay [1..2] of azzay [1..2] of r e a l ;
sau prescurtat prin
type M2RC
= azzay [1..2,
-'rVfcfc
1..2] of r e a l ;
Deci matricea j1 2 | poate fi descris in programe Pascal prin M2RA
(1.0,
3 4
2.0), LINIE(3.0, 4.0)), prin
w r i te l n ( V T [ l ] [ 2 ] , VT[1, 2 ] > ;
34
Limbajul Pascal
( L I N I E d .0,
2.0), LINIE(3.0, 4.0)), prin M2RB ((1.0,2.0),

(3.0, 4.0)), SOU prin M2RC ((1.0, 2.0),
(3.0, 4.0)).
Exemplu.
type M2RC - azzay [1..2,1..2] of r e a l ; const M M2RC((1.0,
2.0),
(3.0, 4.0));
{ p r i m a l i n i e : 1 , 2}
{ a doua i i n i e : 3 , 4 }
var
1: integer; begin
foz 1:=1 to 2 do w r i te l n (M[ l , l ] )
{ s e s c r i u elementele de pe d i ag o n a l a p r i n c i p a l a }
end.
Exemplu. Acest program ilustreaz utilizarea irurilor de caractere: vaz
s i r : packed azzay [1..4] of ch a r ; c o p i e :
azzay [1..4] of ch a r ; i: integer;
begin
sir
'MASA';
unpack( s i r, c o p i e , 1); { s ir e ste despachetat i n copie} copie[1] ' . C i p a ck ( c o p i e , 1 , s ir ) ;
{ i n s i r este impachetat c o p i e }
w r i te l n ( s i r ) { s c r i e i r u l ' C A S A ' }
end.
2.2.2. Tipul de date record (nregistrare)

Re tipurile de date Tx , . . . , Tm i identificatorii distinci s x , . . . , sm prin care snt
notate proieciile canonice ale produsului cartezian 1\ x . . . x Tm. Spre exemplu, dac m = 2
i ( x , y ) Tx x T2, atunci s x ( x , y ) - x i s 3 ( x , y ) - y.
Se numete tip de date record produsul cartezian Tt x. . . x Tn mpreun cu cele m
operaii de selectare a componentelor, definite de proieciile canonice s x , . . . , s. Elementele
unui astfel de tip se numesc articole. Forma sintactic a unei definiii de tip record este
prezentat n anexa 3, diagramele 3.12-3.15. Elementele s j ( x ) apar n programe notate prin
x . s . Exist posibilitatea de a omite n aceast notaie partea x . , prin utilizarea unei
instruciuni with (vezi 3.2.4). Dac unul din tipurile T4 este de asemenea record i are
proieciile ri, compunerea celor dou proiecii se noteaz prin sx. z
y
Exemplu. Mulimea numerelor complexe poate fi reprezentat n programe Pascal ca

un tip de date record. Astfel, prin programul
*
type C - record r e , im : r e a l end;

var x : C ;
begin
x.re:=l.0;
x.im:=2.0
end.
se definete tipul record cu numele c, avnd ca proiecii funciile r e i im. Tipurile si T, snt
ambele r e a l . Partea real i partea imaginara a variabilei x apar n program n notaia x . r e
i respectiv x.im.
type d a t a - record
luna : ( i a n , fe b , m a r, a p r, m a i , i u n ,
i u l , a u g , s e p , o c t , n o i , d e c ) ; ziua ; 1 . . 3 1 ;
a n u l : integer end;
persoana = record
nume: packed array [1..10] of ch a r ; d a t a n : data
____________________________22. Tipuri de date structurate_______________________27
nd;
var data_cr : d a t a ;
p : persoana; begin
data_cr.l u n a i a n ;
data_cr.ziua:-24;
data_cr. a n u l :-1859;
p.nuine:-'IONESCU p.da
ta_n.luna: = fe b ;
p.data_n.ziua:=2; p.da
ta_n.anu1: = 1947
nd.
n acest program este introdus tipul record cu numele d a t a i cu proieciile luna,
z i u a i anul. Tipul T x este un tip enumerare, T2 un tip subdomeniu, iar T, un tip predefinit
Variabila data_cr are componentele data_cr. l u n a , d a t a _ c r. z i u a idata_cr.anul.
Exemplu. Poziia unui punct material n spaiul cu trei dimensiuni poate fi descris n
funcie de timp, prin elemente ale unui tip de date racord, n programul:
fcype POZIIA = racord
x , y, z : r e a l ; timp
: 0..3600
and;
var punct, origine : POZIIA; begin
origine: = P O Z I T I A ( 0 . 0 , 0 . 0 , 0 . 0 , 0 );
p u n c t . x : = 1 . 0 ; punct.y : = 1 . 0 ; punct.z: = 1 . 0 ; pune t.timp: - 19 89
and.
Componentele variabilei punct se obin prin proieciile x , y, z i timp i snt
urmtoarele: punct. x, punct.y, punct. z, i punet. timp.
Elementele unui tip de date record snt reprezentate n programe conform cu

anexa 3, diagramele 3.9, 3.10. Astfel c (0 . o , 1 . 0 ) i C(1.0 , 2 . 0 ) snt articole ale
tipului c reprezentind numerele complexe i i respectiv 1 + 2 i , data (aug, 2 , 1 9 8 8 )
este articol al tipului d a t a iar persoana (' POPESCU ' , d a t a ( i u l , l , 1 9 5 0 ) )
aparine tipului persoana.
Deci tipurile de date racord descriu elemente ale produsului cartezian T x x

... x T f
Produsele carteziene T pot fi descrise i prin tipuri de date axray.
Totui, tipul array nu este caz particular de tip record, pentru ^ = T, l < = i <= m,
deoarece operaia de selectare a componentelor n cazul tipului de date array este
mai general decit n cazul tipului racord
36
Limbajul Pascal
ntr-adevr, indicele unui tip axxay poate fi orice tip scalar (diferit de i n te ge r i
r e a l ) n timp ce proieciile canonice ale unui tip record snt desemnate prin identificatori.
Mai mult, un indice poate fi o expresie ce se evalueaz n timpul execuiei
programului dar identificatorii ce indic proieciile canonice snt stabilii la momentul scrierii
programului.
Cazul particular de tip record obinut prin T4 = T, i < = i < = m poate fi
definit ca un tip array, n care indicele este un tip enumerare. Astfel
type RT = zacord
poate fi definit prin
end;
x, y, z : T
type AT = array [(x, y, z)] of T;

Bineneles, operaiile de selectare a componentelor se noteaz n mod diferit (v.x
pentru v de tipul RT i v[x] pentru v de tipul AT). De asemenea, indicele unui element de tip
AT se poate exprima prin expresii de genul pr ed (y ) , s u c c ( p re d ( y ) ), eto.
Exist i o form mai general de tipuri record prin care se definesc reuniuni
disjuncte de tipuri de date. Acestea se numesc tipuri de date record cu variante. Elementele
unui astfel de tip snt articole ce conin o component prin care se identific tipul din care face
parte articolul. Aceast component apare explicit n definiia tipului record cu variante dup
cuvntul cheie case i se numete identificator de variant. Forma complet a unei definiii de
tip record cu variante este dat n anexa 3, diagramele 3.12-3.15. Ca i n cazul tipului record
fr variante, numele proieciilor canonice ale aceluiai tip trebuie s fie distincte ntre ele.
Exemplu. Prin definiiile:
type
varianta - (a, b); T - 1 . . 2 ; U
- 2 . . 3 ; reuniune_di s j record
case v : v a r i a n t a of
a : (X : T; y : U) ;
b : (Z : U; W : T)
and;
se introduce tipul reuniune_dis j . Elementele acestui tip se reprezint n Pascal prin:
r e u n i u n e _ d i s j (a, 1 , 2 )
reuniune_disj(b, 2 , 1 )
reuniune_disj(a, 1, 3 )
i
reuniune_disj(b, 2 , 2 )
reuniune_disj (a, 2, 2)
ieuniune_disj (a, 2, 3)
reuniune_disj( b , 3 , 1 )
reuniune_disj( b , 3 , 2 ) .
Aceasta corespunde reuniunii disjuncte T x U U U x T. Se oberv c elementul ( 2 , 2 ),

comun celor dou produse carteziene, apare dublat Operaiile de selectare a componentelor
snt desemnate de identificatorii distinci ntre ei v, x, y, z i
w.
Exemplu. S presupunem c se dorete prelucrarea unor progresii geometrice i
aritmetice. Identificm o progresie aritmetic prin elementul ( t , r ) e xe a l x r e a l
reprezentind primul termen i raia. n mod analog, o progresie geometric se reprezint prin
( u , q ) r e a l x r e a l . Rezult c o progresie (aritmetic sau geometric) este un element al
reuniunii disjuncte r e a l x real U r e a l x r e a l . n limbaj Pascal, urmtorul program
ilustreaz prelucrarea progresiilor:
type progresie = record case modul : ( a r, ge) of

a r : ( t , r : r e a l ) ; ge : ( u , q ; r e a l )
end;
var x : p r o g r e s i e ; begin
X : = p r o g r e s i e ( a r, 1 . 0 , 2 . 0 ) ; I p r o g r e s i e a r i t m et i c a }
w r i te l n C termenul t _ 1 0 - ' , x . t + 9 * x . r ) ; x : = p r o g r e s i e ( ge , 1 . 0 ,
2 . 0 ) ; { p r o g r e s i e ge o m et r i c a } w r i te l n ( ' termenul u_3 = ' ,
x . u * s qr ( x . q ) )
end.
Elementele acestui tip snt articole de forma p r o g r e s i e ( a r, t , r ) pentru progresiile
aritmetice i de forma p r o g r e s i e ( ge , u , q ) pentru cele geometrice. Natura variabilei x se
determin dup valoarea x.modul. Dac aceasta este a r, atunci primul termen este x. t, iar
raia este x. r. Analog pentru cele geometrice.
Exemplu. Presupunem c se dorete prelucrarea unor informaii referitoare la starea
civil a unor persoane. Aceste informaii conin numele persoanei, sexul, starea civil (cstorit,
cstorit i divorat, vduv, necstorit) i, dup caz, data cstoriei sau date cstoriei i a
divorului. Urmtoarele definiii introduc tipurile de date necesare unei astfel de prelucrri.
type d a t a = record luna : ( i a n , fe b , m a r, a p r, m a i , i u n ,
i u l , a u g , sep, o c t , n o i , d e c ) ; z i u a :
1 . .31; anul t integer
end;
type nume_persoana = racord
p r im u l , u l t i m u l :
type persoana = record
end;
packed . .10] of ch a r
nume : nume__persoana;
sex : (femeie, b r b a t ) ;
o
case st a t u t : ( c s to r i t , n e c s to r i t ,
d i vo r a t , vduv) of
c s to r i t ,
vduv
: (data_casatoriei: d a t a ) ;
divorat
: (data_cas,
d a t a _ d i vo r t: d a t a ) ;
n e c s to r i t : ( ) end;
Urmtoarele
articole:
persoana(nume_persoana('Popescu
',
'Ion
' ), b r b a t , c s to r i t , d a t a ( i a n ,
2,
1 9 4 0 ) ),
persoana ( n u m e _ p e r s o a n a ( ' I o n e s c u
',
'Mria
' ), fe m e ie ,
d i vo r a t , d a t a ( m a r, 2 , 1 9 5 0 ), d a t a ( o c t , 1 0 , 1 9 6 0 ) ), p e r s o a n a " (
mime_persoana( ' P o p a
'Ion
'), brbat,
n e c s to r i t ) , aparin tipului record cu variante persoana.
Asupra acestui tip de date se pot aplica urmtoarele operaii de selectare: nume,
nume.primul, nume.u l t i m u l , st a t u t , d a t a _ c a s a to r i e i . l u n a , data_cas. luna
etc.
2.2.3. Tipul de date set (mulime)
38
Limbajul Pascal
Unul din conceptele noi impuse de limbajul Pascal l reprezint tipul de date ale crui
elemente snt mulimi asupra crora se pot aplica operaiile uzuale.
Fie un tip scalar diferit de r e a l j e numete tip eet cu tipul de baza , mulimea
( T ) , format din toate submulimile lui . Definiia unui tip eet se face printr-o declaraie
sau
set of T
packed aet of T
unde prin este desemnat tipul de baz.

Spre exemplu, mulimea P ( { 1 ,
declaraia:
2,
5 0 } ), este definit prin
type S_l_50 = eet of 1 . . 5 0 ;

Construcia urmi element de tip eet se face n conformitate cu definiiile:
< s et > : : = [<lista_eleniente>] | [ ] <lista_elemente> : : = <element> 1 ,
<element> } <element> : : - <expresie> 1 <expresie> . . <expresie>
unde < e x p r e s i e > desemneaz o expresie (vezi 2.5) a crei valoare aparine tipului de baz.
Spre exemplu, pentru a desemna mulimea vid se folosete notaia (], iar pentru a
specifica mulimea { 1 , 2 , 3 , 4 , 5 } putem folosi una din variantele: [ 1 , 2 , 3 , 4 , 5 ]
sau
5] sau [1, 2 . . 3 , 4 , 5 ] ete.
Operaiile care se pot face cu variabile sau elemente de tip set snt: reuniunea (+),
intersecia (*), diferena (-), rezultatul fiind de tipul set, i egalitatea (-), inegalitatea (<>),
incluziunea (<", >-), rezultatul fiind de tipul boolean.
Operaia de apartenen a unui element la o mulime se specific prin cuvntul cheie
in, iar rezultatul este de tipul boolean.
De exemplu, dac a , b , c smi variabile de tipul S _ l _ 5 0 , a fiind mulimea vid, b
mulimea [ i , 2 , . . . , 4 0 } ic = [ 3 0 , 3 1 , . . . , 5 0 } atunci expresia 3 0 in b are valoarea
t i u e , reuniunea lui a cu b este desemnat prin a b, iar incluziunea mulimii [ i , 2 , . . ,
3 0 } in b prin [ 1 . . 3 0 ] < = b.
Observaie. Numrul de elemente ai multimii tipului de baz este limitat n
implementarea de fa la 256 (dac tipul de baz este o parte a mulimii numerelor

ntregi, atunci acesta trebuie s fie inclus n l o , 1 , . . . . , 2 5 5 } ) .
Exemplu. Prin execuia programului
var A , B , C : aat of 0 . . 5 ;
[ A , B , C - m u l i m i cu elemente numere n a t u r a l e i n t r e 0 s i 5 }
begin
A
:=
[1.-3,
5 ];
[A
conine
1,2,3,5}
B
:=
[5,
2..3,
1 ];
[B
conine
1,2,3,5}
C := [];
[C - m u l i m e a vida}
w r i te l n ( A - B , A - B - C , A+B = A ) ;
w r i te l n ( A + [ 4 ] = [ 1 . . 5 ], 3 in A , 1 in [ 1 ] ) ;
w r i te l n ( C < = A , [ 1 , 2 ] > = [ 1 ] , [ 1 , 2 ] O [ 1 ] )
and.
va fi scris de nou ori constanta true.

Exemplu. n programul urmtor, mulimile conin valori ale unui tip enumerare.
type st a r e - ( i n i i a l a , o a r e c a r e , fi n a l a ) ;
s: st a r e ;
end.
. .var
m : set of st a r e ; begln
s : - i n i i a l a ; m: =
[s];
w r i te l n ( i n i i a l a in m ) ; { s c r i e t r u e } m : = m + [ fi n a l a ] ;
writeln ( fi n a l a in n i ) ; { s c r i e t r u e ] n i : = m - [ i n i i a l a ] ;
w r i te l n ( i n i t i a l a in m ) { s c r i e fa l s e }
n paragraful 3.2.2.1 poate fi gsit un alt exemplu de utilizate a tipului de date set.
2.2.4. Tipul de date file (fiier)

Fie T un tip de date i EOF un element special care nu aparine lui T . Mulimea FT
= T* {EOF } se numete tip file (fiier) cu componente de tipul T . Elementele acestei mulimi
snt iruri finite i ordonate de elemente din T ,,urmate de EOF ; un astfel de ir se numete
fiier. Tipul T se numete tip de baz. Componentele fiierului se numesc nregistrri sau
articole.
Exemplu. Dac T este tipul i n te ge r, arunci urmtoarele iruri:
<0, -l, EOF > <1,
EOF >
<EOF>
'. ~ . ;
....
snt fiiere cu componente de tipul integer.

n limbajul Pascal, un tip fiier se definete prin:
< t i p _ fi s i e r > ::= file of < t i p > | packed file of < t i p >
unde < t i p > este tipul de baz. Atributul packed indic o compactificare a reprezentrii
componentelor fiierului n memorie.
Cele mai uzuale operaii asupra unui fiier snt extragerea ("citirea") i introducerea
("scrierea") unei componente noi. Aceste operaii se realizeaz prin procedurile predefinite get
sau r e a d i respectiv p u t sau w r i te . nainte de efectuarea operaiilor de scriere sau de
citire este necesar o aciune de validare a lor, numit deschidere a fiierului, realizat prin
procedurile predefinite r e s et i rewrite.
Dup tipul operaiilor permise asupra componentelor, fiierele se clasific n: fiiere de
intrare (este permis numai citirea); fiiere de ieire (este permis numai scrierea); i fiiere
de actualizare (snt permise scrierea i citirea). Operaiile permise snt fixate la
deschiderea fiierului.
Dup medul de acces la componente, fiierele se clasific n: fiiere cu acces
secvenial sau secveniale (accesul la componenta n este permis numai dup ce s-a
citit/scris componenta n-i) i fiiere cu acces aleator sau direct (orice component
se poate referi direct prin numrul ei de ordine n fiier). n lipsa altor specificri,
fiierele declarate n programele Pascal snt secveniale i de intrare sau de ieire.
Orice declarare de variabil f de tip fiier cu tipul de baz T conduce la
declararea implicit a unei alte variabile cu numele f * de tipul T, pe care o vom
numi variabil asociat fiierului i care se poate utiliza n programul Pascal, f * se
poate considera ca o "fereastr" prin care se extrage / introduce o component din /
40
Limbajul Pascal
n fiierul f. Aceasta este singura component accesibil la un moment dat i se

numete component curent.
Exemplu. Prin definiiile
type candidat = record
nume : packed array [1..30] of char; media: real
end;
t_fc
= file of candidat;
var fc
: t_fc;
se introduc tipul fiier t_f c cu componente de tipul candidat, variabila fiier f c
de tipul t_f c i variabila f c * de tipul candidat.
Observaie. n apelurile de procedur, parametrii actuali de tip fi l e snt
comunicai prin referin (vezi 4.6.2.2). Prin urmare, n declaraiile de procedur
parametrii formali de tip file vor fi declarai ca variabili prin specificaia var.
2.2.4.1. Fiiere secveniale 2.2.4.1.1.

Operaii de intrare/ieire
Fie definiiile Pascal:
type FT=file of T;
var f :FT; . ;
f,",:,, '.,,15* i'icy: prin care au fost introduse tipul fiier FT cu tipul de
baz T, variabila f de tip FT i variabila f * de tipul T. Pentru a explica
mecanismul operaiilor asupra tipului FT, introducem notaiile ce urmeaz. Fie
<c 1( c 2 ,.. .c ,EOF> valoarea lui f, unde n e N i Cj e T pentru i = i , . . . ,n snt
componentele fiierului f). Cnd n=o valoarea l u i f este <EOF> . Un fiier se
consider totdeauna a fi secionat n dou pri (partea sting i partea dreapt),
notate prin f , respectiv f d , astfel nct f =f fd. Definiiile lui f i fd se vor preciza la
descrierea operaiilor asupra fiierelor. Este posibil ca partea sting f s nu conin,niciun.element; aceast situaie se va nota prin f 3=e (e este elementul neutru la operaia de
concatenare). Partea dreapta.f d conine totdeauna cel puin elementul EOF.
. Exemplu. Dac variabila f este declarat prin
var f : file of i n te ge r ;
i are valoarea < o, -1, EOF>, este posibil ca f s aib valoarea o i n acest caz f d este < o ,
- l , EOF>. De asemenea, putem avea f = < o > i f d = < - i ,EOF>, sau f 8 = < o ,
- i > i
f D=<EOF>.
Definim funciile pariale p r i m u 1 : FT>T i r e st : FT ^>FT, unde FT
este mulimea fiierelor cu componente de tipul T prin:
p r i m u l ( < c 1 , c 2 , . . .c,EOF>) - c l ( daca n>l
r e st (<<=!,c 2 , . . . c N,EOF>)
< c 2 , . . c N,EOF> , dacan> l .
Se observ c aceste funcii nu snt definite n cazul n= o .

s Observaie. Valoarea variabilei f * asociate variabilei f de tipul fila este definit n felul
urmtor: dac f = f 3 f d i f d nu este <EOF>, atunci f " = p r i m u l ( f d ) ; n cazul f d =
<EOF> valoarea lui f - este nedefinit. Deci pentru f d * <EOF> , p r im u l ( f d ) este
componenta curent a fiierului.

Exemplu. n cazul cnd f = < o , i ,EOF> i f s = < 0 >, f d = < - l , EOF>avemf* =
p r im u l ( < - l , EOF>) = - l ; de asemenea, r e st ( < - 1 , EOF>) = <EOF>. Dac f s =
< 0 , - l > i f d = <EOF> atunci f * este nedefinit
Descriem n continuare procedurile i funciile predefinite care realizeaz operaiile
asupra tipului FT.
reset este procedura de deschidere a fiierelor pentru citire. Dac f este un fiier,
arunci dup apelul de procedur r e s et ( f ), avem f B=o, f d = f . Vom nota acest fapt prin
reset( f )
{ f 8=e, f d = f } .
n consecin, componenta curent este f * = p r i m u l ( f ).
Exemplu. Dac valoarea lui f este < o , - l ,EOF> atunci dup r e s et ( f ) avem f =e,
f d = < 0 , -1,EOF>; prin urmare f - = o. Notm acest fapt prin
{f=<0,-1,E0F>]
r e s et ( f )
{ f s=e, f d = < 0 , - l ,EOF>}
{f'=0}
Observaie. Dac fiierul nu conine nici o component din T ( f - < EOF >, adic
fiierul este vid) atunci, dup execuia lui r e s et ( f ) , f " este nedefinit.
eof este o funcie booleana care semnaleaz prin valoarea t r u e sfritul de fiier. Are
ca argument variabila f de tip fiier. ntotdeauna are loc relaia:
eof(f)
~ f D =< EOF >.
Se observ c dac f=< EOF > (fiierul este vid), dup deschiderea fiierului f prinreset( f ) avem
eof (f) =true.
get este procedura de citire a unei componente din fiier. Apelul de procedur get ( f )
este permis numai dac eof ( f ) = fa l s e . Dac f = x , f d = y, atunci dup execuia
instruciunii get ( f ) avem: f = x p r im u l ( y ) , f d - r e st ( y ) . n consecin, f " = p r i m u l
( r e st (y ) ). Vom nota acest fapt prin:
{ n ot e o f ( f ) , f = x , f d = y } get ( f >
t f a = x p r im u l (y ) , f d = r e st (y ) }
l f A = p r im u l ( f d ) = p r i m u l ( r e st ( y ) } }
Se observ c dac y = < c , EOF > (adic f * are ca valoare ultima component a
fiierului f ) atunci dup instruciunea get ( f ) , f * este nedefinit i eof ( f ) are valoarea
true.
Exemplu.
var f; file of integer;
begin
{ f = < 0 , - l , E OF > }
r e s et ( f ) ;
42
Limbajul Pascal
f = e , f d ~ < 0 , -l, EOF >}

{f=0}
{ n ot e o f ( f ) }
get ( f ) ;
{ f = < 0 > , f d = < - l , EOF >}
{ f - 1 1 { n ot eof( f ) } get ( f ) ;
{fs=<0,-l>, fd-<EOF>} (f*
n e d e fi n i t }
{ e o f ( f ) ; d e c i get ( f ) nu m a i e ste p e r m i s }
Prelucrarea n succesiune a tuturor componentelor unui fiier f se poate realiza
prin urmtoarea secven de program: . . .
var f : file of T;
r e s et ( f ) ; { f " e ste p r i m a componenta fl a l u i f }
while not eof( f ) do begin.
. . . { p r e l u c r a r e a componentei c u r e n te f * } get ( f ) ; { t r e c e r e a l a
componenta u r m to a r e , d a c a e x i st a }
end
..."
Exemplu. Programul urmtor calculeaz media aritmetic a cmpurilor media

din componentele fiierului f c:
type c a n d i d a t - record
n u m e : packed array [ 1 . . 3 0 ] of ch a r ; m e d i a : r e a l
end;
var
f c : file of c a n d i d a t; s : r e a l ;
n : m te ge r ;
begin
s:= 0; n:= 0;
r e s et ( f c ) ;
while not e o f ( f c ) do begin
n : = n + 1;
s:= s + fc".media;
get ( f c )
end;
if n < > 0 then w r i te ( ' m e d i a ge n e r a l a e ste = ' , s / n )
end.
Observaie. Citirea unei componente care precede componenta curent este
posibil numai relund citirea fiierului de la nceput prin apelul r e s et ( f ) .
rewrite este procedura de deschidere a fiierelor pentru scriere. Dup apelul
de procedur r e w r i te ( f ) , f=e i f d = < E O F > (deci eof ( f ) = t r u e i f = < E 0 F >, adic
fiierul este considerat vid). Notaie:
r e w r i te ( f ) { f .-a,
fd=<E0F>} {eof(f)}
put este procedura de scriere a unei noi componente n fiier. Apelul de
procedur p u t ( f ) este permis numai dac f d = <EOF>. Dac f 8 = x i f * = c , atunci
dup execuia instruciunii p u t ( f ) avem f = xc , f d = < E O F > , iar f * este nedefinit.
Notaie:
{ f e = x , f d - < E OF > , f =c )
put(f)
{ f , = xc , f d - < E O F > , f * n e d e fi n i t )
Exemplu, var f : file of i n te ge r ;
begin
r e w r i te ( f ) ; { f =e,
f d - < E OF > ) f*:=0;
put(f);
{f8 = < 0 > , fd-<EOF>l
{ f n e d e fi n i t ; a st fe l f * i - f * - l e ste i n c o r e c t } f - : - - l ; p u t ( f ) ;
{fa = < 0 , - 1 > ,
f d = < E OF > } ? f = < 0 , 1,E0F>}
end.
Observaii.
Dup apelul de procedur p u t (f), f * rmne nedefinit.
Prin execuia instruciunii p u t (f), valoarea lui f * se adaug l a
sfritul fiierului ca ultim component.
3.
O component deja scris nu se poate modifica dect prin rescrierea
ntregului fiier, validat prin r e w r i te .
Schema de utilizare a acestor proceduri pentru crearea unui fiier este
urmtoarea:
var f : file of T; . . . begin
1.
2.
r e w r i te ( f ) ; repeat
{atr ibuie valoare lui f * }
put(f)
until u l t i m a component a fo st a d u ga t ' end.
44
2. Tipuri de date, variabile, constante, etichete, expresii
xead i. x i ta smt proceduri de citite, respectiv serios, a valorilor unor variabile,

respectiv expresii de tipul T n fiier. Ele admit un numr variabil de argumente al. . . . , am de
tipul T. Apelul
read(f, a l , . . . , a m )
este echivalent cu secvena:
al:-f\- get (f) ; . . . , -am: =f\- get(f)
Apelul
write(f, a l , . . . , am) este
echivalent cu secvena:
f * : = a l ; put( f ) ; . . . ; f * : -am; put(f)
alome este o procedur prin care se interzice accesul la componentele unui

fiier f ptn la un nou reset sau rewrite (se spune c "nchide" fiierul). Aceast
procedur nu exist n limbajul Pascal standard. De notat c fiierele snt automat nchise la
terminarea execuiei programului sau cnd apar ca argumente ntr-un nou reset sau rewrite.
Utilizarea procedurilor de intrare/ieire este ilustrat n exemplul 1 din paragraful
3.3.
Sintetic, operaiile de creare i citire a unui fiier secvenial snt prezentate n schema
urmtoare:
->
(f)
rewrite
revrite(f)
<-
<get(f)
I
h-<->
>1
. _____f
.
1
----------1
i
reset(f)
i>
put(f)
1
*/---------
2.2.4.1.2. Fiiere text

In Pascal, tipul text este predefinit ca un caz particular de tip fila. Prin declaraia
var f : text;
se introduce fiierul f de tip text i variabila asociat f * de tip char.
Vom numi text valoarea (coninutul) unui fiier de tip text. Conceptual, textele snt
divizate m linii; modul efectiv de delimitare a liniilor nu este relevant pentru utilizator i
45
depinde de implementare. Pentru discuia care urmeaz, considerm tipul ch a r c extins cu

un caracter numit "sfrit de linie" i notat eol ( e o l C ).FieC' =c U { e o l } . Atonei tipul text
este mulimea C * { E O F } , ale crei elemente snt iruri de caractere (inclusiv e o l ) terminate
prin EOF. O linie este un ir < c l , . . . c , e o l > cu n > - o i c 4 e C. Linia care conine
componenta curent se numete linie curent. Cititorul poate tace analogie cu textul unei
cri, n care trecerea la nudul urmtor este marcat prin eol.
Evident, operaiile de intrare/ieire descrise n paragraful precedent rmn valabile
pentru fiiere text
Observaie. Dac p r i m u l ( f d ) - e o l atunci valoarea lui f * este spaiu. Deci la
citirea sfritului de linie (caracterul e o l ) acesta este transformat n spaiu.
Exemplu. Prin execuia programului
var f : te x t;
c: char;
begin
r e s et ( f ) ;
while not eof( } do begin
r e a d ( f , c ); { a d i c c : = f * ; get ( f ) ; } w r i te ( c )
end;
w r i te C . ' )
and.
cu fiierul f avnd coninutul < a , b , e o l , c , e o l , E O F > se afieaz rezultatul: ab c
Cele dou spaii corespund caracterelor eol din fiierul f.
n plus, utilizatorul dispune de operatorii predefinii e o l n , writeln i readln pentru
manipularea liniilor de text.
Reamintim c un tip de date este alctuit dintr-un domeniu (mulime de
valori) i o mulime de operaii. Prin urmare, alte tipuri declarate, prin fila of
char nu snt identice cu tipul te x t , deoarece au domenii diferite (C'* { E OF }
pentru text i c* { E O F } pentru fila of char) i operaii diferite ( r e a d l n ,
w r i te l n
i eoln pot fi aplicate numai fiierelor text). Spre exemplu,
programul
jj .
var i :
fila of ch a r ;
begin
r e s et ( f ) ;
readln(f)
este incorect
eoln este o funcie booleana care semnaleaz prin valoarea t r u e sfritul de linie.
Are ca argument o variabil de tipul te x t . ntotdeauna are loc relaia:
e o l n ( f ) * ( p r i m u l ( f d ) = e o l ) sau e o f ( f )
writeln este o procedur prin a crei execuie se marcheaz sfritul liniei curente a
fiierului text. Apelul de procedur wi i te In f) este permis numai dac f d= < E O F >. Dac f
B-x, atunci dup execuia instruciunii w r i te l n ( f ) avem f - x eol.
Observaii.
1.
n implementarea descris, la crearea unui nou fiier text, lungimea maxim

a unei linii este de 132 caractere (n <= 132); ea poate fi modificat prin specificarea
comutatorului " /VAR:n" n apelul r e w r i te (vezi 2.2,4.2).
2.
Spre deosebire de fiierele declarate fila of ch a r, scrierea ntr-un fiier te x t
f trebuie s se ncheie printr-o instruciune w r i te l n ( f ) ; n caz contrar, ultima linie de text
nu este totdeauna scris n fiier din motive dependente de implementare.
46
xeadln este o procedur prin care la citire se avanseaz la nceputul liniei urmtoare
celei curente. Apelul de procedur r e a d l n ( f ) este echivalent cu secvena:
while not e o l n ( f )
do get ( f ) ; get ( f )
Astfel, f * primete ca valoare primul caracter din linia urmtoare celei curente. Dac linia
urmtoare este vid (const doar din eol), atunci f * primete valoarea spaiu i e o l n ( f ) ia
valoarea true.
paga este o procedur cu urmtorul efect: textul scris n fiierul f dup apelul page
(f) va apare pe o nou pagin atunci cnd coninutul fiierului f este imprimat De fapt, apelul
p a ge ( f ) are ca efect inserarea n text a caracterului ff ("form feed"), interpretat de
imprimante drept comand de salt la pagin nou.
Utilizarea fiierelor te x t este ilustrat n exemplul 2 din paragraful 3.3.

Exploatarea caracter cu caracter a fiierelor text este greoaie atunci cnd secvene de
caractere din text trebuie interpretate ca formnd date de tip i n te ge r , r ea 1, boolean, ir
de caractere; conversia ntre formatul extern i reprezentarea intern a acestor tipuri ar cdea
n sarcina programatorului (vezi exerciiul 11 din capitolul 3). n consecin, procedurile
predefin te r e a d , r e a d l n , w r i te , w r i te l n snt extinse ntr-un mod nestandard,
admind un numr variabil de argumente de tipurile char, integer, r e a l , ir de caractere
("packed array of char"). Mai precis, fie f un fiier text i a, a l , . . . , am variabile de tipurile
menionate mai sus.
Apelul xaad (f, a) are urmtorul efect:
- dac este de tip integer sau r e a l , atunci este citit ntregul ir de caractere care
reprezint valoarea ntreag sau real i convertit la reprezentarea intern respectiv. n text,
datele numerice trebuie separate prin spatii sau eol. Spatiile sau eol dinaintea unei valori
numerice snt ignorate. irul de caractere care reprezint valoarea numeric se conformeaz
sintaxei constantelor numerice de tipul respectiv.
Exemplu. Fie programul:
var i : i n te ge r ; begin
while not eof do
begin
r e a d ( i ) ; w r i te ( i )
and
cod.
IM
-,*
.ti
prin care snt citite i scrise numere ntregi pe fiierele text input i o u t p u t (vezi paragraful
2.2.4.1.3). Trebuie observat c la introducerea datelor, ultima cifr a ultimului numr va fi
urmat imediat de sfritul de fiier (caracterul CTRL/Z); n caz contrar, dup ultimul numr
citit, condiia eof este fals; prin urmare, se execut nc o dat instruciunea r e a d ( i ) .
Deoarece n acest moment nu mai exist numere ntregi n fiierul input, va fi semnalat
eroare.
- dac a este un ir de caractere, atunci se citesc attea caractere cte snt
necesare pentru completarea irului. Dac nainte de executarea instruciunii

r e a d ( f , a ) condiia eoIn ( f ) este true, atunci irul a este umplut cu spaii; de
asemenea, dac n timpul citirii e o l n ( f ) devine true, atunci restul irului este
completat cu spaii; n ambele cazuri caracterul curent rmne eol.
Exemplu. Dac executm programul
.
var f : te x t;
a : packed array [ 1 . . 3 ] of ch a r ;
47
C!
begin
ch a r ;
r e s et ( f ) ;
r e a d ( f , a ) ; { c a r a c te r u l curent e ste e o l } w r i te l n ( a , e o l n ( f ) ) ;
r e a d ( f , a ) ; { c a r a c te r u l curent nu s - a m o d ifi c a t
deoarece a e ste s ir }
w r i te l n ( a , e o l n ( f ) ) ;
r e a d ( f , c ); { c a r a c te r u l curent s - a m o d i fi c a t
deoarece c e ste ch a r }
w z i te l n ( c , e o l n ( f ) ) ; r e a d ( f , c ) ;
w r i te l n ( c , e o l n ( f ) )
cu fiierul f avind urmtorul coninut

<l,2,eol,3,4,eol,EOF>
atunci rezultatele afiate snt:
12 TRUE
TRUE
FALSE
3
FALSE
Apelul xead(f,
al,..., an) este echivalent cu secvena:
r e a d ( f , a l ) ; . . . ; r e a d ( f , am) Apelul xeadln( f , al,..., am) este echivalent

cu secvena:
r e a d ( f , a l , . . . , a m ); r e a d l n ( f ) Fie f un fiier text i a , a l , . . . , am
argumente de una din formele:
e
e:ix
undea este o expresie de tip char, integer, real, boolean sau packed azray of char (ir de
caractere), a crei valoare trebuie scris n fiierul f n format extern; ij i i2 snt expresii de
tipul integer, numite specificatori de format
i, specific prin valoarea sa absolut numrul minim de caractere ce vor fi folosite la
scrierea valorii lui a n fiierul f; dac Snt necesare mai puin de I ij | caractere, atunci
forma extern a valorii lui a este completat cu spaii la sting pn la | i t | caractere. Dac o
valoare numeric necesit mai mult de J it | caractere, se scriu attea caractere cte snt
necesare (valoarea numeric nu este trunchiat). irurile de caractere i valorile booleene snt
trunchiate la primele | i11 caractere. Valoarea implicit a lui it este dependent de
implementare i de tipul expresiei :

Tipul lui.a
i n te ge r
real
char
i i i mp l i c i t
7
13
48
packed array of char

boolean
| lungimea i r u l u i
2.2.
Tipuri
structurate
dc
date
43
O valoare ij. negativ are sens numai n cazul cnd e este de tip integer, packed
azzay of char sau char: ntregii snt scrii n baza 8, tar scrierea irurilor de caractere
(caracterelor) este suprimat
i, are sens numai n cazul cnd expresia a este de tip real i specific prin valoarea sa
absolut numrul de cifre care urmeaz punctului zecimal n scrierea valorii lui a n virgul fix. n
lipsa lui i2, valoarea lui a se scrie In virgul mobil (cu factor de scal). Exponentul este format din
litera ' E ', semnul ' ' sau ' - ' i dou cifre zecimale. Dac i2 are valoare negativ, atunci valoarea
expresiei a este scris n virgul mobil.
Apelul write(f ,a) are urmtorul efect: valoarea expresiei a din argumentul a este scris
in fiierul f de tip text, convertit la formatul extern conform specificatorilor de format ilf i2.
Apelul wzite (v, al,..., a) este echivalent cu secvena:
write(f, a l ) ; . . . ; w r i te ( f , a m ). Apelul zitain(f, al,..., an) este echivalent cu
secvena:
w z i te ( f , a l , . . . , am); wiiteln(f) . Exemplu.
Programul var
i : integex; r : real;
s i packad array [ 1 . . 1 0 ] of char; b s boolean;
begin
i:- 323;
r : 3 . 1 4 1 5 9 2 6 ; { r primete valoarea 3 . 1 4 1 5 9 3 } s : = 'specificat'; b : = true;
writelnCi-', i , ' ; ' , i : 4, ' ; ' , i : 2 , ' ; ' , l : - 4 ) ;
writelnCr-', r,
r:10, ';', 1:4, ';', r:4:6,
'.ii*.
and.
writeln('r=', r: 1 0 : 3 , ' ; ' , r : 1 0 : 8 , ' ; ' , r : 1 0 : - 5 ) ; writelnCs-', S ,

' ; ' , . s : 1 2 , ' ; ' , 3 : 8 ) ; writeln('b=', b, ' ; ' , b : 3 , ' ; ' , b : 7 )
afieaz rezultatele:
i323; 323;323; 503
r- 3 . 1 4 1 5 9 3 E + 0 0 ; 3 . 1 4 1 5 9 3 E + 0 0 ; 3 . 1 4 1 5 9 3 E + 0 0 , - 3 . 1 4 1 5 9 3 ;
1=
3.142;3.14159300;3.14159E+00
s =specificat; specificat;specific
'<
b- TRUE;TRU;
TRUE
2.24.U. Fiierele standard input i output
Exist dou fiiere text cu numele input i o u t p u t , predeclarate astfel: var i np u t , o u t p u t:
te x t; i asociate implicit cu mediile standard de intrare i respectiv ieire ale sistemului de calcul.
n implementarea descris, ambele stnt asociate cu terminalul utilizatorului (TI:). Dat fiind
utilizarea lor frecvent, numele lor snt luate ca valori prin lips ale numelui de fiier text n operaiile
de intrare/ieire. Prin urmare, apelurile urmtoare snt respectiv echivalente:
read(al, . .., a)
cu
readln ( a i y . . . , a )
cu
49
readln
w r i te ( a i ,
aj
w r i te l n ( a l f . . . , a )
w r i te l n ;
r e a d ( i np u t , a x , . . . , a m )
readln( i np u t , a1#. . . , ' aj
cu
cu
cu
cu
readln( i np u t )
w r i te ( o u t p u t , a l f
a)
w r i te l n ( o u t p u t , a w . . . , a m )
w r i te l n ( o u t p u t ) .
n cazul folosirii acestor fiiere, standardul prevede specificarea lor n lista de

parametri din antetul de program. n implementarea descris, acest lucru nu este
necesar. Fiierele standard input i o u t p u t snt deschise automat la nceputul execuiei
programului. Apelul reset ( i np u t ) este echivalent cu r e a d l n , iar r ewr i te (ou t p u t )
termin linia de text curent. Apelurile r e s et ( o u tpu t) i r e w r i te ( i np u t ) snt
incorecte.
I
Observaii.
1.
La deschiderea pentru citire a unui fiier text asociat cu un terminal
interactiv (de exemplu input asociat cu i i : ) , variabila asociat (n exemplu i np u t * )
primete valoarea spaiu, iar funcia e o l n primete valoarea fa l s e , fr s se
transmit efectiv vreun caracter.
2.
Conform standardului Pascal, variabilele input i output trebuie considerate variabile globale dac apar ca argumente n antetul de program. n implementarea
descris, antetul de program este ignorat i variabilele input, output snt predeclarate ca
variabile globale. Deci la nivelul global, programatorul nu poate declara o variabil sau o
procedur cu numele input sau output.
2.2.4.2. Asocierea fiierelor Pascal cu fiiere externe
Fiierele existente independent de programul Pascal se numesc fiiere externe.
Acestea snt recunoscute i gestionate de sistemul de operare. Exist posibilitatea de asociere a
fiierelor Pascal cu fiiere externe. Standardul Pascal prevede ca aceast asociere s se
realizeze prin specificarea fiierelor externe ca argumente n antetul de program. n
implementarea descris, antetul de program fiind ignorat.

_______
2.2. Tipri de date structurate
45
asocierea fiierelor externe se realizeaz prin extensii ale procedurilor z e s et i

r e w r i te . Restul paragrafului descrie aceste extensii, in apelurile:
r e s et ( f , n , c , i )
r e w r i te ( f , n , c , i )
argumentele f , n, c , i au urmtoarea semnificaie: f este o
variabil de tip file.
n (opional) este o variabil sau constant de tip ir de caractere (packed zzay of
char) i conine numele fiierului extern asociat cu fiierul Pascal f. Prin lips, fiierul extern
are numele i extensia vide; el este ters din catalogul curent la terminarea execuiei
programului.
c (opional) este o variabil sau constant de tip ir de caractere i conine alte
cmpuri ale specificaiei de fiier extern neincluse n n. Att n n ct i n c se pot specifica
opiuni de intrare / ieire relative la fiierul etern asociat O list complet a opiunilor de
intrare / ieire apare n [Pa81]. Aici le descriem pe cele mai des utilizate:
50
/ SEEK : permite apelul procedurii seek (vezi 22.4.3) n programul Pascal pentru
exploatarea unui fiier n acces direct
/WR: permite operaii de citire i scriere ntr-un fiier secvenial, indiferent de
modul de deschidere. Opiunea /WR poate fi utilizat la adugarea unei componente noi la
sfiritul unui fiier extern deja existent la nceputul execuiei programului.
/si m: n specific numrul de blocuri de 512 bytes ce se vor aloca fiierului creat
prin r e w r i te .
/VARm: fiierul va avea nregistrri de lungime variabil, cu lungimea maxim n.
i (opional) este o variabil de tip integer, n care procedurile reset, r ewr i te ntorc
dimensiunea fiierului n blocuri de 512 bytes, sau valoarea -l n cazul unei erori la
deschiderea fiierului.
Exemple:
1. Prin instruciunea
rewrite( fi s , ' F is . DAT ' )
se deschide pentru scriere fiierul Pascal fi s asociat cu fiierul extern Fis .DAT din catalogul
curent
r e w r i te ( f ,'FILEl/SEEK',*.DAT/SI: 2' )
se deschide fiierul cu acces direct f asociat cu fiierul extern FILEI . DAT, cruia i se aloc
2 blocuri.
r e w r i te ( f , , '/SEEK')
se deschide fiierul cu acces direct f.
r e w r i te (output,' L P O : ' )
se asociaz fiierul standard output cu imprimanta LPO: a sistemului de calcul. Observaii.
1.
La deschiderea prin reset a unui fiier asociat cu un fiier extern pe disc
fr specificarea versiunii, sistemul de operare alege dintre toate fiierele cu numele specificat
n xe s et existente n catalog pe cel cu versiunea maxim.
2.
La deschiderea prin xewr i te a unui fiier asociat cu un fiier extern pe
disc tar specificarea versiunii, sistemul de operare creeaz un fiier cu versiunea cu 1 mai
mare dect versiunea maxim a fiierelor cu acelai nume existente n catalog n acel moment:
dac un astfel de fiier nu exist, numrul de versiune este 1.
51
2.2.4.3. Fiiere cu acces direct
Acest paragraf se refer n ntregime la implementarea Pascal Oregon.
Prin declarare, fiierele cu acces direct nu se deosebesc de cele secveniale.

Diferenierea ntre cele dou categorii de fiiere se realizeaz la deschiderea fiierului. Pentru
fiierele cu acces direct este obligatorie specificarea opiunii ' / S E E K ' n apelul procedurilor
r e s et i r e w r i te (vezi 2.2.4.2). Indiferent de modul de deschidere, un fiier cu acces direct
este fiier de actualizare. Fiierele cu acces direct se pot asocia cu fiiere externe numai pe
disc. Componentele unui fiier cu acces direct se consider numerotate ncepnd cu 1.
Operaiile, de intrare / ieire pentru fiiere cu acces direct se execut prin apelul
procedurilor;i funciilor standard prezentate n 2.2.4.1.1. Accesul direct la componentele
fiierului f se realizeaz schimbnd componenta curent prin apelul procedurii nestandard
seek. Mai precis, fie f=<c1#.. . f n , EOF> un fiier i i o variabil sau constant de tip integer
cu valori n domeniul 1. . n. Dup apelul seek ( f , i ) , componenta cu numrul de ordine i a
fiierului f devine component curent i valoarea ei se regsete n variabila f *. Dac
f=<EOF> (fiier vid) sau dac valoarea lui i iese din domeniul 1. . n atunci funcia eof ( f )
primete valoarea true.
n consecin, se pot scrie secvene de program pentru:
1. Scrierea secvenial ntr-un fiier cu acces direct, ncepnd cu componenta i: var
f: file of T;
r e w r i te ( f , , ' / S E E K ' ) ;
seek(f,i);
while . . . { e x i st a d a te de s c r i s } do begin . . . . { c a l c u l e a z a }
f * : - a ; p u t ( f ) { s a u w r i te ( f , a ) } ead . . .
nenta i.
2. Citirea secvenial dintr-un fiier cu acces direct, ncepnd cu compo-
reset( 1 , , ' I SEEK') ;

seek(f,i);
while not eof( f ) do begin
a : = f * ; get ( f ) ; { s a u r e a d ( f . a ) ; } . . .
{prelucreaz a } nd . . .
3. Actualizarea componentei i:
reset( f ' / S E E K ' ) ;
ii: i
s e e k ( f , i ) ; a : - f ; . . . { m o d i fi c a a }
seek(f,i); f.*:-a; put(f);
Jii
...
:i
Exemplul 3 din paragraful 3.3 ilustreaz modul de utilizare a fiierelor cu acces

direct.
:
23. Tipul de date pointer (referin)
52
Mecanismul de declarare a variabilelor prin definiii var desemneaz variabilele prin

identificatorii asociai. Numrul de variabile i identificatorii lor snt reflectai de textul
programului. Ele pot fi utilizate cu destinaia de variabile pe toat durata execuiei blocului n
care au fost definite (vezi pentru detalii 4.3.3). Exist situaii n care numrul necesar de
variabile de un anumit tip nu este acelai pe toat, durata execuiei unui bloc.
S presupunem c se dorete prelucrarea unui vector cu n componente de tipul
integer. Dac n este cunoscut n momentul scrierii programului (sau cel puin valoarea sa
maxim N) atunci se utilizeaz o declaraie de forma vax v : azray [ 1 . . N ] of i n te ge r ;
unde N este o constant (literal sau identificator de constant). Pe toat durata execuiei este
rezervat un spaiu de memorare necesar pentru toate cele N componente ale lui v.
Ar fi mai avantajos, din punctul de vedere al ocuprii spaiului de memorie, un
mecanism de definire a numrului de componente in momentul execuiei. Spre exemplu,
dac de fiecare dat cnd se genereaz o nou component a vectorului exist posibilitatea de
a crea o nou variabil de tipul integer n care s fie reinut valoarea noii componente,
atunci spaiul de memorie alocat este cel strict necesar.
Sntem prin urmare n prezena unui fenomen de generare dinamic de variabile de
un anumit tip.
Fie T un tip de date. Ptintr-o definiie de forma
type PT
- "T;
se introduce un nou tip PT care este o mulime de variabile de tipul T. PT se numete tip
de date pointer. O variabil de tipul PT declarat prin:
var p : PT;
ia ca valori variabile de tipul T. Variabila de tipul T desemnat de p la un anumit moment
al execuiei se noteaz cup*. Atribuirea unei variabile de tipul T lui p se face prin procedura
predefinit nev. Variabila p * obinut prin instruciunea new ( p ) este distinct de toate
variabilele de tip T create anterior. Executarea repetat a instruciunii new ( p ) conduce la
crearea unui ir vL, . . . . . . . . v de
variabile de tipul T. Numai ultima variabil creat, v, este referit prin p *.
Procesul dinamic de creare de variabile de un anumit tip T presupune i existena
unui mecanism de distrugere a lor i de eliberare a spaiului de memorie ocupat Acest lucru
se realizeaz prin utilizarea procedurii predefinite dispoae.
' Dup executarea unei instruciuni dispose ( p ), variabila p * devine nedefinit De
asemenea, p nu este definit atunci cnd nu s-a executat nici o instruciune new ( p ) . Dac
dorim ca p s nu indice nici o variabil, atunci i asignni valoarea constantei predefinite nil.
Dac y este o variabil de tipul T, p poate lua ca valoare aceast variabil printr-o
instruciune de atribuire p: ref (v ) .
Exemplu: var
p
: * i n te ge r ; x , y :
integer; begin
p : = nil; { p * nu e x i st a i n a c e st moment, dar p a r e valoarea n i l !
new(p); {a fost creata o variabila p* de tip intreg} p * := 0 ;
writeln(p*); { scrie numrul 0 }
x :~ 1;
y :- 2 ;
p : - ref( x ) ;
writeln(p'); { scrie numrul 1 } p := e f (y ) ;
53
writeln(p*); { scrie numrul 2 }

dispose( p ) ; { p * nu mai exista in acest moment iar valoarea lui p este
nedefinita}
end.
Alte aplicaii ale tipului de date pointer sint prezentate n legtur cu tipurile de date
recursive n paragraful urmtor.
2A.
Tipuri de date recursive
Tipurile de date pointer ofer posibilitatea de a reprezenta n programe Pi.si.iil date a

cror definiie este recuri v.
O bun ilustrare se obine n cazul reprezentrii grturilor orientate. S considerm
mai nri gtafuri de forma unor liste
1------> 5 -------> 7
cu nodurile marcate prin cifre zecimale, definite astfel n notaie BNF:
<lista> : ; = <element> <lista> | e
<element> :0 1 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
Caracterul recursiv al definiiei este dat de prima regul. Precizm c e este
elementul neutru pentru operaia de concatenare. Deoarece o list diferit de este dement al
produsului cartezian <element> x <lista>, este sugerat folosirea tipului de date record.
Aceasta ar conduce la utilizarea numelui de tip lista pentru propria sa definiie, ceea
ce este interzis n limbajul Pascal. Este posibil ns depirea acestei interdicii prin
intermediul tipului de date pointer.
O list este identificat prin primul ei element i prin sublista ce urmeaz acestui
element n limbajul Pascal aceasta revine la definiia
type legtura - * lista; type lista =
record
element : 0 . . 9 ;
sublista : legtura
nd;
Se observ c n definiia tipului l i st a se folosete tipul pointer l e g t u r a , definit
la rindul su pe baza tipului l i st a . Aceast circularitate este consecina recurivitii
definiiei listei.
Mai mult, utilizarea tipului l i st a precede definiia lui (aceasta este o excepie, n
general utilizarea unei entiti se poate face dup ce aceasta a fost definit).
O list va fi reprezentat n programe Pascal printr-o variabil de tipul pointer
declarat prin
vai 1 : legtura;
Efectul execuiei instruciunii n e w ( l ) este crearea unei variabile 1 * de tipul l i st a .
Dac 1 - nil, atunci se consider c lista 1 A este vid (adic a).
Exemplu. Lista l ----------> 5 ------> 7 descris prin arborele
< l i st a >
54
<element>
< l i st a >
1 <element> < l i st a >

I
<element> < l i st a >

a
7
poate fi obinut prin urmtorul program:
type legtura - " l i st a ; l i st a
= record
element : 0. . 9 ;
s u b l i st a : legtura
and;
var.p, g , r t legtura; begin
and.
new (p);
q : = p; q * . element: = 1;
r : = q ; n e w ( q ) ; r * . s u b l i st a : - q ; q * . e l e m e n t: = 5 ; r : = q ; n e w ( q ) ;
r A . s u b l i st a : = q ; q * . e l e m e n t: - 7 ; q * . s u b l i st a : = nil;
Prezentm un alt caz, cel al arborilor binari de forma

2
/ \
1
/ \
definii prin
<arbore> i : = (<nod> , <arbore>, < a r b o r e > ) | <nod> | a <nod> : : =
0 | l | 2 | 3 | 4 | 5 | 6 r 7 | 8 | 9 .
ies--,
Deoarece un arbore este fie n form complex, adic un nod urmat de un

(sub)arbore sting i altul drept, fie n form simpl, adic un nod, el este un element al
reuniunii disjuncte de tipuri <nod> x <axbore> x <arbore> U <nod>. De asemenea, el poate
fi vid, adic a. Aceasta sugereaz utilizarea tipurilor record cu variante. n limbajul Pascal
acest arbore poate fi obinut prin programul:
type legtura - *arbore; type
a r b o r e - record
case fe l : (complex, simplu) of complex : (nod :
0..9;
a_sting,
a_drept : l e g t u r a ) ; simplu
(nod_terminal : 0 . . 9 )
55
end
and;
var p , q , st , d r : legtura; begin
new ( p ) ;
q : - p;
q * . fe l : - complex; q * . n o d : = 2 ; new( st ) ; new( d r ) ; q*.a_sting:- st;
q * . a _ d r e pt: - d r ; q : = st;
q ' . fe l : - s i mp l u ; q * .nod_terminai: = 1; q : = d r ;
q * . fe l : complex; q * . n o d : = 3 ; new(st ) ; new(dr) ; q * . a _ st i n g : - st;
q * . a _ d r e pt: = d r ; q s = st;
q * . fe l : - s i mp l u ; q A .nod_terminai: - 7 ; q t - d r ;
q * . fe l : = complex; q ' . n o d : - 4 ; n e w ( st ) ; dr:
nil; q * . a _ st i n g : - st; q * . a _ d r e pt: = d r ; q : - St;
q * . fe l : - s i mp l u ; q * . n o d _ te r m i n a i : - 5;
ud.
Alte ilustrri ale tipurilor de date recursive se gsesc n exemplul 4 din paragraful 3.3
i n exemplele 5, 6, 7 din paragraful 4.5.4.
2.5. Expresii
n timpul execuiei unui program pe calculator, instruciunile sale prelucreaz
elemente ale tipurilor de date predefinite (integer, r e a l , etc), sau ale celor definite de
programator (array, racord etc.). Aceste elemente snt referite prin intermediul variabilelor i
constantelor i asupra lor snt aplicate anumite operaii. Variabilele snt identificatori ce apar
ntr-o declaraie var sau snt referite prin intermediul unei alte variabile de tipul pointer (vezi
paragraful 2.3 pentru detalii). Constantele snt numere, iruri de caractere (vezi 1.2),
constante structurate (vezi anexa 3, diagrama 3.9), constante predefmite ( m a x i n t , nil,
t r u e , fa l s e ) sau identificatori declarai prin const. Numele operaiilor, paritatea i sensul
lor pot fi de asemenea predefinite ca n cazul , -, div, mod pentru tipul integer etc, sau
definite de programator, ca n cazul numelor proieciilor canonice ale tipurilor record i ale
operaiilor introduse prin funcii i proceduri (vezi capitolul 4).
Se poate deci considera c execuia unui program se desfoar n cadrul unui
model logic de signatur dat, al crui domeniu D este format de tipurile de date. Signatura
acestui model cuprinde mulimea simbolurilor operaiilor predefinite (+, - , succ etc) sau
definite de programator (proiecii canonice, identificatori de funcii i proceduri etc.), mulimea
simbolurUor predicat predefinite ( < , > , >-, in etc.) sau definite de programator i mulimea
simbolurilor constant (numere, iruri de caractere, identificatori de constante predefmite
precum m a x i n t , nil, false, t r u e i identificatori definii prin const). Interpretarea acestor
simboluri este fie predefinit, fie stabilit de programator.
Se pune deci n mod natural problema modului n care aceste elemente pot fi
agregate n limbajul Pascal pentru a obine expresii. Sintaxa acestor expresii este descris n
anexa 3, diagramele 3.24-3.25. Se poate observa c cele mai simple expresii snt constantele
fr semn i variabilele. Astfel, numrul l. 2E -10, caracterul ' A ' , constantele predefinite
m a x i n t , nil, t r u e , fa l s e , constantele structurate M2RA (LINIE (I.O, 2.0),
LINIE (3.0, 4. o) ) , variabilele x, Y, v * snt expresii n limbajul Pascal. Expresiile de la
urmtorul nivel de complexitate se numesc factori (anexa 3, diagrama 3.28) i se obin prin
aplicarea opional a simbolurilor funcie, a simbolului predicat no t i a parantezelor ( , ) sau
[, 1. Astfel X, s i n (XI), a r c t a n ( V ) , zound(2.8), not fa l s e , (2),
[ a , b , c ] (desemneaz mulimea cu elementele a, b i c), [ 1 . . 5 ] (desemneaz intervalul
de numere ntregi n, 1 <- n <= 5) snt factori.
56
Prin aplicarea opional a operatorilor multiplicativi *, /, div, mod i and asupra

factorilor se obin termeni (anexa 3, diagrama 3.26). Astfel x, a * b, a * b mod 10, not
x and y and z snt termeni. Din termeni se obin expresiile simple (anexa 3, diagrama 3.27)
prin aplicarea opional a operatorilor aditivi , - i or sau prin aplicarea semnelor + i -. Spre
exemplu, x + (-1 ) , a * b, -a * b, a * b + b mod 10, not x and y and z or
not false snt expresii simple. Cele mai complexe expresii Pascal se obin prin aplicarea
simbolurilor predicat <, >, <-, >, -, <>, in. Astfel, x, x < y, x + y in z , (i < j) = (j
< k), x in [2, 3 , 6] snt expresii Pascal corecte sintactic.
Expresiile prezente n textul unui program Pascal snt evaluate n cursul execuiei
programului pe calculator. Rezultatul depinde de valorile variabilelor la momentul cnd se face
evaluarea (valorile constantelor nu se modific n cursul execuiei). Spre exemplu, expresia x
< o este evaluat la valoarea false dac valoarea lui x este l; este posibil ns ca la o
evaluare ulterioar s aib valoarea true dac ntre timp valoarea variabilei x s-a schimbat
Operaiile predefinite snt clasificate n patru categorii, dup prioritatea pe care o au
n cursul evalurii expresiilor. Cea mai mare prioritate o are operaia not. Urmeaz apoi n
ordine descresend a prioritilor operaiile multiplicative, operaiile aditive i operaiile
relaionale:
prioritate
0
(cea mai mare)
(cea mai mica)
operaia
1
2
3
<
not
* / div mod and
+ - or
<=
>
>
in
Prioritatea operatorilor este reflectat n regulile 2.25-2.29 din anexa 2. Spre

exemplu, conform notaiei BNF, expresia a+b*c este descris prin arborele de derivare
urmtor:
<expresie>
/
<termen>
I
<factor>
I
<variabil>
I
<expresie_simpl>
I
\
<operator_aditiv>
<termen>
I
/
1
\
+
<factor> <operator_multiplicativ> <factor>
I
I
I
<variabil>
*
<variabil>
Din plasarea celor doi operatori n acest arbore (+ mai aproape de rdcin dect *)
rezult c operaia * se execut naintea operaiei +.
Secvenele de operaii care au aceeai prioritate snt evaluate de la sting la dreapta.
Expresiile dintre parantezele ( , ) sau [ , ] snt evaluate independent de operaiile care le preced
sau care le urmeaz. Se observ c operaiile not, and i or au aceeai ordine a prioritilor
ca n algebra booleana;
Trebuie remarcat c operaiile relaionale <, <-, etc. snt definite i pentru operanzi de
tipul predefinit boolean, deoarece false < true. Prin urmare, operaia < - are sensul de
implicaie logic, iar = are sensul de echivalen logic. Aceast ncrcare cu sensuri
suplimentare a operatorilor relaionali are ca efect o scriere mai complicat a expresiilor logice
n limbajul Pascal dect n matematic sau n alte limbaje de programare (spre exemplu, n
AlgoloO exist simbolurile predicat implicaie logic i echivalen logic). Astfel, n cazul
declaraiei
var x , y, z : r e a l ;
57
expresia
(x <- y ) and ( y <" z ) <= ( x <- z )
este evaluat totdeauna a valoarea true i exprim proprietatea de tranzitivitate a relaiei <-.
Omiterea parantezelor conduce la expresia
x <= y and y <= z <= x <- z
care este incorect semantic, deoarece se evalueaz mai nti operaia y and y care nu are
sens pe tipul r e a l . Mai mult, dac x , y i z Snt de tipul integer, ultima expresie este corect
semantic dar evaluarea ei se face ncepnd cu operaia and (vezi paragraful 2.1.1).
2.6. Exerciii
1.
a) S se reprezinte n cod complementar pe 2 bytes numerele ntregi - 2,

-l, 0, 1, 2.
b) S se reprezinte n virgul mobil (ampl precizie i dubl precizie) urmtoarele
numere reale: + 3 . 0 , - 3 . 0 .
2.
Dac un numr pozitiv x se reprezint n virgul mobil prin x o . i x x . . . x n * 2" (vezi paragraful 2.1.1 tipul r e a l ) , atunci s se reprezinte
numrul ntreg i o ... 01 (scris n baza 2, avnd n zerouri).
2.6.
Exerciii
55
3.
Snt corecte urmtoarele definiii?

a)
type culoare ( a l b , r o u , verde, ga l b e n ) ;
alta_culoare = ( p o r to c a l i u , ga l b e n ) ;
b)
JSypa z i l e = ( l u n i , m a r i , m i e r c u r i , j o i ) ;
p r im e l e _ 3 _ z i l e = luni. . m ie r c u r i ;
4.
Fie declaraiile:
type T = i n te ge r ; var
A , B : integer; C
: integer; D
: T;
E
: T;
Dac x i Y aparin mulimii { A , B , c , D , E } , care dintre atribuirile "X : - Y" este

acceptat de compilatorul utilizat? 5.
Fie declaraiile
type R - record I , J : integer end;
A - array [ 1 . . 2 ] of integer; var
R; AR : A;
RE :
58
Care dintre urmtoarele atribuiri este corecta?

RE.I
- AR [1] ;
= RE.J;
AR[2]
= AR;
RE
6.
Fie declaraiile
type numr - ( u n u , d o i ) ;
complex = record
r e , im : r e a l end;
v a r i a n t a = record
A : integer;
case alege : numr of
unu : ( B , C : c o mp l e x ) ;
doi : (D : c o mp l e x )
end;
Care dintre urmtoarele constante structurate snt conforme cu definiiile de mai sus:
a) v a r i a n t a (1,unu,complex(1.1 , 0.IEI),complex(- l . 0 , 0 . 5 ) ) ;
b)
complex ( - 1 . 0 , 2.3E5);
c) v a r i a n t a (2, d o i , (1.1, 1 . 1 ) )
7.
8.
a) Declarai variabilele A, B, c de tip set avnd tipul de baz mulimea

{ 1 , 2,..., 1 0 } .
b) Atribuii tui A mulimea {1 , 2, 3, 4 } , lui B mulimea {3, 4 ,
iar lui c mulimea A U B.
b) Care este valoarea expresiei 4 in A * B ?
5, 6} ,
Re declaraiile
type p i = " i n te ge r ; var
integer; vp : p i;
S se arate cum se pot realiza urmtoarele aciuni:
a)
vp este referin la o variabil de tip integer egal cu 1;
b)
i este egal cu 1;
c) vp este referin la i .
9.
S se evalueze urmtoarele expresii Pascal:

a) l and 2 < 5;
b) 1 * 2 < 5
c) (l <= 2) and (2 < = D
d) 1 <= 2 and 2 <= 1
e) x < = 0 - ( - x > = 0 )
10.
Exprimai
numere reale.
limbajul
Pascal
expresia
algebric
xy,
unde
snt
Sintaxa instruciunilor limbajului Pascal este descris n anexa 2, definiiile 2.22 2.23 i n anexa 3, diagramele 3.22 - 3.23.
O instruciune este alctuit dintr-o etichet opional prin intermediul creia poate
fi referit din alte instruciuni, urmat de instruciunea propriu-zis, prin care este descris
aciunea realizat n momentul execuiei sale. Se face distincie ntre instruciunile simple
(instruciunea de atribuire, apelul de procedur, instruciunea de transfer necondiionat i
instruciunea de efect nul) i instruciunile structurate (instruciunea compus, instruciunile
iterative, instruciunile condiionale i instruciunea with).
3.1. Instruciuni simple

O instruciune se numete simpl dac nu conine alte instruciuni.
3.1.1. Instruciunea de atribuire

Aceast instruciune are forma
v. s - E
unde v este o variabil (vezi diagrama 3.24 din anexa 3), iar E este o expresie (anexa 2,
definiia 2.23.b).
Prin execuia instruciunii de atribuire, expresia E este evaluat i rezultatul se
atribuie variabilei v. Variabila i rezultatul evalurii trebuie s fie de tipuri identice, sau tipul
uneia s fie un subdomeniu al celeilalte, sau ambele s fie subdomenii ale aceluiai tip iar
rezultatul n subdomeniul variabilei. Se admite ca excepie cazul cnd variabila este de tipul
r e a l iar rezultatul de tipul i n te ge r sau un subdomeniu al acestuia.
Spre exemplu, s considerm declaraiile urmtoare:
ip
type T12 = 1. . 2; T13 = 1 . .

3 ; ABC = ( a , b , c );
complex = r e c o r d
r e , im . : r e a l and;
t a b - azray [ABC] of complex; conat i complex( 0 . 0 , 1 . 0 ) ;
c_tab - tab(complex( 0 . 0 , 0 . 0 ),
'
60
3. Instruciuni
complex( 1 . 0 , 1 . 0 ),
complex( 0 . 1 , 1 . 0 ) ) ;
var k : integer; v l 2 : l f . 2;
v l 3 : 1 . . 3 ; VS6 :
5 . . 6 ; al2 : T12; a l 3
: T13; v_logic :
boolean; r
: real;
v_tab : tab; z :
complex;
n acest caz instruciunile
k : = v l 2 ; vl3
:= al2; al2
:= vl2
snt corecte;
instruciunea v l 3 : = k este corect numai pentru l < - k < = 3; instruciunea vi2
vl3
este corect dac l < vl3 <= 2; instruciunile
v 5 6 v l 2 ; vl2
:=
v56;
i
:= z
snt incorecte;
instruciunea a l 3 : - loophole ( T 1 3 , a ) este incorect, deoarece rezultatul evalurii este 0
i deci nu este din T13 (detalii privind funcia loophole snt in anexa 4);
instruciunea a 13 : = loophole (T13, b ) este corect i hii a 13 i se atribuie
valoarea 1;
instruciunile
v_logic : = ( a l 2 < = v l 2 ) = ( a l 2 < v l 2 ) or ( a l 2 = v l 2 ) ; v_logic : = a p r e d ( b ) ; v_logic : = b = s u c c ( a ) ;
v_ l o g i c : = a - p r e d ( c ) snt toate corecte; primele trei atribuie variabilei
v_ l o g i c valoarea t r u e iar ultima valoarea fa l s e ;
instruciunea r : = s i n ( r ) + c o s ( k ) este corect;
instruciunea k : = r este incorect, dar instruciunile
r :k : = k round(r ) ;
trunc(r)
snt corecte;
instruciunile
z .re
z. im
z
v tab
0;
i;
i;
c tab
snt corecte.
3.1.2. Instruciunea apel de procedur
61
Instruciunea apel de procedur se insereaz n program n locul n care se dorete

executarea instruciunilor specificate de o declaraie de procedur asupra entitilor
particulare "transmise" ei din locul de apel (vezi capitolul 4).
Sintactic, apelul de procedur (vezi regulile 2.23c-f, anexa 1) poate fi reprezentat prin
metaforma
P(1)
unde p reprezint numele procedurii, iar 1 lista de parametri actuali. Parametrii actuali din 1
trebuie s corespund ca numr, ordine i tip cu parametrii formali specificai n antetul
declaraiei de procedur. Ei pot fi expresii, funcii, proceduri. Numai parametrii actuali care
corespund parametrilor formali variabili (declarai prin var) pot fi modificai. Ei snt variabile a
cror locaie este folosit pentru recuperarea n program a rezultatelor din procedur
Exemplu. O procedur cu antetul
procedura p(x, y. intecter; var z , t: r e a l )
se poate apela prin
p (3 , 2 * ( a + b - c ) , u, v)
sau
sau
p ( a , b , u, v)
p (3 , 5 , u, v)
unde a , b , c desemneaz variabile ntregi, evaluarea expresiei 2 * ( a + b - c ) produce o

valoare ntreag, iar variabilele u i v snt declarate n program ca reale.
3.13. Instruciunea de transfer necondiionat

Instruciunile unui program snt executate secvenial, aa cum apar scrise n textul
programului. Instruciunea de transfer necondiionat ofer posibilitatea de a ntrerupe aceast
secven i a relua execuia dintr-un alt Ioc al textului (vezi anexa 2, definiia 2.23.p).
Aceast instruciune are forma:
goto e
unde e este o etichet declarat prin labei. Declararea prin labei a etichetei e este
obligatorie. Domeniul de valabilitate al unei astfel de declaraii este precizat n 4.4.3.2.
Execuia instruciunii goto e are ca efect transferul controlului la instruciunea
prefixat de e (exist o singur instruciune de acest fel).
Instruciunea goto e i instruciunea marcat cu e trebuie s ndeplineasc una din
condiiile urmtoare:
1) instruciunea prefixat cu e conine instruciunea goto e;
2) instruciunea prefixat cu e face parte dintr-o secven de instruciuni s, iar instruciunea
goto e este una, sau este coninut n una dintre instruciunile lui s (secvene de instruciuni
apar doar n instruciunea compus begin... and sau n instruciunea zepeat. . , until);
3) instruciunea prefixat cu e face parte din secvena de instruciuni din instruciunea
compus begin. . . and a unui bloc B, iar instruciunea goto e apare ntr-o
62
3. Instruciuni
funcie/procedur definit n partea de declaraii a blocului B (prin bloc se nelege un

program / funcie / procedur).
Exemplu. Programul urmtor execut parcurgerea n inordine a unui arbore binar
reprezentat prin tablourile st , dr, info [LiGe86]. Stilul de programare folosit n exemplu trebuie
descurajat, deteriornd claritatea programului. Singura instruciune goto folosit justificat n
programul de mai jos este goto 1001.
labei 1 0 0 1 , 1 0 0 2 , 1 0 0 3 ;
conat nmax-9; type
tip=integer;
index=0. . n m a x ;
fi i =array [ l . . n m a x ] of index; i n fo r m =array
[ l . . n m a x ] of t i p ; var st . d r : fi i ; i n fo :
i n fo r m ; r a d : index; procedura inordine( p :
i n d e x ) ; labei 1 , 2 , 3 ; const s m a x - 5 ;
var st i v a : array [ L . s m a x ] of index;
k: 0..smax;
begin
k:=0;
i f p =0 then goto 3 ; { c o n d i i a 2 } l : i f st [ p ] O 0 then begin

if k=smax then goto 1001; { c o n d i i a 3 }
k : = k + l ; st i v a [ k ] : =p ;
p s = st [ p ] ;
goto 1; {condiia 1 }
end;
2 : w r i te l n ( i n f o [ p ] ) ; if d r [ p ] - 0 then
begin
i f k- 0 then goto 3 ; { c o n d i i a 2 } p : = st i v a [ k ] ; k : = k- l ; goto 2 ;
{condiia 2 }
end;
p : = d r [p] ;
goto 1 ; { c o n d i i a 2 ] 3:end;
begin
goto 1 0 0 2 ; { c o n d i i a 2 } 1 0 0 1 : w r i te l n ( ' D e p a s i r e
i n t r e r u pt * ) ;
goto
1003;
{condiia
2}
1002:
{iniializare arbore}
st: - fi i ( 2 , 3 , 0 , 5 , 0 , 7 , 8 , 0 , 0 ) ;
d r : - fi i ( 6 , 4 , 0 , 0 , 0 , 0 , 9 , 0 , 0 ) ;
i n fo : - i n fo r m ( 7 , 3 , 1 , 6 , 5 , 1 1 , 9 , 8 , 1 0 ) ;
rad:-l;
{vizitare in inordine} inordine(rad) ;
{ te r m i n a r e p r o g r a m } 1 0 0 3 : e n d .
E xe mp l u . Secvenele de program urmtoare snt incorecte:
"
st i v a ;
program
a) goto 1 ; ...begin 1: a : = b ; . . . e n d
b) i f a = b then begin x : = a ; goto 2 end else 2 :
c) procedure p;
63
y:-b
procedure q ; label 1; begin l : a : - b end; begin

goto 1 end
Instruciunea de efect nul

Executarea acestei instruciuni nu are efect asupra variabilelor programului
(starea acestuia rmne neschimbat). Prezena sa n programele Pascal este
stabilit prin parantezele de opiune [ i ] ale definiiei 2.23.a din anexa 2 i de arcul
nemarcat al diagramei 3.23 din anexa 3. n textul programului, instruciunea de
efect nul nu este reprezentat prin nimic dar, deoarece instruciunile snt desprite
ntre ele prin delimitatorul " ; , prezena sa este marcat de apariia acestui
delimitator. Astfel, n textul
10:; i
: = i + 1 ; ; ; goto 10
exist 5 instruciuni, dintre care 3 de efect nul.

Dei efectul su la execuie este nul, inserarea sau eliminarea unei astfel de
instruciuni dintr-un text de program poate s-i altereze semnificaia (vezi 3.2.3,
observaia 1).
3.2. Instruciuni structurate

O instruciune structurat este compus la rndul ei din instruciuni care
se execut fie n secven (instruciunea compus), fie condiional (instruciunile
condiionale), fie repetate de un anumit numr de ori (instruciunile iterative).
3.2.1. Instruciunea
compus
Instruciunea compus are forma (vezi anexa 2, definiiile 2.23.g):

begin I t ; I2. . . ; In end
i specific un grup de instruciuni, l x , l 2 . . . ; in, care snt executate n ordinea n
care snt scrise. Chiar partea de instruciuni a unui program reprezint o
instruciune compus (vezi paragraful 4.)
Exemplu. Programul:
type c o mp l e x = r e c o r d
r e , im : integer
end;
vector = array . . 5 ] of integer; var : c o mp l e x ;
a , b : vector; begin
: = complex( 1 , 2 ) ; { c : = l +2il
64
3. Instruciuni
a : = ve c to r (1, 2, 3 , 4 , 5 ) ;
b : = ( e r e , c . i m , 1, 0 , 2)
end.
'
conine o singur instruciune compus prin care se iniializeaz variabilele a,

b i c.
Aceast instruciune este util pentru a plasa n locurile din program n care nu este
permis dect o singur instruciune aciuni mai complexe (vezi instruciunile while, for n
paragraful 3.2.2, instruciunile condiionale if i caae n paragraful 3.2.3 i instruciunea with
n paragraful 3.2.4).
3.2.2. Instruciuni iterative

Instruciunile iterative snt folosite pentru a exprima execuia de zero sau mai multe
ori a unui grup de instruciuni. n limbajul Pascal o instruciune iterativ este definit de:



< ins t r u c t i u n e a _ fo r >
|
|
Instruciunea for este indicat n situaiile n care numrul de execuii repetate este
cunoscut. n caz contrar se pot folosi instruciunile iterative while sau zepeat.
3.2.2.1. Instruciunea while

Instruciunea while are forma (vezi anexa 2, definiia 2.23.4): while B do I
n mod normal, instruciunea i se execut ct tinip expresia booleana B ce
controleaz repetiia este adevrat. Execuia se poate ns ncheia i printr-un transfer
necondiionat. Dac expresia B are de la nceput valoarea fa l s e , atunci instruciunea I nu
este executat. Astfel, execuia instruciunii
while t r u e do x : = 1
conduce la executarea de un numr infinit de ori a instruciunii x: = 1. Pe de alt parte,
instruciunea
whi.le fa l s e do I
este echivalent cu instruciunea de efect nul, deoarece I nu va fi executat deloc.
Se recomand utilizarea sa n situaiile cnd numrul de execuii repetate ale
instruciunii i este dificil de evaluat
Exemplu. Re seria definit prin sumele pariale
s0 = t 0 , Si = s'ili + t1( pentru i > 0 unde
t4 - - (x2't11)/(kJ ( k i - i )J, i > 0

kj - ki.x + 2,
k0 - 1.
65
i>0
Este cunoscut c l im sn - s i n ( x ) . Urmtorul program calculeaz prima sum parial s cu

proprietatea 11| e p s i l o n - | s |, unde e p s i l o n > o.
var
s , t : r e a l ; k : i n te ge r ;
x , x 2 , e p s i l o n : r e a l ; begin t : = x ;
k : = 1 ; s : = t;
epsilon
0 . 0 0 0 1 ; x2 : = sqr ( x ) ; falle a b s ( t ) > e p s i l o n * abs(s)
do begin
k := k + 2; .
t : = - t * x 2 / ( k * ( k- D ) ; s
s+t
end
end.
Dup execuia programului, valoarea variabilei s este o aproximaie a lui s i n ( x ) . Se

observ c valoarea x2 se calculeaz nainte de instruciunea wfaile, deoarece variabila x nu se
schimb n cursul execuiei acestei instruciuni.
Exemplu. Re irul v1# i o , definit prin relaiile de recuren
v0 = a
Vi
= f t v j . i ) ; 12:1
i p o proprietate satsfcut de cel puin un termen al irului. Urmtoarele instruciuni

determin primul termen vk din ir ce satisface proprietatea P:
v:= a;
^rtiile not P ( v ) do v : = f ( v ) { v a r e
v a l o a r e a l u i v_k}
Exemplu. Programul urmtor calculeaz frecvena literelor ntr-un text var
ch: char;
frecventa: array [ ' A ' . . ' Z ' ] of i n te ge r ; l i te r a _ m a r e : set of ' A ' . . ' Z ' ;
l i te r a _ m i c a : s et of ' a ' . . ' z ' ; begin
l i te r a _ m a r e
:=
['A'..'Z'];
I i te x a _ m i c a : = [ ' a ' . . ' z ' ] ;
fo r ch : = ' A ' to ' Z ' do f r e c ve n t a [ c h ] : - 0 ;
while not eof do
begin
while not e o i n do
begin
r e a d ( ch ) ;
if ch in l i te r a _ m i c a + l i te r a _ m a r e then { l i te r e l e mici s i n t
c o nve r t i te i n l i te r e m a r i } begin
i f ch in l i te r a _ m i c a then ch : = ch r ( o r d ( ch ) - ( o r d ( ' a ' ) - o r d ( ' A ' ) ) ) ; '
frecventa[ ch ] : = f r e c ve n t a [ ch ] + 1 end end; readln end;
fo r ch : = ' A ' to ' Z ' do
66
3. Instruciuni
w r i te l n C Frecventa l u i
ch, ' e ste - ' , f r e c ve n t a [ ch ] )
end.
Exemplu. Programul urmtor calculeaz cu aproximaie valoarea c o s ( x )
[W721:
{ c a l c u l e a z cos( x ) = l - x 2/2! + x 4 / 4 ! - . . . }
program c o s ; const e p s = l e -6; var
x,sx,s,t : real;
i,k
i i n te ge r ;
begin
w r i te l n C F u r n i z a i v a l o a r e a l u i x ' ) ; r e a d ( x ) ; t: - l ; k :=0; s : = l ;
s x : = s q r ( x ) ; while a b s { t ) > eps * a b s ( s ) do begin
k : = k +2; t : - - t * s x / ( k * ( k- 1 ) ) ;
s:=s+t
end;
writeln('cos C , x , ' ) = ' , s )
end.
O alt ilustrare a utilizrii instruciunii while apare n exemplul 1 din paragraful
3.3, la prelucrarea informaiilor dintr-un fiier.
3.2.2.2. Instruciunea repeat

Instruciunea repeat are forma (vezi anexa 2, definiia 2.23.1): zepeat I j . . .
; In
until B
Instruciunile aflate intre repeat i until snt executate pn cnd expresia booleana B
care controleaz repetiia devine adevrat. Execuia se poate ns ncheia i printr-un transfer
necondiionat Aceast instruciune este echivalent cu secvena de instruciuni
Ii. . ; IB
while not B do begin Ij . . .
; In and
Se observ c instruciunile I a ,. .., I se execut cel puin o dat. Se

recomanda utilizarea sa n locul instruciunii while atunci cnd evaluarea expresiei care
controleaz repetiia se face dup executarea instruciunii I .
Exemplu. Prin programul urmtor se citete de la fiierul standard de intrare un ir
de numere ntregi cu proprietatea c toate numerele, cu excepia ultimului, snt nenule. Aceste
numere se transfer ntr-un fiier cu tipul de baza integer i se calculeaz apoi suma tuturor
componentelor fiierului.
var v: file of integer; a: integer;
suma: integer;
begin
rewrite( v ) ;
repeat
read( a ) ;
<.
67
write(v,a) until
a- 0 ; reset( v );
suma:= 0;
while not eof(v) do begin
suma : = suma + y ";
get(v)
end;
writeln('Suma=', suma)
end.
Exemplu. Programul urmtor citete doi vectori cu componente ntregi i
scrie pe ecran TRUE sau FALSE dup cum vectorii snt identici.sau nu:
const n='i;
type vector = airay | L . . n ] of integer; var a , b :
vector;
i: integer; begin
for i : - J to n do read(a[ i ] ) ; for i : = l
to n do read ( b |'i ] ) ;
repeat i : = L * i until ( i = n ) or ( a i i ] o b i i ) ; write(a[i]=bfi l) ;
end.
Exemplu. Programul urmtor calculeaz cel m a i mare divizor comun al

dou numere ntregi pe baza algoritmului l u i Euclid.
var
begin
end.
a , b, c
: char;
integer; t
repeat
write( ' Furnizai numerele a s: b : ' ) ; readlti(a, b) ;

a : = abs(a); b : - a b s ( b ) ; while (a O 0 ) and (b < > o) do
begin
C
b;
b : - a mod b;
a : -- c
end;
wr i te( ' cmmdc f ' , a + b,
Continuai? Rspundei d sau n ' ) ;
readln(t) until
t -- 'n'
Exemplu. Programul urmtor ordoneaz cresctor o list de n>i numere

ntregi, prin metoda inversrii elementelor adiacente.
const nmax-100;
68
3. Instruciuni
var lista :array [L.nmax] of integer;

n,
{lungimea efectiva a listei (
i
: O . . nmax;
loCj nv : 1. .nmax;
l l o c u L ultimei inversiuni I I.
. : integer;
begin
writeCdati lungimea l i s t e i ' ) ;
read In( n ) ;
writeCdati ' , n , ' elemente a l e listei' ) ; fo r i
I to n do read
( l i s t a [ i ] ) ; repeat
1ocinv:-l;
fo r i : ^1 to n-.l do
i f lista M l
> l i s t a li+.l ]
then b e g i n {se face inversiune}
t: --lista 1 i] ;
lista { i ]
lista [ i i 1 } ;
lista l i " l ]
t;
lOCinV : i end;
! l i s t a |locinv . . n } este ordonata cresctor 1 u n t i l locinv-1 ;
wr j te In ( 'lista ordonata cresctor este:').,;
fo r
to n do writeln( l i s t a |i|)
end.
3.2.2.3. Instruciunea for

Instruciunea fo r a r e formele (vezi anexa 2, definiiile 2.23.m , 2.23.n) fo r
v
sau
:-
to [ do I
fo r v : - i downto f do l.
Va r i a b i l a v este de t i p scalar ordinal (deci nu real) iar i i f snt expresii

de tipuri compatibile cu tipul l u i v. n mod normal, instniciunea specific executarea repetat a grupului de instruciuni
V
: X; T
_
pentru toate valorile x d i n intervalul cuprins ntre i i t , luate n ordine cresctoare

pentni prima form i n ordine descresctoare pentm a doua. Execuia poare fi ns
ncheiat i printr-un transfer necondiionat. Valoarea final a variabilei v se
consider a fi nedefinit dup terminarea normal a instruciuni' fo r. Prin urmare,
cu excepia faptului c variabila Y este nedefinit dup terminarea normal,
instmciunea
fo r v := i to f do l este
echivalent cu
69
v : - i ;
while v <' f do b e g i n I ; v : = s.ucc(v) end i a r i n st r u c i u n e a
fo r v : - i downto f do T
cu
. .
v := i;
while v > = f do begin I ;
v : = pied(v)
end
Aceast instruciune este util pentru programarea formulelor de recuren

de forma
ac. = a ,
a n .,
- f(an), n> -0 .
Astfel, n urma execuiei unei secvene de instruciuni de forma urmtoare

v : - a ;
fo r i : ^
1 to n do v
'
: = f (v)
valoarea lui v este a r .

P r i n urmare, n cazul
a 0 - 1,
,a* (nKI.)
programul urmtor
v a r i, v : integer; begin
v
1 ;
fo r i :
1 to V do -v : = v *. i..
end.
calculeaz valoarea v = /!.
v:
Pentru a prelucra pe rnd toate valorile tipului dat de definiia

-
t y p e EH -
(A_l,
A_7.,
A_~\, A_4) ;
n ordine descresctoare, utiliznd o procedur P i o variabil v de tipul EH,

putem folosi instruciunea iterativ fo r astfel:
for v :- A 4 downto A i do P ( v )
n acest c a z , .secvena de instniciuni executat va fi :
P(A_4) ;
P( A_ i ) ;
P( h_ Z ) ;
P(A_l) .
E xe mp l u . Programul urmtor calculeaz produsul a dou matrici.

{ i tunul t i . re m a t r i c i !
const m
var
= 1; p = 3; n - 2 ;
70
3. Instruciuni
1. .m;
: Integer;
A
B
:
:
: n;
1 . :
array [.):. .m.

array [ .1 . .
p,
C : array [1 . . m ,
begin (ini t i a i i /.are A
writeIn < ' scrieti
for
J . .p!
J . .n]
l.-.n]
si B}
mat
rit
i: l to m do
begin for k : - 1 to p do
begin r e a d ( s ) ; w r i t o ( s ) ; A | i , k } : - S end;
wr i. teln
end;
{ a f o s t c i t i t A } writeln;
for k : -1 to p do
begin for j : --1 to n do
begin
read(s);
write(s);
B[k,;j|
end;
v.
writeln
end;
{ a tost, citit Bl w r i t e l n ;
ise calculeaza C = A * B) wri teln('A *
B - ' ) ; for i : - 1 to m do begin
for j : = . l to n do begin s := o;
for k : - 1 to p do
s
s * A]i,k] * B[k,j1;
C fi . j J
s; write(s)
end;
writeln
end;
w r i teln
:=
3.2.3. Instruciuni condiionale

O instruciune condiional selecteaz o singur instruciune d i n t r e
a l te r n a t i ve l e sale, pe care apoi o execut. Instruciunile c o n d i i o n a l e snt i f i
case.
3.2.3.1. Instruciunea if
Instruciunea i f are forma (vezi anexa 2, definiia 2.23.h): i f B then I
sau
if 15 then I else J
E xe c u i a instruciunii i f ncepe p r i n evaluarea condi;iei B. Dac
r e z u l t a t u l e v a l u r i i este t r u c , atunci se execut instruciunea 1 . Dac
71
r e z u l t a t u l e v a l u r i i este fa l s e , atunci n primul caz se execut instniciunea

de efect n u l , i a r n a l doilea caz se execut instruciunea J.
Observaii
n instruciunea i f 6 then s , introducem nainte de s instruciunea de
efect nul (if B then; S) atunci a n u m a i intr n componena i n st r u c i u n i i
c o n d i i o n a l e , d e c i este e xe c u t a t i n d i fe r e n t de v a l o a r e a l u i n.
2.Amintim c limbajul Pascal nu consider simbolul ; ca facnd parte d i n
instruciune ci l folosete ca delimitator. Prin urmare, dac ntr-o instniciune i f
B then I else J introducem dup I simbolul ; obinem un program incorect
sintactic (n acest c a z secvena else. . . este interpretat ca fi i n d i n st n i c i u nea
ce urmeaz celei condiionale).
3.Ambiguitatea sintactic a construciei
1.Dac
i f B_l
then i f B_2 then
else ] _ 2
I_l
(else face parte din primul i f sau din cel de-al doilea?) este rezolvat p r i n
interpretarea construciei c a fiind echivalent cu
i f 13__3
then begin
i f B_2 then I _ l
else I._2 end
> kM
Ilustrm utilizarea instruciunii condiionale if i a instruciunii iterative while prin

exemplul urmtor care convertete un numr in baza 10 n scrierea cu cifre romane. Daca x
este o variabil ntreag ce conine numrul ce trebuie convertit, atunci urmtoarea
instruciune compus realizeaz conversia dorit:
var x : 0 . . m a x i n t;
begin
r e a d l n ( x ) ; w r i te ( x , ' = ' ) ;
while x > = 1 0 0 0 do begin w r i te C M ' ); x : x - 1 0 0 0 end; if x > = 9 0 0
then begin w r i te ( ' C M ' ) ; x : = x - 9 0 0 end else if x > = 5 0 0 then begin
w r i te ( ' D ' ) ; x : = x - 5 0 0 end else if x > = 4 0 0 then begin w r i te ( ' C D ' ) ;
x : = x - 4 0 0 end; while x>=100 do begin w r i te ( ' C ' ); x : = x - 1 0 0 end; if
x > = 9 0 then begin w r i te C XC ) ; x : = x - 9 0 end else if x > = 5 0 then
begin w r i te ( ' L ' ) ; x : - x - 5 0 end else if x > = 4 0 then begin
w r i te { ' X L ' ) ; x : = x - 4 0 end; while x > - l 0 do begin w r i te ( ' X ' ) ; x : = x10 end; if x = 9 then begin w r i te ( ' I X ' ' ) ; x : = x - 9 end else if x > = 5
then begin w r i te ( ' V ' ) ; x : = x - 5 end else if x - 4 then begin w r i te
C i v ) ; x : = x - 4 end; while x > - l do begin w r i te C I ' ) ; x : = x - l end;
w r i te l n
end.
O utilizare abuziv a instruciunii if este urmtoarea
if a - b then found : = t r u e else found : = fa l s e
72
3. Instruciuni
unde found este o variabil booleana Evident, acelai efect se obine prin execuia
instruciunii
found
nenul.
law
a=b
Exemplu. Prin programul urmtor se calculeaz xy, unde y este numr natural
var e , y : 0 . . 1 0 0 ;
u , x , z : r e a l ; begin
readln(x); readln(y);
z := 1 ; u
x; e != y;
while e > 0 do begin
while not o d d ( e ) do begin e : - e
div 2 ; u :- sqr ( u ) ;
end;
e :- e, - 1; z := z * u
and;
w r i te l n { x , ' l a puterea ' , y, i z - x * *
y}
z)
end.
Observm c o variant mai simpl dar mai puin eficient se poate obine omind
instruciunea while interioar, rezultatul z este astfel obinut prin y multiplicri ale lui x.
Alte ilustrri ale utilizrii instruciunii if pot fi gsite n exemplul 2 din paragraful 3.3.
3.23.2. Instruciunea case

Instruciunea case (vezi anexa 2, definiiile 2.23.i, 2.23.J) const dintr-o expresie
numit selector i o list de instruciuni, fiecare precedat de o constant de acelai tip cu
selectorul sau de cuvtntul cheie othexwise. Instruciunea casa se execut astfel: se
evalueaz expresia ce definete selectorul i apoi se execut fie instruciunea precedat de
constanta egal cu valoarea selectorului, fie instruciunea precedat de othexwise dac
valoarea selectorului nu coincide cu nici una din constantele ce eticheteaz

instruciunile componente. n acest ultim caz, absena specificaiei othexwise conduce la
erori.
Exemplu. Programul urmtor simuleaz un calculator cu operaiile elementare +,

-, *, div i mod pentru numere ntregi.
program c a l c u l a to r ;
var a , b : i n te ge r ; codoper: ch a r ;
begin
w r i te ( ' c o d o p e r a i e : ' ) ; r e a d l n (codoper) while
codoper <> '.' do begin
w r i te ( ' o p e r a n z i : ' ) ; r e a d l n ( a , b ) ;
w r i te ( ' r e z u l t a t : ' ) ;
case codoper of
div
and
end.
3.3.
wr iteln(
a,
wr iteln(
a,
wr iteln(
73
b, a+b) a-b) a*b)

b,
b,
' , b , ' = ' , a div b , mod ', b , ' - ' , a mod b ) ;

otherwise w r i te l n ( ' c o d o p e r a i e n e c u n o s c u t ' ) and;
w r i te ( ' c o d o p e r a i e : ' ) ; r e a d l n ( c o d o p e r )
O alt ilustrate a utilizrii instruciunii case poate fi gsit n exemplul 3, paragraful
Observaii
1.Constantele ce prefixeaz componentele unei instruciuni casa nu snt etichete n
sensul din paragraful 1.2 i nu pot prin urmare s fie referite printr-o instruciune goto i nici
nu pot s apar ntr-o declaraie labei.
2.Ordinea acestor constante este arbitrar, dar fiecare nu poate apare dect o
singur dat ca prefix de componente.
3.Dintr-o instruciune component nu se poate face transfer la o alt component.
3.2.4. Instruciunea with

n paragraful 2.2.2-, unde a fost introdus tipul de date record, s-a menionat c
dac x este o variabil de tip record, avnd pe s_i drept component, atunci referirea la s_i
se face prin x. s_i. Dac s_i este la rndul ei de tipul record, atunci referirea la componenta
sa s_ i _ j se face prin x. s_i. s_i_ j . Acest mod de referire a componentelor unei date
structurate este n anumite situaii greoi. Pentru a nltura acest neajuns a fost ncorporat n
limbaj instruciunea witb care definete domeniul de valabilitate pentru identificatorii
proieciilor canonice ale unor variabile de tip record. n acest fel, o proiecie canonic poate fi
referit i prin numele ei s_i, fr a fi necesar calificarea prin numele articolului care o
conine.
Forma general a instruciunii with este:
witb. <variabila_record> { , < v a r i a b i l a _ r e c o r d > }
do 
Spre exemplu, n prezena declaraiilor:
type complex = record x , y : r e a l and;
numr
- record
case t i p
: ( i n t , r e , corn) of
i n t : (x_int : i n te ge r ) ;
re : (x_re : real);
corn
: (x_com : complex)
and;
74
3. Instruciuni
var n : n u m r ;
putem face iniializrile:

n . t i p .:- int;
n.x_int : - 1;
n.tip
re;
n.x_re : = 1 . 1 ;
n.tip
corn;
n.x_com.x
:
0.0;
n.x_com.y
1.0;
sau putem folosi instruciunea with echivalent:

with n , x_com do begin
tip
int; x_int
1;
t i p : = r e ; x_re
1.1;
tip
corn; X :0 . 0 ; y : - 1 . 0 rad
{with}
Exemplele 1 i 3 din paragraful 3.3 snt alte ilustrri ale mstruciunii with.
Observata
1. Este interzis afectarea elementelor din lista de variabile prin instruciunile asociate lui with. Dac de exemplu a este o variabil de tipul array avnd
tipul de baz un tip record, atunci
with a [ i ] do i : - i + 1
nu este permis.
2. Dac declaraia
var a : axray [ 1 . . 2 ] of integez; a : 1 . . 2 ; nu este permis, datorit unei definiii
ambigue pentru a, declaraia
var a : integer;
b : racord a : r e a l ; b : boolean and;
este permis, variabila a este de tip inegez i b. a este de tip r e a l . n plus, ntr-o
instruciune
with b do S
identificatorii a i b, dac snt referii n S, au semnificaia b . a i respectiv b.b.
33. Exemple
75
Exemplul 1. Programul urmtor creeaz un fiier cu componente de tipul record

per soana; cmpurile acestor componente se obin prin citire din fiierul input (de la
terminal). Fiierul este apoi citit i snt numrate nregistrrile cu cmpul anul-194 9.
type persoana - record nume,
prenume : packed azzay [ 1 . . 2 0 ] of ch a r ; z i u a :
l . . 3 1 ; luna : 1. .12; anul : integer and;
var individ : p e r s o a n a ; f : fila
of p e r s o a n a ; n integer; begin
\
r e w r i te ( f ) ;
vith individ do begin
while not eof { e x i st a inca d a te } do begin
w r i te ( ' nume: ' ) ; readln( n u m e ) ;
w r i te ( ' prenume: ' ) ; r e a d l n ( p r e n u m e ) ;
w r i te l n C d a t a n a te r i i ' )
w r i te C z i u a : ' ) ; readln ( z i u a ) ;
w r i te ( ' l u n a : ' ) ; readln( l u n a ) ;
w r i te ( ' a n u l : ' ) ; readln( a n u l ) ;
f * : - individ; p u t ( f ) { s a u w r i te ( f , i n d i v i d ) }
and;
m
r e s et ( f ) ; n : = 0 ; while not e o f ( f )
do begin
i n d i v i d : - f " ; get ( f ) ; { s a u r e a d ( f , i n d i v i d ) ; }
anul=1949 then n : = n + 1
end;
w r i te l n ( ' s i n t ' , n , ' persoane cu anul 1 9 4 9 ' )
and
end.
.; .
if
Exemplul 2. Considerm un fiier text de intrare, fa ; coninutul acestuia este copiat

n fiierul text f b , pstrndu-se structura de linii a lui fa , dar nlocuind orice grup de dou
caractere ' a ' consecutive printr-un caracter ' b ' :
var fa , f b : te x t; c : ch a r ; begin
r e s et ( fa ) ; r e w r i te ( f b ) ;
33.
77
Exemple
while not eof(fa) do
begin
if e o l n ( fa ) then
begin
r e a d l n ( fa ) ; w r i te l n ( f b )
end Is*
begin
read( fa , c ) ;
if c < > ' a ' then w r i te ( f b , c ) else if eof( fa ) then w r i te ( f b , c )
else if e o l n ( fa ) then begin
76
3. Instruciuni
w r i te ( f b , c ) ;
r e a d l n ( fa ) ;
w r i te l n ( f b )
end.
end
end
end
IB*
begin
read( fa , c ) ;
if c - ' a ' then w r i te ( f b ,
else
begin
w r i te ( f b , ' a ' ) ;
w r i te ( f b , c )
end
end
'b')
*-
E xe mp l u l 3. Considerm tipul de date persoana din exemplul 1 completat cu

cmpurile cod i c o p i i . Se creeaz un fiier n acces direct cu componente de tip persoana; cod
va fi chiar numrul de ordine al componentei. Programul permite urmtoarele tipuri de operaii
asupra fiierului: * a': adugarea unei componente la fiier (cmpurile componentei se citesc de
la terminal);
'u': actualizarea cmpului copii al unei componente din fiier, identificat prin
cod;
' 1': listarea componentelor fiierului cu numere de ordine ntr-un interval; ' a': terminarea
programului.
type persoana = zacozd cod :
integer;
nume,
prenume : packed array [1..10] o char;
ziua : 1 . . 3 1 ;
luna : 1..12;
anul : integer;
copii : integer
end;
vax individ : p e r s o a n a ;
f
: fila of persoana;
n , ncod,pcod,ucod,i : integer; codoper : char; begin
r e w r i te ( f , , ' / s e e k ' ) ; with
i n d i v i d do begin
w r i te ( ' c o d operaie ( e , a ) : ' ) ; readln( c o d o p e r ); while codoper< > ' e ' do
begin caaa codoper of
' a ' : { a d a u ga } begin
w r i te ( ' c o d : ' ) ; r e a d l n ( c o d ) ; w r i te ( ' nume: ' ) ;
readln(nume); w r i te ( * prenume: ' ) ; readln( p r e n u m e ) ;
w r i te l n C d a t a n a te r i i ' ) ; w r i te ( ' z i u a : ' ); readln( z i u a ) ;
77
w r i te C l u n a : ' ) ; r e a d l n ( l u n a ) ; w r i te ( ' a n u l : ' ) ;

r e a d l n ( a n u l ) ; w r i te ( ' copii: ' ) ; readln( c o p i i ) ;
s e e k ( f . c o d ) ; w r i te ( f , individ) end;
' u ' : ( a c t u a l i z e a z ) begin
w r i te ( ' c o d : ' ); readln(ncod); w r i te C n u m a r copii de
a d u ga t: ' ) ; readln(n) ; seek(f,n c o d ) ; read(f, i n d i v i d ) ;
copii: = c o p i i + n ;
seek( f , n c o d ) ; w r i te ( f , individ) end;
' 1 ' : { l i ste a z } begin
w r i te ( ' de la: ' ) ; readln(pcod); w r i te C p i n a l a : ' ) ;
readln(ucod) ; seek( f , p c o d ) ;
fox i:=pcod to ucod do begin r e a d ( f , i n d i v i d ) ;
w r i te l n ( c o d , nume, prenume,
z i u a , luna, anul, copii)
end
3.3.
79
Exemple
end.
end
ud;
otherwise
end;
w r i te ( ' c o d o p e r a i e ( e , l , a , u ) : ' ) ; l e a d l n ( c o d o p e r ) end
Exemplul 4. (Problema lui Josephus [Kn74], p.178). Se consider n obiecte, aezate

pe un cerc i numerotate n ordinea aezrii 1, 2 , . . . , " n . Parcurgnd cercul n sensul dat de
numerotarea obiectelor, ncepnd cu obiectul m, se elimin pe rnd toate obiectele din k n k.
Programul urmtor determin numerele de ordine ale obiectelor eliminate pentru n , m , k
dai, folosind o list circular creat dinamic.
type l e g t u r a - "nod; nod =
record
numr: integer;
u r m to r u l : l e g t u r a
end;
var p , q , r : l e g t u r a ; n , m,
k : integer; i, j: integer;
begin
w r i te C n u m a r de o b i e c te : ' ) ; r e a d l n ( n ) ; w r i te C c u c e obiect s e
incepe e l im i n a r e a : ' ) ; readln ( m ) ;
w r i te ( ' d i n c i te i n c i te : ' ) ; r e a d l n ( k ) ; { c o n st r u i e te l i st a
c i r c u l ar a } n e w ( p ) ; q : = p ; q * . numr: = 1 ; for i : - 2 to n do begin
r:= q; new(q);
r * . u r m to r u l : - q ;
q*.numr:= i
end;
78
3. Instruciuni
q * . u r m to r u l : - p ;
{ i n a c e st moment p i n d i c a p r i m u l nod din l i st a s i q u l t i m u l ;
s e determina p r i m u l nod de e l i m i n a t; p va indica nodul de
e l i m i n a t s i q nodul precedent d i n l i st a }
for i : = 1 to m - 1 do
begin
q : = p ; p': = p * . urma to r u l
and;
{incepe eliminarea}
w r i te l n ( ' ordinea de e l i m i n a r e e ste : ' )
for i : = 1 to n -1 do
begin
w r i te l n ( p * . n u m r ) ; { e l im i n a nodul
din l i st a } q * . u r m to r u l : =
p * . u r m to r u l ; ; d is p o s e ( p ) ;
{determina u r m to r u l nod de e l i m i n a t }
p:- q;
fox j : = 1 to k do begin
q : = p ; p : = p * . u r m to r u l
and
and;
w r i te l n ( p * . n u m r ) ; d i s p o s e ( p )
and.
3.4. Exerciii
1.
Fie programul Pascal:

var
txue : boolean; i
:
integer; begin
true : = fa l s e ;
i
: = 0;
while not t r u e do begin t r u e : =
not t r u e ; i : = i + 1
end
and.
Care este valoarea lui i dup execuia sa?

2.
S se scrie un program Pascal n care s fie utilizat instruciunea
iterativ for (cazul to), pentru a calcula numrul armonic de ordin 100, h_lO0.
Reamintim c h_n = 1 + 1/2 + . . .
i /n [Kn74].
3
Aceeai problem ca mai sus n care se substituie to cu downto.
4.
Fie suma s _ i o o = l/l - 1/2 + 1/3 - . . . -1/100. Scriei cte un program Pascal
care s calculeze s _ i o o a) evalund de la sting la dreapta
81
3.4.
Exerciii
5.
79
b) evalund de ia dreapta la sting.

Este corect urmtorul program Pascal? label 1;
var ( a l b , n e g r u ) ;
A *,'
i
ti'-'' l
end.
i _ s i r : packed array [ 1 . . 5 ] of ch a r ; begin

r e a d l n ( i _ s i r ) ; if i _ s ir - ' a l b ' then i : = a l b else
if i _ s i r = ' n e g r u ' than i : = negru else
w r i te l n ( ' r e z u l t a t u l i mp r e v i z i b i l ' ) ; casa i of
a l b : begin
if t r u e than goto 1 ;
1 : i := succ(i)
and;
n e g r u : i : = p r e d ( i ) ; end;
casa i of
a l b : w r i te l n C a l b ' ) ; n e g r u :
w r i te l n ( ' n e g r u ' )
end
6.
Fie programul Pascal:

labei l , 2 , 101, 102; var i :
integet; begin i : - 1 ; casa i of
1 : 101 : goto 1 0 2 ;
2 : 102 : goto 101;
and
and.
Este corect? De ce?
7. -
Fie declaraiile
var a : i n te ge r ; b :
record
a , b : integer end;
a) Suit corecte instruciunile
b.a := a ;
b.b : = b.a
b) Dac se execut instruciunile
a : = 0 ; with
b do
valoare are a ?
a := 1; ce
8.
Fi T un tip de date pe care s-a definit o relaie de ordine total <,. Se
numete sortare (n ordine cresctoare) a fiierelor din T* o aplicaie S : T*---------------->T*,
definit astfel: oricare ar fi u = f l i 4 . f n e T, s ( u ) - f p l . . . f p n , unde (p_l, . . . ,p_n) este o
permutare a lui ( i , . . . , n ) , astfel nct f p t f p j pentru 1 i <, j <, n. Practic, se poate
construi fiierul sortat s ( u ) , eventual n aceeai arie de memorie ca u, sau numai
permutarea (p_i, . . . , p_n).
80
3. Instruciuni
Fie mei un natural fixat, i un tip de date cu ordinea total i T - i". Pe T definim
ordinea lexicografic astfel: kt. . . k lt.. .1 * k j - 1 pentru 1 i m sau exist p ,
l i p i m , astfel nct lq = l t pentru l 5 i S p - l i kp < lp. S se scrie un program de
sortare n ordine lexicografic a unui fiier cu componente de tipul T, pentru I - integer.
9.
Re definiiile Pascal:
type candidat = zecozd
nume: packad axray [ 1 . . 3 0 ] of ch a r ;

media : real
'
and;
var f: file of candidat; S se scrie un program de sortare
a fiierului f :
a) dup cmpul nume, n ordine lexicografic;
b) dup cmpul media, n ordine descresctoare;
c) dup cmpul media n ordine descresctoare, iar n cadrul aceleiai
valori a cmpului m e d i a , dup cmpul nume n ordine lexicografic.
10.
Fie T un tip de date pe care s-a definit o relaie de ordine total <, i F = im s, unde
s este aplicaia de sortare din exerciiul 8 (F este mulimea fiierelor sortate din T*). Se
numete interclasare o aplicaie I : F x F r^-> F definit prin i ( u , v ) - s ( u v ). Scriei un
program de interclasare a dou fiiere cu componente de tip integer.
11.
Fie un fiier text fi

urmtoare:
<continut>
al crui coninut este descris prin diagramele sintactice
, - > EOF -------->

| ---- < c o n st a n t a _ i n t r e a ga > <--------1
|------------------- gp < ---------------------------_ j
l------------------ eol <--------------------J
< c o n st a n t a _ i n t r e a ga >
----------1------------------1-----------------1----> < c if r a > ----------1-------->
--------------,----------------------------------------------------. -'i
unde sp este caracterul spaiu, eol este caracterul sfrit de linie, EOF este sfrirul de fiier,
iar < c if x a > este o cifr zecimal S se scrie un program care s transfere constantele ntregi
mai mari ca -100 din fiierul fi ntr-un fiier text f o. Compararea va fi fcut n binar, iar
conversiile vor ii efectuate prin program. Fiierul fo va pstra structura de linii a fiierului fi .
12.
Scriei un program care s adauge componente la sfrirul unui fiier
extern deja existent, utilizind
a) un fiier Pascal secvenial;

b) un fiier cu acces direct
13.
Fie programul:
var
l i n i e : packed axxay [ 1 . . 7 2 ] of ch a r ; contor: integer;
begin
c o n to r : - 0 ; bila not
eoln do begin
81
c o n to r : - contor + 1 ;
read( l i n i e [ c o n to r ] )
and;
readln;
w r i te l n ( c o n to r )
and.
Care este valoarea variabilei contor afiat pe terminal ca urmare a execuiei acestui
program cu datele de intrare urmtoare:
a) o linie vid, constnd din RETURN;
b) spaiu urmat de RETURN;
c) sfrit de fiier (CTRL/Z)?
(n legtur cu observaia 1 de la paragraful 2.2.4.1.3).
14.
S se scrie un program pentru rezolvarea problema lui Josephus (vezi
exemplul 4 din paragraful 3.3), folosind o list circular cu legturi duble, definit
prin:
type l e g t u r a - * n o d ;
nod- record
inapoi: l e g t u r a ; { s p r e nodul precedent] numr:
integer;
n a i n te : l e g t u r a { s p r e nodul u r m to r ]
and;
4.1. Mecanisme de abstractizare n Pascal

...........
Capitolele precedente au introdus conceptele de baz ale programrii (tip de date,
expresie, instruciune) i realizarea lor n Pascal. Ele permit exprimarea riguroas a
descrierilor i prelucrrilor de date sub form de programe.
Introducem acum conceptele de funcie i procedur, care generalizeaz pe cele de
expresie i instruciune. O funcie / procedur se definete printr-o declaraie care asociaz un
nume cu o instruciune compus precedat, eventual, de o secven declarativ. Numele
funciei / procedurii poate fi urmat de o list de parametri formali. Funcia / procedura este
referit prin simpla inserare a numelui ei n locurile dorite din program avnd ca efect
producerea n acele locuri a valorii / rezultatelor determinate de execuia instruciunii
compuse. O astfel de referire se numete apel de funcie / procedur.
Un numr de funcii uzuale (sin. I n , s q r t , axctan,...) i de prelucrri standard
( w r i te l n , read,.. .)snt disponibile utilizatorului ca funcii, respectiv proceduri predefinite
(vezi anexa 4). .
Conceperea programelor n termeni de funcii / proceduri permite un nivel superior
de abstractizare fa de expresii / instruciuni, furniznd astfel un mijloc de control al
complexitii programelor. Acestea pot fi descompuse convenabil n subprograme mai simple,
rafinate succesiv ca funcii / proceduri programate independent [Wi72].
Exprimarea unui algoritm ca program Pascal nu este unic. Conceperea structurii
programelor, fol osirea de funcii sau proceduri, stabilirea parametrilor snt, n bun msur,
la alegerea programatorului, cum se va vedea n exemplele din paragrafele urmtoare.
4.2. Funcii
Pascal.
Conceptul de funcie corespunde celui uzual matematic i extinde pe cel de expresie
4.2.1. Declararea funciilor

sintax:
Definirea unei funcii n Pascal se face n conformitate cu urmtoarele diagrame de
<functie>
i> <antet_functie> > ; ,--------> <corp> - - - - -,- -,> ; - - ->
!
I> <diiectiv> '
|
> function -> <identificator> -> , -> <corp> 1
4.2. Funcii
<ancet_functie>
83
i--------- ; <-----------1
L
> function <identifi cator> T ( <param foimal>
) -,
I_____
1
--->
. .-: .
<corp>
________________:---------------:____________________l
: > <identifi cator tip> >

<U4 sXv S?JJ
JS-'JS Sj?. ; JSAS
:.
-----------------> <declaratii> > <instructiune_compusa> ----->

n general textul Pascal al unei declaraii de funcie are forma: function f ( x , ; . .
. ; x_) : t; begin
f : = e;
end ;
{f}
Primul rnd ilustreaz antetul funciei cu:

f: identificator reprezentnd numele funciei;
( x i ( - . . . ; x n ) : list (opional) de parametri formali reprezentnd argumentele
funciei;
- t: identificator reprezentnd tipul rezultatului; acesta trebuie s fie un tip simplu
(scalar) sau pointer.
Antetul este urmat de corpul funciei, format din:
- dx: declaraii locale ale funciei (opionale) grupate n seciuni (eventual vide) scrise
n ordinea
labei
const
type var
function / piocedure
Aceste cerine snt mai puin stricte n Pascal Oregon vezi 4.6.1. -begin . . .
f : = e ; . . . e n d ; : instruciune compus specificnd prelucrrile de date ce se produc
prin execuia funciei; numele f al funciei (fr parametri) apare cel puin o dat n
partea sting a unei instruciuni de atribuire care se execut: f: '- e. Rezultatul
ntors de funcie, de tipul t, este ultima valoare atribuit lui f.
4.2.2. Apelul funciilor
. - fi
Utilizarea unei funcii se specific printr-un apel de forma:
f(a1( . .. ,a)
f: numele funciei;
( a t , . . . , a n ) : lista (opional) de parametri actuali reprezentnd expresii ale cror valori sau
adrese snt furnizate funciei.
Apelul de funcie este un operand ntr-o expresie; el se insereaz n locul n care este
dorit valoarea produs de funcie. Cnd expresia este evaluat, funcia este activat, iar
valoarea operandului devine valoarea ntoars de funcie.
4.2.3. Exemple
84
4. Proceduri, funcii, programe, module
Vom scrie pentru nceput un program extrem de simplu, pentru calculul ariei unui
triunghi ABC cunoscnd lungimile laturilor:
program P I ;
var a , b , c , p , s : r e a l ; bag in
- 3
; =
5;
6;
= ( a + b + c ) / 2;
= sqrt (p * (p - a) * (p - b) * (p - c) ) ;
{Pl}
ab
cPs
w r i te l n ( s ) and;
Acest calcul poate fi realizat i prin urmtoarea funcie:

function a r i a : r e a l ; var
p : r e a l ; begin
p
(a + b + c) / 2;
aria
s q r t ( p * ( p - a ) * ( p - b ) * ( p - c ) ) end;
{arial
Declaraia acestei funcii conine antetul

function a r i a ! r e a l ;
n care specificaia real stabilete tipul valorii calculate. Restul textului reprezint corpul
fimeiei, format dintr-o declaraie i o instruciune compus. Numele funciei apare n
instruciunea compus n partea sting a unei instruciuni de atribuire. Asupra utilizrii
variabilei p facem urmtoarea observaie. Dac s-ar rescrie cele dou instruciuni, nlocuind
variabila p prin a r i a , cele dou instruciuni ar deveni:
aria:= (a+b+c)/2;
aria:=sqrt(aria*(aria-a)*(aria-b)*(aria-c)).
Apariia variabilei a r i a n membrul drept este incorect, aceasta implicnd
apelul (recursiv) la funcia a r i a .
Programul PI poate fi rescris acum n forma P 2.
program P 2;
var a , b , c , s : r e a l ; function
ar ia : real;
var p : r e a l ;
begin
p : = ( a + b + c ) / 2;
aria := sqrt(p * (p-a) * (p-b)
{aria}
begin
a := 3 ; b ! 5 ; c :- 6 ; s : =
a r i a ; w r i te l n ( s ) end. { P 21
* ( p - c ) ) end;
Printre declaraiile programului P 2 apare i cea care definete funcia a r i a .

Variabilele reale a, b , c , s ale programului snt cunoscute i n corpul funciei; ele
snt variabile globale relativ la funcia a r i a . Variabila p este ajuttoare pentru
funcie, ea servind doar la calculul unei valori intermediare fr interes pentru
restul programului. Declaraia ei
. . .
var p : r e a l ;
4.2. Funcii
85
a fost deplasat n corpul funciei; p devine astfel o variabil local funciei i nu

este accesibil n afara corpului funciei. Ea va fi creat (prin alocare de spaiu
pentru valorile sale) la fiecare activare a funciei i desfiinat (prin dealocarea
spaiului ei) la completarea execuiei funciei i revenirea n program.
Se previne astfel i un efect secundar (vezi 4.5.3) nedorit c e s-ar fi produs
dac p ar fi rmas global: valoarea atribuf ei prin instruciunea
p : = ( a + b * c )/2
ar fi devenit, inutil, cunoscut n tot programul.
Apariia numelui funciei n expresia din partea dreapt a instruciunii
s := aria
determin activarea funciei cu efecte echivalente instruciunii compuse: begin
p := ( 3 + 5 + 6 ) / 2 ;
aria := sqrt(p * (p - 3 ) * (p - 5 ) * (p - 6 ) )
end;
Valoarea astfel obinut va fi inserat n locul numelui funciei i atribuit
lui s.
Comunicarea ntre program i funcie nu este specificat explicit; ea se face
prin variabilele globale a, b, c, care snt cunoscute i n corpul funciei.
Limbajul permite o form sintactic n care elementele de comunicare snt
desemnate explicit prin declararea lor n antet ca parametri formali ai funciei, de
exemplu:
function aria { a , b, c : real)
: real;
Prin specificarea ca parametri formali, a, b, c desemneaz i ei variabile

locale funciei.
Apelurile de funcie vor conine acum parametrii actuali care corespund
celor formali n numr i tip, de exemplu:
aria( 3 , 5 , 6 )
aria( 6 , 4 , 9 ) .
Programul P 3 include aceste modificri.
program P 3;
var a , b , c , s : real;
function aria(a, b, c : real) : real;
var p : real;
begin
p :- (a * b + c) / 2 ;
aria : = sqrt(p * (p - a ) * (p - b) * (p - c ) ) end;{aria begin
a : = 3 ; b : = 5 ; c : = 6 ; s : = aria (a, b, c) end.{ P 3}
Identificatorii a, b, c apar acum n dou declaraii: n program i n antetul
funciei. n antetul funciei ei snt declarai drept parametri formali. Aceste
declaraii snt valabile doar n corpul funciei; variabilele numite de ei nu exist n
afara acesteia. Aceste variabile snt deci diferite de cele desemnate cu acelai nume
n program prin declaraia
var a , b, c , s : real;
86
Variabilele a , b , c astfel declarate nu snt cunoscute n corpul funciei.

Doar s este cunoscut n tot textul programului P 3, deci i n corpul funciei aria.
Spre deosebire de a, b i c, s nu a fost redefinit n corpul acesteia. El rmne o
variabil global pentru funcie.
Aceste observaii sugereaz c alegerea numelor parametrilor formali este
la latitudinea programatorului, fr grij pentru coliziune de notaii, fapt care
uureaz mult programarea. Devine astfel posibil realizarea de subprograme scrise
ca funcii Pascai de ctre persoane diferite. Pentru a asigura comunicarea ntre
aceste subprograme este suficient s se convin asupra aritii lor, adic asupra
numrului de parametri formali i asupra tipului lor, nu i asupra numelor lor, care
pot s coincid sau nu n declaraii diferite de funcii.
Funcia a r i a putea fi declarat folosind de exemplu parametrii formali x, y,
z astfel:
f u n c t i o n a r i a ( x , y, z : r e a l ) : r e a l ; var p :
r e a l ; begin
p := (x + y + z) / 2 ;
aria := sqrt(p * (p - x) * (p - y)
* (p - z)) end;{aria}
i invocat prin a r i a ( a , b , c ) sau prin a r i a ( 3 , 5 , 6 ), et c .

Prin aceast ultim chemare, valorile specificate de parametrii actuali 3, 5,
6 snt transmise drept valori ale parametrilor formali a, b, c cu efectele specificate
mai sus.
Exemplu. Funcia compl din programul urmtor calculeaz complementara
unei mulimi x relativ la o alt mulime e. Tipul rezultatului este pointer, deoarece
utilizarea unui tip structurat este interzis n aceast situaie.
type m u l t i m e =s et of 0 . . 2 5 5 ;
p m = "m u l i m e ; function
compl( e , x : m u l i m e ) : pm; var p: pm;
begin
new(p); pA:=
e - x ; c o mp l : p;
end;
var a , b , e : m u l i m e ;
begin
a:-[0,5,7,3,9]; '
b:=[2,7,8,12,34,3] ; e:[0. .255] ;
{ Ve r i fi c a r e a r e g u l i l o r l u i De M o r ga n }
w r i te l n ( compl( e , a + b ) A = compl( e , a ) * * compl( e ,
w r i te l n ( compl ( e , a * b ) * = compl ( e , a ) * + compl ( e , b ) *') ;
end.
b)A);
43. Proceduri
Conceptul de procedur extinde pe cel de instruciune. Formele sintactice ale
declaraiei i apelului snt similare celor pentru funcii.
4.3.1. Declararea procedurilor

Definirea unei proceduri Pascal se face n conformitate cu urmtoarele diagrame de sintax:
4.2. Funcii
87
<procedura>
i--------> <antet_piocedura> ; |------> <corp> -------1---,> ; ----->
|
l> <directiva> 1
|
> procedure > <identifi cator> > ; > <corp> 1
<antet^procedura>
i-------------; <-----------^
-------> procedure<identifi catoi> I ( l <param_formal > )-,>

Forma general a textului unei declaraii de procedur este: procedura p
(x1(\. . . ; x) ;
Di;
begin
end; { p }
n antetul procedurii apar:
- p: numele procedurii;
- (x1(- . . ; x ) : list (opional) de parametri formali, n corpul
procedurii snt incluse:

- D x : declaraii locale procedurii (opionale) grupate dup aceleai reguli ca n cazul
funciilor;
- begin.. .end; : instruciune compus; ea nu conine vreo atribuire asupra numelui
procedurii.
Procedura poate s ntoarc mai multe rezultate dar nu prin numele ei, ci
prin variabile desemnate special (cu prefixul var) n lista de parametri; tipurile
rezultatelor se specific n lista de parametri ca tipuri ale acestor variabile.
4.3.2. Apelul procedurilor

Activarea unei proceduri se specific printr-un apel de forma:
p(alf . . . ,an)
cu
- p: numele procedurii;
- ( a , . . . , a ) : lista (opional) de parametri actuali.
Spre deosebire de funcie, apelul de procedur este o instruciune; aceasta se insereaz n

program n locul n care snt dorite efectele produse de execuia procedurii pentru eventualii
parametri actuali a lt . . . , an.
4.3.3. Exemple
Textul de program din 4.2.3 pentru calculul ariei unui triunghi poate fi rescris ca o
procedur Pascal astfel:
pxoceduxe a r i a ( a , b , c : r e a l ; var s : r e a l ) ; var p : r e a l ; begin
p := (a + b + c) / 2 ;
s : = s q r t ( p * ( p - a ) * ( p - b ) * ( p - c ) ) end; { a r i a }
.
Anteml procedurii
88
procedure a r i a ( a , b , c : r e a l ; var s : r e a l ) ;
conine numele ei i declaraiile parametrilor formali a , b , c i s. Restul textului este corpul
procedurii; el conine o declaraie i o instruciune compus. Observm c, spre deosebire de
funcii, n antet nu mai apare o specificaie a tipului rezultatului; de asemenea, numele
procedurii nu apare n partea sting a unei instruciuni de atribuire din corpul ei. Notm n
sfrit forma special n care este declarat parametrul formal s n antet:
var s : r e a l ;
Acesta este acum parametru variabil i va fi folosit pentru ntoarcerea unui rezultat
din procedur; a , b , c snt parametri valoare i servesc, ca i la funcii, pentru acceptarea de
valori transmise procedurii.
Programul are acum forma:
program P4;
var s i : r e a l ;
procedure a r i a ( a , b , c : r e a l ; var s : r e a l ) ; var p : r e a l ;
begin
p
(a + b + c) / 2;
s : = s q r t ( p * ( p - a ) * ( p - b ) * ( p - c ) ) end;
{aria}
begin
a r i a ( 3 , 4 , 6 , s i ) ; w r i te l n
( s i ) end; {P4}
Execuia instruciunii a r i a ( 3 , 4 , 6 , si) determin transmiterea valorilor
primilor trei parametri actuali drept valori ale parametrilor'formali a , b, c i a locaiei
parametrului actual si drept locaia parametrului formal s. Observm c sl este o variabil.
Ea corespunde parametrului formal s, declarat cu vax. Invocarea procedurii determin efecte
echivalente urmtoarei instruciuni compuse:
begin
end;
p : = (3 + 4 + 6 ) / 2 ;
sl : = sqrt(p * (p - 3 ) *
(p - 4 )
(p - 6 ) )
4.4. Programe 4.4.1. Forme

sintactice; exemple
Sintactic, forma general a unui program amintete pe cea pentru funcii i
proceduri:
program P(x1( . . . ,xn) ; D;
begin
.
end. {Pl unde P este numele

programului.
Ca i la funcii / proceduri declaraiile D snt grupate n seciuni (eventual vide) labei,

const, type, var, funct-ion / procedure, scrise n aceast ordine; similar se definesc antetul i
corpul programului. n implementarea Oregon regulile pentru declaraiile din lista D snt
mai puin stricte (vezi 4.6.1.2). De asemenea, antetul programului este opional.
4.2. Funcii
89
Parametrii formali specificai n lista (xv, . . . ,x) denot entiti (de regul fiiere) de
comunicare a programului cu mediul su. Aceste entiti (n afara fiierelor standard input
i output) trebuie declarate n program.
Specificarea identificatorilor input sau output ca parametri formali ai
programului are ca efect declararea implicit a acestora ca fiiere text i executarea implicit a
apelurilor de procedur reset (input), respectiv rewri te (output) la nceputul fiecrei
activri a programului (vezi 2.2.4.1.2).
Corpul programului este urmat de ' . ' i nu de ' ; " ca n cazul funciilor i
procedurilor.
Exemple:
program copie ( f , g ) ;
var f , g : fi l e of real; begin reset(f);
rewrite(g); while not e o f ( f ) do
4.4.
Programe
begin g "
ond.
end
{copie}
93
: =f * ;
p u t ( g ); get ( f )
Parametrii formali f i g din antet snt declarai n corpul programului drept fiiere de
numere reale. Instruciunea compus care urmeaz descrie partea de aciune a programului:
copierea fiierului f n fiierul g.
Programul c o p i ete x t care urmeaz folosete parametrii formali i np u t i o u t p u t
predefinii ca fiiere standard de intrare / ieire. Ei nu vor fi declarai n program. Partea de
instruciuni determin la execuie copierea, linie cu linie, a fiierului de intrare n fiierul de ieire,
pstrnd structura liniilor.
program c o p i ete x t ( i np u t , o u t p u t ) ; var
ch : ch a r ; begin
while not eof do begin
while not e o l n do
begin
r e a d ( ch ) ; w r i te ( ch )
end;
w r i te l n ; i e a d l n
end
end. { c o p i ete x t }
4.4.2. Structura static a programelor

Funciile / procedurile snt declarate n programe i pot s conin, la rndul lor, declaraii
ale altor funcii / proceduri la orice nivel. Relaia de incluziune a declaraiilor de funcii, proceduri i
program definete structura static a programului. Ei i se poate ataa o reprezentare arborescent
n care:
- programului / funciilor / procedurilor le corespund noduri marcate cu numele lor P, 0 , R , . . . ;
- dac P conine declaraia lui Q, reprezentm structura static a lui P prin arborele
90
- dac P conine declaraiile lui Q i R, n aceast ordine, reprezentm structura static a lui p
prin arborele
P
Exemplu. Fie programul:
program P;
procedura Q; begin
...
end; { Q }
procedure R;
function S ; begin
end;
{S}
begin
end;
end.
{P
{R
} begin
Reprezentm structura static a lui P prin arborele:

P
/
Q
\
R
4.4.3. Domenii de vizibilitate a declaraiilor

ntr-un program care nu conine declaraii de funcii / proceduri, pentru orice identificator
x al su exist o singur declaraie d x. Orice referire rx a lui x n program are n vedere obiectul
definit de aceast declaraie. Declaraia i referirile au loc n acelai program. Am vzut cum
declaraii de funcii / proceduri n alte funcii / proceduri conduc la structuri de programe cu mai
multe nivele. Aceasta, mpreun cu libertatea de alegere a numelor n program, fac posibil s existe,
pentru acelai identificator x, mai multe declaraii diferite n uniti de program diferite. Fiecare
astfel de declaraie definete un alt obiect Aceiai identificator poate deci desemna (numi) obiecte
diferite n diferite pri ale programului.
De asemenea, n program pot s apar mai multe referiri r x ale identificatorului x. Fiecare
astfel de referire are n vedere obiectai x definit de o anumit declaraie d x .
4.43.1. Domenii de vizibilitate ale declaraiilor de identificatori
Definiia 1. Fie P un program / procedur / funcie, x un identificator i d x o declaraie a
lui x n P. Se numete domeniu de vizibilitate al lui d x textul de program n care pot apare referiri
r x la identificatorul x ce desemneaz obiectul definit prin declaraia d x .
Domeniul de vizibilitate al lui d^ ncepe imediat dup terminarea declaraiei i se sfrete
odat cu p. Trebuie precizat c declaraia unei funcii / proceduri se consider terminat la sfritul
antetului; acest fapt face posibil apelul recursiv: n corpul funciei / procedurii, aceasta poate fi
referit, fiind vizibil.
Exemplu: n programul urmtor, ncepuml domeniilor de vizibilitate este marcat prin
comentarii, program P ; const n = 3 ;
{de aici n devine v i z i b i l i type natural =
0..maxint; {de aici natural devine vizibil}
function f ( x : natural
4.2. Funcii
91
{de aici x devine vizibil} ) : natural; {de aici f

devine vizibila} begin
if x - 0 then f : = 1
{deci f poate fi referit} else f : = x * f ( x - l )
end;
begin
end.
Exemplu. Urmtoarea declaraie a tipului arbore este eronat:
type arbore - record
info: char;
sting: " arbore; {eroare, referin nainte
ca arbore s devin vizibil}
dreapta:* arbore; end;
{numai de aici arbore devine vizibil}
Domeniul de vizibilitate al unei declaraii d x nu este neaprat o poriune continu din
textul programului. Apariia ntr-un subprogram Q, din domeniul de vizibilitate al declaraiei d,, a
unei alte declaraii d'x (ce implic acelai identificator x) provoac acoperirea domeniului de
vizibilitate al declaraiei prin domeniul de vizibilitate al declaraiei d'x. Acoperirea se produce de la
nceputul declaraiei d x , n timp ce noul domeniu de vizibilitate ncepe de la terminarea declaraiei
d;.
Exemplu. Re programul urmtor:
program P ; const c = 1;
{ a i c i ncepe domeniul de v i z i b i l i t a te a l l u i d c } procedure q ; const
{ a i c i ncepe acoperirea l u i dc p r i n d j }
c=
.
c + l ; { e x p r e s i e i n c o r e c t a } { a i c i ncepe domeniul de v i z i b i l i t a te
a l u i d'c}
begin
end { q } ; b e g i n
. . . end.
E x p r e s i a c + l este incorect: referirea Ia c se face dup acoperirea declaraiei
din programul principal i nainte de a deveni vizibil declaraia din procedura q.
E xe mp l u . n programul
program P ; type t =
0 . . 1 0 ; procedure q ;
var t : t; { e r o a r e }
begin
end;
end.
declaraia din procedura q este eronat. Intenia a fost de a se declara o variabil iocal t,
de tipul global t (definit n programul principal). Referirea ia identificatorul t de dup ' : '
nu este ns n nici un domeniu de vizibilitate; cel din programul principal a fost acoperit
(la nceputul declaraiei var t: t;), iar cel din procedura q ncepe de abia la sfritul acestei
declaraii.
Deci n Pascal domeniul de vizibilitate ai unei declaraii se deterrnin static; el
depinde doar de poziia declaraiei n textul programului i se poate stabili la compilare
ca i n Algol, PL/1 i alte limbaje cu structur d e bloc; conceptul de bloc din aceste
92
limbaje (instruciune compus cu declaraii locale ei) difer ns de cel din Pascal (funcie
/ procedur cu eventuale declaraii locale i o instruciune compus). n alte limbaje de
programare (Lisp, Snobol, APL,...) domeniile de vizibilitate se stabilesc dinamic (la
execuie).
Exemplu. n programul
program P ; type i =
integer;
{1}
procedure Q; var
{2}
{2.1}
x: i;
i : real;
begin
end;
{3} begin
end
{4}.
mo
domeniul de vizibilitate al declaraiei i - integer este textul cuprins intre punctele marcate
{1} i {4} mai puin textul cuprins ntre punctele {2} i {3}. Domeniul de
vizibilitate al declaraiei i : real este cuprins ntre punctele {2.1} i {3}.
. Exemplu. Stabilirea domeniului de vizibilitate este important pentru corectitudinea
apelurilor de funcii / proceduri. n programul program p;
procedura q;
procedura r;
procedura u;
begin { u }
u ; r ; q ; and; { u }
begin { r }
U ; r ; q ; end;
{ r } proceduie s;
procedura t ; begin
t ; s ; q ; r ; end;
{ t } begin { s }
s ; q ; r ; t ; and; { s }
begin { q }
and;
begin
end.
q;r;s;
{q}
{p}
{p}
cu arborele de structur static
P
''>
rot
XQ
q
r
i l
snt peimise numai apelurile specificate n program.
O consecin a regulii de stabilire a domeniului de vizibilitate este faptul c orice
referire r, n P trebuie precedat de o declaraie d, n P sau ntr-un program / funcie /
4.2. Funcii
93
procedur care include P. Singura excepie o constituie referirea tipului d baz T din definiia
unui tip pointer, care poate precede declaraia lui T; totui, declaraia lui T trebuie s apar
n aceeai parte de declaraii de tip cu tipul pointer.
Exemplu. Declaraiile urmtoare:
type
ptr = * nod;
nod = xecoxd
Sting: ptr; informaie:
real; drept: ptr; end; tf
snt corecte, dei declaraia tipului nod apare dup referirea sa n declaraia tipului pointer
ptr.
4.43.2. Domenii de vizibilitate pentru alte declaraii
Ca i identificatorii, etichetele pot fi definite i referite n program. Domeniul de
vizibilitate al unei definiii de etichet se stabilete similar cu cel al declaraiilor identificatorilor.
Specificaia unui identificator constant drept component a unui tip enumerare are
acelai domeniu de vizibilitate cu declaraia acestui tip.
Domeniul de vizibilitate pentru o specificaie de identificator selector de cmp
(proiecie canonic) ntr-o nregistrare este textul definiiei tipului nregistrare n care apare.
Acest domeniu poate fi extins la textul eventualei instruciuni with n care se specific numele
nregistrrii. Un astfel de identificator poate fi referit i n afara domeniului de vizibilitate, dar
nu direct ci calificat de numele nregistrrii. O astfel de referire poate fi fcut n tot domeniul
de vizibilitate al declaraiei nregistrrii.
Exemplu: n programul
program p ;
typo rec = record
(1}
{2}
{2.1}
x : real;
y : record
end; { 3 }
end;
{4}
var x : boolean;
{5}
v : rec;
begin
x : = true;
v. x : = 1.2;
v. y. x : = 1 2 ;
with v do
{6}
begin
x:= 12.5;
y. t : = 7 ;
end;
{7}
end.
{8}
- declaraia x:
x : integer;
t : integer;
real are ca domeniu de vizibilitate textul cuprins ntre punctele { l } - { 4 } cu

excepia celui dintre { 2 } - { 3 } ; el este extins cu textul { 6 } - { 7 } prin instruciunea with;
- declaraia x: integer are domeniul de vizibilitate {2.1}- { 3 } ;
- declaraia x: boolean are domeniul de vizibilitate {5} - {8} cu excepia celui dintre { 6 } {7}.
94
- n afara domeniilor de vizibilitate (extinse), selectorii de cmpuri x

complet cu numele megtetrrilor: v. x, v. y. x.
snt referii prin calificare
ik3
4.43.3. Context asociat unei uniti de program

Prin unitate de program nelegem un program, o funcie sau o procedur.
Fie P o unitate de program i x un identificator declarat n P (n lista llf. . ., x n ) a
parametrilor formali sau n declaraiile D); x desemneaz un obiect focal lui P. Dac acest
obiect este vizibil ntr-o funcie / procedur o declarat n ?, atunci el este global relativ la Q,
fiind "motenit" din P.
Definiia 2. Numim context asociat unei uniti de program mulimea obiectelor
vizibile n ea (locale sau globale).
Conceptual, este util s considerm ca predefinit o unitate de program fictiv n
care este inclus (declarat) orice program. Entitile locale acestui-program fictiv snt
constantele, tipurile, variabilele, procedurile i funciile predefinite (vezi anexa 4). Acestea
devin astfel globale relativ la orice unitate de program i extind 2stfel contextul asociat
acesteia. n lipsa unei precizri contrarii, o referire l contextul asociat are n vedere
aceast extensie, numit i context (spaiu) de execuie.
Unei declaraii i corespunde pe lng domeniul de vizibilitate i un
domeniu de timp.
Definiia 3. Se numete durat de via ("extern") a unei declaraii timpul
ct exist la execuie obiectul definit prin declaraie.
n Pascal, durata de via a unui obiect declarat ntr-o unitate de program
P este timpul ct dureaz execuia lui P.
Durata de via a unei variabile dinamice (vezi 2.7) este cuprins ntre
momentul crerii sale (prin apelul procedurii naw) i momentul dealocrii spaiului
s u (prin apelul procedurii dispose) sau, n lipsa unei dealocri explicite, pn la
sfritul execuiei programului.
4.5. Comunicarea ntre uniti de program

A m vzut cum limbajul Pascal permite definirea de funcii i proceduri
pentru a descrie pri autonome de program care asociaz un nume cu declaraii
de obiecte locale i cu o instruciune compus.
Definiia unei funcii / proceduri se face n partea de declaraii a unei
uniti de program. Referirea ei se poate face prin apeluri n instruciuni ale
unitilor de program din domeniul de vizibilitate al definiiei. Fiecare apel solicit
executarea aciunilor din instmciunea compus a funciei / procedurii asupra
"datelor" particulare locului de chemare. Prezentm n continuare mijloacele prin
care aceste date snt comunicate funciei / procedurii, iar rezultatele produse snt
ntoarse n locul de apel.
n Pascal comunicarea se poate face prin entiti globale i prin parametri.
4.5.1. Comunicarea prin identificatori globali

Un identificator global relativ la o procedur este declarat n afara ei ntr-un
program / funcie / procedur ce o cuprinde, fr a fi redeclarat n ea. El este
cunoscut deci n procedur cu semnificaia dobndit n afara ei, constituind astfel
un mijloc de comunicare de la locul de apel la procedura apelat.
4.2. Funcii
95
Comunicarea r sens invers este de asemenea asigurat: efectele asupra

unui obiect global referit n procedur devin cunoscute n afara acesteia (n tot
domeniul de vizibilitate al declaraiei asociat referirii).
Procedeul se mai numete i comunicare prin parametri implicii i a fost
ilustrat prin exemplele de la nceputul capitolului.
4.5.2. Comunicarea prin parametri

Limbajul permite i specificarea explicit a interfeei ntre funcie / procedur i
programul / subprogramul care o apeleaz.
O list de identificatori locali ai funciei / procedurii specificai n antetul
acesteia drept parametri formali este pus n coresponden biunivoc cu o list
de parametri actuali specificat n apel. Corespondena se realizeaz ntre
parametrii din aceeai poziie n cele dou liste, cei actuali avnd tipuri identice cu
cei formali corespunztori.
.
La execuia apelului valorile parametrilor actuali snt substituite parametrilor formali
astfel c aciunile instruciunilor funciei / procedurii au loc asupra acestor valori, cu efecte la
locul de chemare.
Exist patru feluri de parametri formali:
- parametri valoare
- parametri variabil
- parametri funcie
- parametri procedur.
Parametrii valoare snt cei obinuii n Pascal. Ei nu snt semnalai deci n vreun mod
special. Ceilali parametri snt semnalai n antet prin prefixele var, function i respectiv
pzoceduze.
4.5.2.1. Parametri valoare

Parametrii valoare reprezint mijlocul comun n Pascal pentru comunicarea datelor
de la locul de apel spre funcia / procedur apelat.
Un astfel de parametru se declar n antetul funciei / procedurii prin numele su
urmat de specificaia de tip. De exemplu:
pzoceduze q ( n : integer; x, y : real);
Parametrul actual corespunztor este o expresie a crei valoare are tipul celui formal
(prin excepie, unui parametru formal de tip real poate s-i corespund i o expresie care se
evalueaz l o valoare de tip integer).
Exemplu. Apelurile urmtoare snt corecte: ,
q(3, 1.3,
q(i, j, k) ;
q(7, j, 8 +
7.) ;
:
{
7 div 3) ;
i, j, k : real}
Substituia implicat de parametrii valoare are loc conceptual astfel: la apelul

funciei / procedurii se aloc spaiu pentru parametrul formal, se evalueaz expresia
parametrului actual i valoarea rezultat se depune n acest spaiu drept valoare curent a
parametrului formal. Acesta capt de acum statut de variabil local. El poate fi referit n
funcie / procedur, valoarea sa poate fi modificat aici, fr vreun efect n afara ei. Valoarea
dobndit astfel de parametrul formal se pierde la revenirea n program.
96
Observaii:
1. Aceast substituie a parametrilor formali valoare este cunoscut sub numele de
transmitere (referire, apel, chemare ...) prin valoare. Ea este folosit i de alte limbaje de
programare (ALGOL60, SIMULA, Ada...) [WaGo84].
2. Dac parametrii actuali sint de tipuri structurate i de dimensiuni mari, un
spaiu de memorie de aceeai mrime este irosit pentru parametrii formali, iar copierea
valorilor celor actuali n acest spaiu consum timp. Transferul prin parametrii variabili est
preferabil n astfel de cazuri, cu deosebire dac nu se fac atribuiri asupra parametrilw formali
(vezi 4.5.2.2 i 4.5.3).
3. Fiierele sau Variabilele structurate cu componente fiiere nu pot fi parametri
actuali valoare.
4.5.2.2. Parametri variabil
Parametrii variabil reprezint mijlocul principal de recuperare a rezultatelor din
procedura apelat.
Parametrul formal se declar n antet sub forma
vai n :
t;
unde n este numele iar t tipul su.

Exemplu: Antetul
procedure s (x : real; var y, z : integer);
conine parametrii variabil y i z. Ei se recunosc ca atare prin prefixul var. Parametrul x nu
ar vreun prefix, el fiind deci un parametru valoare.
Parametrul actual corespunztor unui parametru formal variabil este un
identificator de variabil (simpl, component a unui tablou, a unei nregistrri sau a unei
combinaii a acestora, dar nu o component a unei structuri de date mpachetate).
Substituia implicat de parametrii variabil const n asocierea locaiei parametrului
actual cu parametrul formal corespunztor, astfel nct, pe durata apelului, orice referire la
parametrul formal este de fapt o referire la parametrul actual corespunztor.
Astfel, o atribuire asupra parametrului formal devine cunoscut n afara procedurii
prin schimbarea valorii parametrului actual.
Observaii:
1. Acest mod de substituie este cunoscut i sub numele de transmitere
(referire, apel, chemare...) prin referin (adres ...). El este folosit i n alte
limbaje (FORTRAN, Ada...). Snt, de asemenea, implementate i alte mecanisme
de substituie: apel prin nume (ALGOL60), prin rezultat (Ada), prin valoare rezultat (FORTRAN, Ada) etc. [WaGo84].
2. Parametrilor formali variabil li se vor asocia parametri actuali distinci.
Parametrii actuali sinonimi produc efecte neateptate n program (vezi 4.5.3).
3.Dei destinai recuperrii de rezultate din procedur, parametrii variabil snt folosii
ocazional i pentru comunicarea spre procedur. Este cazul parametrilor actuali de tipuri
structurate (azzay, record sau combinaii ale lor) care, transmise prin valoare, ar implica risip
de spaiu (alocat parametrilor formali) i de timp (pentru copierea n acest spaiu a valorilor
parametrilor actuali).
4.Toate calculele de adrese se fac la intrarea n procedur (de exemplu evaluarea indicilor
componentelor de tablouri).
Exemplu: Programul urmtor ilustreaz comunicarea prin variabile globale,
parametri valoare i prin parametri variabil.
program P;
4.2. Funcii
var x, y, z : integer; procedure Q (y :

integer; var z
97
: integer);
z : = z + 1;
1;
11,1,1}
{0,0,0}
{1,0,1}
begin x : = x + 1; y : = y + writeln ( x , y, z )
end; { Q } begin x : = 0 ; y : - 0; z : - 0 ;
writeln ( x , y, z ) ;
0(x, y);
writejn (x, y, z) ; end. {P}
Relativ la procedura 0, identificatorul x este global, y este parametru valoare, iar z
parametru variabil.
n program x , y , z primesc valorile o care snt scrise: 0, 0 , 0 .
Prin execuia apelului Q (x, y), variabilele desemnate prin identificatorii x (global),
y (din procedur i din program) i z (din procedur) primesc valorile l care snt scrise: l , l ,
l. La revenirea n program variabila cu numele x (global) pstreaz valoarea l dobndit n
procedur; variabila y din procedur dispare, valoarea sa nefiind pstrat n vreun fel, deci y
din program continu s aib valoarea o pe care o dobndise aici; z din program dispare dar
valoarea 1 atribuit lui n procedur se recupereaz ca valoare a lui z din program. Valorile
lui x , y, z din program snt scrise: 1, o, l. Valoarea lui y difer de cele ale lui x i z, dei
de flecare dat s-au specificat transformri similare asupra identificatorilor x, y, z. Chiar
valorile variabilelor x i z, dei egale, snt dobndite pe ci diferite.
4.5.2.3. Parametri formali funcie / procedur
O funcie / procedur poate fi desemnat drept parametru formal al altei funcii /
proceduri prin specificarea ei n lista L din antetul acesteia. O specificaie de funcie /
procedura ca parametru formal are forma antetului acelei funcii / proceduri incluznd
parametrii si formali i tipurile lor, iar pentru funcii i tipul rezultatului. De exemplu function
f( x , y : integei) : r e a l ;
i
procedure p ( z : r e a l ) ;
apar ca parametri formali in antetul procedurii cp
procedura q (function f ( x , y : integex) : r e a l ;
procedura p ( z r e a l ) ; vax n :
real);
Un apel al lui q ar putea fi
q ( u , r, a )
unde parametrul actual u este numele unei funcii
function u ( m , n : integer) : r e a l ; begin . . .
and; { u }
iar parametrul actual r este numele unei proceduri r cu antetul
procedura r ( b : r e a l ) ;
98
Observaie. Funciile / procedurile predefinite nu pot fi transmise ca parametri

actuali funcie / procedur. De exemplu apelul procedurii p n forma p ( s i n ) nu este corect,
deoarece sin este o funcie predefinit. Inconvenientul poate fi ns depit definind o funcie
sini
function s i n l ( x : real) : r e a l ; begin
sini ! = Sin( x )
and;
{sini}
care poate ti folosit n apelul p( s i n i ) cu efectul dorit

Exemplu. Programul Ecdif conine declaraia
specific funcia f drept unul din parametrii si formali:
procedura Runge(function f( x ,
xO, y0, h
n
var vx, vy
g l i g2:
procedurii
Runge
care
.
y : real) : real;
: real;
-tt- integer;
: ve c to r ) ;
De asemenea, n partea de declaraii a corpului programului snt definite dou funcii

'"
function g l ( x , y : real) : r e a l ; function g2( x , y : r e a l ) : r e a l ; Procedura

Runge este apelat de dou ori n partea de instruciuni a
corpului programului. Primul apel specific, printre altele, pe g i drept parametru actual
corespunzind parametrului actual de tip funcie f:
Runge(gl, 0 , 1, 5 . 7 , h, vl, v 2 ) ;
Similar pentru cel de-al doilea apel i funcia g2. Urmeaz enunul problemei, algoritmul
folosit i programul Pascal autodocumentat prin comentarii.
Problema: Integrarea ecuaiilor difereniale de forma y' - f(x, y) n condiiile iniiale y (x,,) - ye.
Algoritmul: folosete metoda Runge-Kutta de ordinul patru cu pas constant h; pentru i - 0 ,
1 , . . . , n - l : Xi.i - x + h i
yi.i ' Y i * 1/6- (ki + 2 - k j + 2-k, + k4) + O ( h ) unde kx - h - f (Xj , yt) ka - h ( X i 1/2-h,
y j + 1/2-k,,) k, - h ' t (Xj + 1/2h , yt + 1/2-k2) k - h - f (Xi + h, yt + kj) Cte n valori pentru x i y
smt acumulate n vectorii vx i vy pentru a fi ntoarse n punctul de apel.
t
progxan Ecdif;
{ n piogram se declar procedura Runge i f u n c i i l e g l i g2; se apeleaz
Runge de dou o r i pentru integrarea ecuaiilor difereniale y ' = g l ( x , y ) ,
respectiv y' - g2(x, y).1
cont h - 0.001; n - 10; e - 2.71828;

typa vector - axray [ l . . n ] of r e a l ;
var 3 : xnteger; v l , v2 : vector;
procedura Runge (function f( x , y : r e a l ) : r e a l ; x O , y O , h s r e a l ;
n : integer; var vx, v y : ve c to r ) ;
{Procedura pentru integrarea ecuaiilor d i fe r e n i a l e de forma y ' = f ( x , y ) in
condiiile iniiale y ( x 0 ) y 0 prin metoda Runge-Kutta de ordinul 4 cu pas
constant h i n i te r a i i )
var x, y , k l , k 2 , k 3 , k 4 : real; i : integer;
4.2. Funcii
bagin x
99
x O ; y : - y O { i n i i a l i z r i ] for i : = 1 to
n do { n i te r a i i } bagin kl
h * f(x, y);
k2 h * f(x + h/2, y + kl/2); k3 h * f ( x + h/2, y + k2/2); k4 : -
y :- y + f(kl + 2 * k2, 2*k3+k4)/6;

x
x + h; {se modific x} vx[i] :=
x; {se rein x i y) vy[i] := y
end;{for}end; {Runge} '. .. rfunctiongl(x, y:
real): real;begingi : -2 * x* sin(x)end;{gi}function
g2(x, y :real) :real;beging2 - 1 + (x- y) / (x
+ln(y))end;{g2}beginRunge(gi, o,1.57, h.n, vl,
v2);lapel al lui
Runge pentru integrarea ecuaiei y'- gl(x, y)

in condiiile iniiale y(0) - 1.57 }
writeln (' x
y(x)
pentru y''gl(x,y)');
for j := 1 to n do writeln (vl[j], v2[j]);
writeln;
Runge (g2, e., e + 1, 1E-2, n, vl, v2); {apel al lui
Runge pentru integrarea ecuaiei y'=g2(x, y)
in condiiile iniiale y'te) = e + 1 }
write (' x
y(x)
pentru y''g2(x,y)');
fox j
1 to n do writeln (vl[j], v2[j]) and.
{Ecdif}
4.5^.4. Ta b l o u r i ca parametri
h * f ( x + h, y + k 3 ) ;
Definiia iniial a limbajului nu permite folosirea nemijlocit a tablourilor cu

dimensiuni variabile drept parametri formali n funcii i proceduri, fcnd necesar
modificarea i recompilarea acestora pentru apeluri cu alte dimensiuni ale parametrilor actuali
tablouri.
Un remediu const n declararea tablourilor cu dimensiuni specificate prin
identificatori de constante care snt definite (i modificate) anticipat.
Exemplu. (Vezi 4.52.3, programul Ecdif) .
type vector
procedure Runge
- axxay [l..n] of real;

(... var vx,, vy : vector;
In secvena de program const n
10;
...)
tablourile vx i vy de tip vector snt folosite ca parametri formali ai procedurii Runge.

Valoarea 10 este asociat cu n dar ea poate fi modificat (la 100 de exemplu) prin simpla
redefinire a constantei (const n - 100), fr vreo modificare n textul procedurii.
Acelai efect s-ar obine definind tipul n forma
type vector - axray [1..10] of r e a l
i redefinindu-1 cu
100
type vector = axzay [1..100] of r e a l .

Prima variant este desigur preferabil. Un apel al procedurii ar putea avea
forma
Runge { . . . v i, v2, . . . )
unde tipul tablourilor vl i v2 este definit anticipat prin
var vl, v2 : vector;
Ultimul standard al limbajului ofer ca soluie alternativ (nepreluat n Pascal
Oregon) folosirea drept parametri formali valoare sau variabil a schemelor de tablouri, adic a
specificaiilor de tablouri cu dimensiuni parametrizate definite prin diagramele de sintax:
<schema de tablou>
||packad mxxmy [<dimensiuni>]of-^rrj><id_de_tip>^>
| 1-----> azzay---------[{<dimensiuni>]]of|'
I
;<- - - - -H
I
I-------------!-----------------i--------------------------------------.--------------------------'
<dimensiuni>
- - - -.> identifi cator>..> identifi ca tor> : > <id_de_tip> ------->
4.5.2.5. Structura dinamic a programelor
n 4.4.2. am mtrodus structura static a programelor. Ea are n vedere textul surs*
al programului, punnd n eviden unitile de program componente i este unic pentru un
program dat. Toate consderaiile care au urmat au avut n vedere aceast structur static i
este remarcabil c principalele informaii necesare la compilare (domeniile de vizibilitate a
declaraiilor, legarea identificatorilor la declaraii^..) snt obinute prin explorarea acestei
structuri.
Folosirea funciilor /procedurilor face util luarea n considerare i a structurii
dinamice (la execuie) a programelor.
Structura dinamic este unic pentru o activare a programului (a prii sale de
instruciuni) n condiii iniiale date, dar poate s difere la schimbarea condiiilor iniiale. Ea
are n vedere succesiunea activrilor unitilor de program (funcii / proceduri) componente (a
prii lor de instruciuni) i poate fi reprezentai folosind graful apelurilor (pentru exemple vezi
4.5.4.2) sau modelul conturului al mi Dijksrra [WaGo84].
Fiecare activare a unei funcii / proceduri produce ipostaze proprii ale contextului asociat (vezi
4.4.3) obinute prin:
a) crearea de copii proprii ale entitilor locale (etichete, variabile, funcii, proceduri);
b) crearea de variabile proprii pentru identificatorii folosii ca parametri formali
valoare;
c) stabilirea de legturi (referine) de la identificatorii folosii ca parametri formali
variabil / funcie / procedur la parametrii actuali corespunztori.
Copii multiple de entiti cu declaraii identice pot s existe n acelai timp, n
contexte proprii ale activrilor recursive (vezi 4.5.4).
Dac Q este declarat n p, atunci contextul propriu unei activri a lui Q este
scufundat n contextul asociat (declaraiei) lui p, nu n contextul propriu activrii unitii de
program care a provocat activarea lui Q.
O referire r x a identificatorului x ntr-o activare a unitii de program P
are n vedere obiectul specificat prin declaraia d x vizibil n acel loc; el se
determin la compilare explornd structura static a programului. Specificarea
atributelor acestui obiect este ns, de regul, incomplet la momentul compilrii.
Astfel, pentru o variabil definit prin cvadruplul
'
4.2. Funcii
<nume, tip,
101
locaie, valoare>
doar numele i tipul snt specificate n declaraia corespunztoare din textul programului;
locaia i valoarea vor fi determinate la execuie, folosind structura dinamic a programului
corespunztoare acelei execuii. ;:.
Regulile de completare a informaiei de legare a identificatorilor l a entitile ce le
corespund se numesc reguli de activare i, pentru Pascal, ele snt urmtoarele:
- dac identificatorul este local, el corespunde ipostazei coninute n contextul
propriu al activrii;
- dac identificatorul este parametru formal valoare, el se refer la variabila creat
pentru acesta, n contextul propriu al activrii;
- dac identificatorul este un parametru formal variabil / funcie / procedur, el
se refer la entitatea la care conduce legtura (referina) stabilit n contextul propriu al
activrii.
Observaie. Dac identificatorul numete o entitate extern, legarea lui la acea
entitate se completeaz la momentul editrii task-ului (vezi 4.7 i 7).
4.5.3. Efecte secundare Ia execuia funciilor i procedurilor

Singurul mod n care execuia unei funcii trebuie s influeneze mediul (contextul)
din care este apelat este prin valoarea pe care o ntoarce, atribuit numelui ei, n locul de
apel. Orice alt schimbare n acest; mediu produs de execuia ei este un efect secundar care
poate influena n mod neateptat execuia programului.
Prezentm n continuare practici defectuoase de programare care produc funcii cu
efecte secundare la execuie.
4.5.3.1. Atribuiri asupra variabilelor globale
;:-vrt-:.
{.
Valorile dobndite de variabilele globale n corpul f u n c i e i devin cunoscute

n afara ei (n unitile de program din domeniile de valabilitate ale acestor variabile). Execuia unei astfel de funcii va influena mediul de chemare nu doar prin
valoarea ntoars, ci i prin alterarea valorilor variabilelor globale.
Exemplu.
program p;
var a , b : integer; var x : real;
. function f(c : real) : real; - begin
a : - 7 ; b : - 3; f : a + h
.. . '.
. end; { f }
begin
a : - X ; b : - 2; X
: = f '<5)/10| .
w r i t e l n ( a , b , x ) end.
].
,-,
, . tr.i -.
-jft<a
n programul p variabilele a i b - s n t globale relativ l a funcia f. F u n c i a

este invocat n program n expresia f (5) /10; la execuie ea ntoarce valoarea 15
atribuit numelui ei f. Pe lng aceasta ns, atribuirile fcute asupra variabilelor
globale a i b produc, c a efect secundar, alterarea valorilor acestor variabile n tot
programul.
4.5.3.2. Atribuiri asupra parametrilor formali variabil
102
Valorile dobndite n program de parametrii formali variabil devin cunoscute n locul de chemare c a valori a l e variabilelor globale folosite drept
parametri a c t u a l i n apel.
Execuia unei funcii c u parametri formali variabil produce deci i efectul
secundar de alterare a valorilor acestor variabile globale.
Folosirea v a r i a b i l e l o r globale ca parametri actuali corespunztori
parametrilor formali variabil este deci descurajat n c a z u l funciilor.
Comunicarea standard a funciilor cu mediul de chemare const deci n :
transmiterea de valori spre funcie prin parametri v a l o a r e i ntoarcerea u n u i
( s i n g u r ) rezultat din funcie prin numele ei.
Folosirea variabilelor globale c a mijloc suplimentar de comunicare este
permis. Variabilele globale pot fi deci folosite n f u n c i i , dar se recomand ca
valorile lor s nu fi e schimbate d e acestea.
Observaii:
1. Spre deosebire de funcie, o procedur poate s ntoarc mai mult dect o valoare n mediul
de chemare. Procedura nu conine vreo atribuire asupra numelui ei, deci nici o valoare nu este
ntoars din procedur prin acest nume. Mijlocul standard de ntoarcere de valori din
procedur este prin parametri formali variabil: valorile dobndite de acetia n procedur
devin cunoscute n afara ei ca valori ale parametrilor actuali corespunztori.
2. Atribuirile n procedur asupra variabilelor globale produc efecte secundare similare celor
discutate pentru astfel de atribuiri la funcii. Ele nu snt recomandate nici n acest caz. Astfel
de atribuiri introduc abateri de l a procedeul standard de comunicare dinspre procedur prin
care variabilele participante snt desemnate explicit ca parametri formali variabil (n
declaraie) i parametri actuali (n apel). Efectele lor se propag l a distan (n domenii de
vizibilitate a l e variabilelor globale) i pot interfera cu cele similare produse l a execuia altor
proceduri din acelai program, fcnd riscant utilizarea acestor variabile.
4.53.3. Parametri actuali c u acelai nume pentru parametri formali variabil distinci
Folosirea de parametri actuali cu acelai nume nu este recomandat dac ei
corespund la parametri formali variabil. Se evit astfel o surs de efecte secundare subtile.
Parametrii actuali cu acelai nume ar desemna cte o singur variabil, care la
execuia apelului ar fi cunoscut sub mai multe nume (ale parametrilor formali corespunztori
celor actuali cu acelai nume). O atribuire asupra unuia din aceti parametri formali ar avea
ca efect secundar i alterarea valorilor celorlali.
Exemplu. Programul urmtor ilustreaz efectele secundare produse de folosirea de
parametri actuali cu acelai nume pentru parametri formali variabil.
program P ;
var a : real;
procedure p l 2 (var x , y : r e a l ) ;
begin
x := 1; y
2 and;f p l 2 l
procedure p21 (var x, y : r e a l ) ; begin
y := 2 ; X := 1 end;{p21}
r.
;
begin
pl2( a , a ) ; w r i t e l n ('a- ', a ) ; p21( a , a ) ; writeln ( ' a = ' , a )
end.
{P}
Procedurile pl2 ip21 difer doar prin s i mp l a permutare a instruciunilor
de atribuire x : = l i y : - 2. Dup apelul lui pl2 se scrie a - 2. Dup apelul l u i
p?l se scrie a = l.
4.2. Funcii
103
n s i t u a i i normale (chemri de fonna'pl2 ( a , b ) , p21 ( a , b ) aceast

permutare nu ar fi produs vreun efect pentru c x i y ar fi referit variabile diferite
(a, respectiv b).
M u l te implementri, inclusiv cea pentru Pascal Oregon, nu semnaleaz
astfel de defecte n programe nici l a compilare, nici l a execuie.
Cele de mai sus sugereaz c pentru o procedur c u antetul
p r o c e d ur a p (var x , v
real)
nu este indicat un apel de forma

p ( a [ i ] , a ! i I > unde a | i ] este o component de tablou. Chiar un apel
de forma
pta[ell, aIe2])
unde e l i e2 snt expresii, este susceptibil de a produce efecte secundare dac el
i e2 conduc la aceeai valoare.
:; -l
X: ' :.
.
4.5.4. Recursie
4.5.4.1.
Recursia indirect
ntr-o structur de program reprezentat prin arborele
I
P
Q
? poate s apeleze pe Q, dar Q n u poate s apeleze pe k pentru c R nu este nc

declarat. Limbajul prevede tot u i o facilitate prin c a r e aceast referire d e v i n e
posibil. Pentru aceasta:
1. R va fi preanunat n P naintea l u i Q p r i n antetul su complet,
urmat de d i r e c t i v a f o r wa x d ("nainte").
2. n declaraia propriu-zis a l u i R care urmeaz dup Q, se folosete un
antet redus n care se specific doar numele l u i K , tar parametri i tipuri.
Programul p va avea, de exemplu, forma:
program P ;
procedure R ( x : r e a l ; vai y :
Q(x:real);
var a: i n te ge r ; b e g i n
( 2 . 1 , a ) ; and; Q?
procedure R ; begin end; { R }
i n t e q e r ) ; fo r wa r d ; procedure
104
begin
end. { P $
Reprezentm noua structur a programului prin arborele
P
fo r wa r d Q
\ R
Desigur, referirea lui R n Q era posibil i fr folosirea directivei fo r wa r d , prin

simpla inversare a ordinei declaraiilor Iui Q i R n P. Ar rezulta programul
P
/
\ R
Q
Dac ns att 0 apeleaz pe R ct i R apeleaz pe 0, o astfel de inversare nu
rezolv problema, fiind necesar folosirea directivei forward. Ea face deci posibil acest fel de
referire mutual a dou funcii / proceduri care se numete recursie indirect.
Cazul mai general de recursie indirect al unui lan finit nchis de n > 2 chemri de
funcii / proceduri se specific similar.
4.5.4.2. Recursia direct
Discutm acum cazul recursiei directe n care o funcie / procedur se apeleaz
nemijlocit pe ea nsi. Conceptual, un astfel de apel nu difer de apelul ntre funcii /
proceduri distincte i se implementeaz n translatoare, de regul, prin mijloace similare.
Pentru programator recursia este nc o posibilitate, foarte elegant, de exprimare a
controlului asupra succesiunii prelucrrilor repetitive i ea permite scrierea natural a
programelor care folosesc algoritmi i structuri de date prin esen recursive. Ea este de
aceeai natur cu iteraia care se exprim cu ajutorul instruciunilor de control (n Pascal:
while, r e p e a t , fo r,
vezi 3.2).
n cazul iteraiei repetiia este exprimat i controlat explicit folosind variabile sau
predicate desemnate special acestui scop. In cazul recursiei, repetiia este implicit. Ea este
provocat de execuia unei funcii / proceduri care conine un apel al ei nsi n partea sa de
instruciuni: cnd execuia ajunge la acel apel, o nou execuie este declanat .a.m.d..
Desigur, o condiie de oprire a a c e st u i proces (potenial infinit repetitiv) trebuie prevzut i
programat.
Ilustrm prin cteva exemple simple mecanismul recursiei i meritele relative ale
recursiei i iteraiei. De fiecare dat presupunem definit tipul
type natural = 0..maxint;
Exemplul 1. Funcia factorial
f 1
f : N -----> N, f (n) =
dac n -
X n - f (n-1)
dac n > = 1
poate fi exprimat n Pascal, urmnd direct definiia, n forma

function f ( n : natural) : natural; begin
i f n = 0 then f : = 1
else f 2 = n * f(n-1)
end; { f }
Efectul unui apel de forma f (1 o) este declanarea unui lan de apeluri ale
lui f pentru parametrii actuali 9 , 8 , 7 ,
2, l, 0:
4.2. Funcii
105
f'(10)
10 f ( 9 )
i
1
..
i
f (1)
f(0)
Apelul f (o) determin evaluarea direct a funciei oprind astfel procesul repetitiv;
urmeaz revenirile din apeluri i evaluarea lui f pentru l , 2 ,
9, 10,
ultima valoare fiind ntoars la locul primului apel f (l o). Se observ c apelul recursiv al lui
f este ultima aciune care se execut la activarea funciei factorial. Acesta este un exemplu de
recursie l a sfrit ("tail - end recursion") care, n general, poate fi uor nlocuit prin iteraie
[Kru84] i implementat eficient. Funcia factorial poate fi rescris iterativ folosind dou
variabile auxiliare i i p pentru controlul procesului repetitivi respectiv pentru acumularea
rezultatelor
intermediare:
function f(n:natural): natural; var
i, p: natural; begin
end;
p i - i;
for i: 2 to n do p:- p*i;
f:= p i ffl
{f}
Exemplul 2. Funcia
fib:N - ->,
fib(n)
dac
dac n - 1
dac n >-
fib(n-i) + fib(n-2)
2
are ca valori numerele lui Fibonacci. Forma ei Pascal derivat nemijlocit din definiie nu
ilustreaz cazul recursiei la sfrit:
function fib(n: natural): natural;
begin
if n - 0 then fib:= 0
elae if n = 1 then fib:= 1
elae fib:- fib(n-l) + fib(n-2)
end; {fib}
Fiecare apel al funciei pentru n > - 2 genereaz dou apeluri .a.m.d., de exemplu:
fib(4)
fib(l)
fib(3)
/
\
fib(2)
fib(l)
fib(O)
fib(2)
/
\
fib(l)
1
fib(O)
I
106
Introducnd variabile suplimentare, se poate obine o variant eficient cu recursie la

sfrit (vezi exerciiul 1). O form nerecursiv care evit calculul repetat al valorilor funciei
pentru aceeai valoare a argumentului se obine folosind trei variabile auxiliare i, a, b
(pentru controlul iteraiei, pentru valoarea curent
a funciei i pentru pstrarea unei valori precedente):
. . . . .. . <
function fib(n:natural): natural;

-var i,a,b: natural; begin
if n-0 then fib:= o
elae if n-1 then fib:- 1
else begin
a:= 0; b:= 1; for

i:= 2 to n do bogin
b:= a+b;
a:= b-a
and;
ond;
ond
fib:- b
Exemplul 3. Funcia lui Ackermann [Bro77] (exemplu celebru de funcie recursiv

care nu este primitiv recursiv), redefinit de R. Peter m forma
n + l
a:NxN ---> N, a(m,n)

a(m-i, 1 )
L a(m-.l, a(m, n-l))
dac m = o
=
dac n - 0
dac m>0 i n>0
''
poate fi exprimat cu uurin ca o funcie Pascal recursiv:

function a(m,n: natural): natural;
begin
if m - 0 then a:= n+1
elae if n - 0
then a:= a(n-l,
elsa a:= a(m-l, a(m, n-D)
end; {a}
1)
Funcia ia valori foarte mari chiar pentru valori mici ale parametrilor, de exemplu a
(4,2) i o20000. AmM programat, execuia ei necesit timp de calcul mare (datorit
numrului mare de apeluri recursive) i un spaiu de memorie prohibitiv (datorit "adineimii"
rscursiei), astfel c a devenit un test al calitii implementrii recursiei ,n> limbaje de
programare [Wic82]; graful apelurilor ei pentru m=2, n=l este sugestiv n acest sens:

Cartea de Programare

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Cartea de Programare

Încărcat de

Drepturi de autor:

Formate disponibile

dr. Tudor Blnescu, erban Gavril, conf. dr. Horia Georgescu, dr.

Copyright 1992, Editura

Adresa : Editura Tehnic

Redactor: Ing. Silvia

Tiraj : 20 000 exemplare

Tiparul: IMPRIMERIA ARDEALUL" CLUJ

Un limbaj de programare este un sistem de notaii pentru reprezentarea

matica programrii calculatoarelor i cu noiunile de baz ale informaticii teoretice. Ea

1. VOCABULARUL I SINTAXA LIMBAJULUI ................................................... 5

nisme de abstractizare n Pascal..........................................................

Domenii de vizibilitate pentru alte declaraii . . . .

ext asociat unei uniti de program............................. 99

5. REPREZENTAREA FORMALIZAT A SEMANTICII.......................................

e axiomatice de tip Hoare...................................................................

a instruciunii de efect nul....................................................

a instruciunii de atribuire ................................................... 162

nzile de baz ale depanatorului.......................................................... 197

acestea fiind terminalul utilizatorului.

Primul exemplu este un program numit Mesaj care scrie un ir de caractere.

{declara variabilele intregi

Din exemplele anterioare se poate desprinde urmtoarea structur a unui program

{se declara var iabila reala x}

n programul care urmeaz, ilustrm utilizarea instruciunii iterative while

Presupunem c textul unui program Pascal se afl ntr-un fiier creat cu

Vocabularul oricrui limbaj de programare conine cele mai simple

1.1. Mulimea de caractere

023456,70 |nulsohstxetx eotenqack bel1

Se face distincie ntre caracterele neimprimabile (caracterul

1.2. Vocabularul limbajului

Cuvintele cheie snt rezervate, adic snt utilizate n programe doar cu

Numerele de tipul real desemneaz numere raionale cu numr finit de

Prin sintaxa unui limbaj de programare se nelege, n general, un

Au fost dezvoltate i alte variante echivalente de specificare a sintaxei,

1.3.1. Formalismul BNF

pentru a defini uhitile sintactice ale limbajului Pascal.

< fa c to r > < r e st

au semnificaia: un termen este o succesiune de unul sau mai muli factori,

Exemplu. Unitatea sintactic <rest termen}.- <mai poate fi definit si

< r e st te r m e n ) : : < e mpt y > |

1.3.2. Diagrame sintactice

Prin diagrame sintactice se realizeaz o reprezentare mai intuitiv a

Exemplu. Unitatea sintactica <r.ertnen> poate fi definit prin diagrama

Sintaxa limbajului Pascal este definit cu ajutorul diagramelor sintactice n

Care dintre urmtorii identificatori snt coreci: Pascal, PASCAL , $ PASCAL ,

3. Limbajul Ada [Ada83] definete instruciunea if astfel:

Scriei n notaia BNF definiiile acestor diagrame.

Snt acestea echivalente cu

---- C < D <-l

d) Programul obinut prin concatenarea exemplelor a, b i c.

TIPURI DE DATE, VARIABILE, CONSTANTE,

Un program n limbajul Pascal conine o descriere a aciunilor ce trebuie s

var v_l, . . . , v_n : T ;

Exemplu. Prin labei 1 , 1 0 ; type bin = 0. . 1; var bit. : b i n ;

2.1. Tipuri de date simple

2.1.1. Tipuri de date predefinite

Reprezentarea intern (fornui de memorare) a elementelor de acest

d a c 0 < x < 0 111 3 11 11.1 i i i m

l _ 2 " - | x | dac x < 0 i 2 " - | x | 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 f x

Reprezentarea (memorarea) acestora n calculator se face n virgul

Reprezentarea intern a unui element de acest tip se face pe I byte i

-Tipul text va fi prezentat n paragraful 2.2.4.1.2. Exist de asemenea o serie de operaii

q : - a div b ; r : = a mod b; it ( a < 0)

w r i te l n C 8 div 3 = w r i te l n C - 8 div 3 = w r i te l n C 8 div - 3 '