Obtinerea informatiilor de tip

Informatiile de tip se extrag in decursul analizei declaratiilor si a expresiilor si pot fi considerate ca atribute atasate simbolurilor gramaticale implicate in declaratii si expresii. Obtinerea propriu-zisa a acestor informatii are loc fie prin preluarea lor din TS, fie prin receptarea lor de la analizorul lexical, in momentul detectarii terminalelor identificator sau constanta.

Transmiterea informatiilor de tip spre punctele din analizorul sintactic unde urmeaza sa se execute rutine de analiza semantica se poate realiza prin intermediul:

• unor parametri de iesire (transmisi prin referinta) - in cazul analizoarelor cu descendenti recursivi;
• unei stive de atribute - care poate fi folosita cu toate tipurile de analizoare sintactice, dar mai ales in cazul analizoarelor care lucreaza pe baza de tabele de analiza.

a. Atrib_tip - indica tipul (simplu) pe care il are o constanta, o variabila sau o expresie. Valoarea acestui atribut poate fi: 'intreg', 'real' sau 'caracter'.
b. Atrib_lvalue - poate lua una din valorile: 'adresa ' sau 'valoare', indicand daca o anumita expresie are atasata o adresa stabila de memorie (expresia este formata dintr-o variabila declarata in sectiunea var, sau dintr-un parametru formal declarat cu var), respectiv daca expresia reprezinta un rezultat intermediar, aflat temporar in memorie. Acest atribut este necesar pentru verificari ale parametrilor, in cazul apelurilor de subprograme. El permite detectarea situatiilor in care unui parametru formal declarat cu var (transmis prin adresa) ii corespunde un parametru real care nu are o adresa stabila (nu este o expresie l-value, daca ar fi sa folosim terminologia din limbajul C). Exemplu:

var A : integer;
procedure P (var X : integer);
begin

X := . . .

end; { P }
begin {program principal}

P(12); {1}
P( A + 2 ); {2}
P(A); {3}

end.

In secventa de mai sus apelurile din liniile notate cu {1} si {2} sunt incorecte din punct de vedere al modului de transmitere a parametrilor, in timp ce apelul din linia {3} este corect.
Dupa cum se vede, am convenit ca valorile atributului Atrib_lvalue sa fie aceleasi cu cele ale campului 'tip_transmisie' din nodurile listei LISTA_PAR din TS, pentru a usura rutina de verificare a parametrilor (v. Apeluri de subprograme si Factori).

c. Atrib_val - se foloseste in cazul declaratiilor de constante (sectiunea const) si indica valoarea atribuita unei constante. O asemenea valoare este calculabila la compilare si se obtine prin evaluarea unei expresii statice (v. Evaluarea expresiilor statice).

Reguli semantice referitoare la concordanta tipurilor

In cele ce urmeaza vom adopta urmatoarele conventii legate de tipuri:
 

Expresii relationale

  E₁ oprel E₂

Regula este:

{ Atrib_tip(E₁), Atrib_tip(E₂) }{ 'intreg', 'real' } sau
Atrib_tip(E₁) = Atrib_tip(E₂) = 'caracter'

Tipul rezultatului unei expresii relationale va fi:

Atrib_tip(E₁oprel E₂) = 'intreg'

(convenim ca rezultatul unei expresii relationale este 1 sau 0, dupa cum relatia definita de oprel este sau nu satisfacuta ).
 

Expresii aditive

 
E₁ opad E₂

Regula este:

{ Atrib_tip(E₁), Atrib_tip(E₂)} { 'intreg', 'real' }

Tipul rezultatului este:

if Atrib_tip(E₁) = Atrib_tip(E₂) then
Atrib_tip(E₁ opad E₂) = Atrib_tip(E₁)
else
Atrib_tip(E₁ opad E₂) = 'real'
endif

 

Expresii multiplicative

E₁ opmul E₂

Regula este:

if opmul in {div, mod} then
*trebuie ca Atrib_tip(E₁) = Atrib_tip(E₂) = 'intreg'
else
*trebuie ca {Atrib_tip(E₁), Atrib_tip(E₂)}{'intreg', 'real'}
endif

Tipul rezultatului este:

if opmul in {div, mod} then
Atrib_tip(E₁ opmul E₂) = 'intreg'
else
if opmul = '/' then
Atrib_tip(E₁ opmul E₂) = 'real'
else
*se aplica regula pt. tipul rezultatului de la Expresii aditive
endif
endif

Facem conventia ca , in cazul utilizarii operatorului '/' (impartire reala) pentru operanzi intregi, acestia sa fie convertiti la tipul real.
 

Operatii de atribuire

 
V := E

Regula este:

( Atrib_tip(V) = Atrib_tip(E) sau
( Atrib_tip(V) = 'real' si Atrib_tip(E) = 'intreg' ) ) si
( Atrib_lvalue(V) = 'adresa' )

Se face conventia ca daca tipul membrului stang este 'real' si tipul membrului drept este 'intreg', acesta din urma se converteste la tipul 'real'.
 

Instructiunea for

for V := E₁ to/downto E₂ step E₃ do I

Regula este ca

(Atrib_tip(V) = Atrib_tip(E₁) = Atrib_tip(E₂) = Atrib_tip(E₃) = 'intreg') si
Atrib_lvalue(V) = 'adresa'

Variabile indexate

id[E]

Daca notam cu loc_id locul in TS ocupat de simbolul id, regula este:

TS[loc_id].CLASA = 'nume de tablou' si Atrib_tip(E) = 'intreg'.

Tipul unei variabile indexate este :

Atrib_tip( id[E] ) = TS[loc_id].TIP.

Declaratii de tablouri

array [E₁ .. E₂] of T

Regula este:

Atrib_tip(E₁) = Atrib_tip(E₂) = 'intreg' si
Atrib_val(E₁) <= Atrib_val(E₂)

Referinte ale campurilor de structuri

id₁. id₂

Daca notam cu loc₁, respectiv cu loc₂ pozitiile din TS ocupate de id1 si id2, atunci regula este:

TS[loc₁].CLASA = 'nume de structura ' si
TS[loc₂].CLASA = 'nume de camp' si
exista un nod in TS[loc₂].LISTA_REC care face trimitere spre loc₁

Tipul unei asemenea variabile va fi:

Atrib_tip( id₁. id₂ ) = TS[loc₂].TIP.
 
 

Apeluri de subprograme

id ( E₁, E₂, . . . , E_n )

Notand cu loc_id locul din TS ocupat de id, se vor impune urmatoarele conditii:

• TS[loc_id].CLASA = 'nume functie' sau 'nume procedura ', dupa cum apelul apare intr-o expresie, respectiv intr-o instructiune apel de procedura;
• TS[loc_id].NR_PAR = n;
• Atrib_tip(E_i) = TS[loc_id].LISTA_PAR_i.tip_param sau
  (Atrib_tip(E_i) = 'intreg' si TS[loc_id].LISTA_PAR_i.tip_param ='real' si TS[loc_id].LISTA_PAR_i.tip_transmisie = 'valoare' ), pentru i = 1 . . n.
  Se precizeaza ca LISTA_PAR_i reprezinta nodul de pe pozitia i, din lista LISTA_PAR.
• Atrib_lvalue(E_i) = TS[loc_id].LISTA_PAR_i.tip_transmisie, pentru i = 1 . . n.

Convenim ca, in cazul in care un parametru formal este de tip 'real', iar parametrul de apel corespunzator este de tip 'intreg', valoarea acestuia din urma sa fie convertita la tipul 'real'.

In cazul apelurilor de functii tipul rezultatului va fi:

Atrib_tip( id( E₁, E₂, . . . , E_n )) = TS[loc_id].TIP

Instructiunea case

case E of
C_1,1, . . . ,C_1,n1: I₁;
. . .

C_m,1, . . . ,C_m,nm : I_m;
end

Atrib_tip(E) = Atrib_tip (C_i,j), pt. i = 1..m, j = 1..n_i

Verificarea semantica are loc practic pe durata analizei expresiilor si presupune completarea si testarea atributelor mentionate in acest paragraf. In plus, in cazul expresiilor statice se efectueaza si evaluarea.

In cele ce urmeaza , partea de analiza a expresiilor va fi prezentata utilizand inserarea de marcaje in productiile gramaticale si indicand actiunile semantice corespunzatoare.
 

Evaluarea expresiilor statice

Se realizeaza prin intermediul atributului Atrib_val. Productiile implicate sunt cele care decurg din simbolul Sectiune_const.
 

Expresii aditive

E₁ opad E₂

Atrib_val( E₁ opad E₂ ) = Atrib_val(E₁) opad Atrib_val(E₂)

Expresii multiplicative

E₁ opmul E₂

Determinarea lui Atrib_val se face ca la Expresii aditive, inlocuind opad cu opmul. In cazul impartirilor se vor face verificari pentru a evita impartirea cu 0.

Factori statici

FS -> id | const | ( E )

Daca factorul este o constanta , atunci Atrib_val ia valoarea constantei respective (memorata in TAB_CONST).

Daca factorul este un identificator, atunci se verifica daca TS[loc_id].CLASA = 'nume constanta ' (unde loc_id este locul din TS ocupat de identificator) si daca da, atunci Atrib_val(F) = TAB_CONST[TS[loc_id].VAL ].

Daca factorul este o expresie intre paranteze, atunci Atrib_val(F) = Atrib_val(E).
 

Pozitionarea marcajelor si tratarea acestora pentru evaluarea expresiilor statice sunt explicate pe larg in Anexa D.
 

Analiza expresiilor
 

Atribuiri

Instr_atrib -> Variabila := Expresie₁
Variabila -> identificator₁ |
                    identificator₂ [Expresie₂ ] |
                    identificator₃ . identificator₄

Notand cu tipv si tipe_i valorile lui Atrib_tip determinate pentru Variabila, respectiv pentru Expresie_i (i=1..2), avem:

loc1 = Cauta _TS(identificator₁)
select TS[loc1].CLASA of
'nume de variabila ', 'nume de parametru' :
tipv = TS[loc1].TIP
'nume de functie' :
if loc1 <> ST_BLOC[VSTB] then
*eroare 'nu se poate atribui decat numele functiei curente'
else
tipv = TS[loc1].TIP
endif
default:
*eroare 'acest simbol nu este l-value'
endselect



*fie loc2 indicele intrarii din TS corespunzatoare lui identificator₂
if TS[loc2].CLASA <> 'nume de tablou' then
*eroare ' identificator₂ nu este nume de tablou'
else
if tipe_2 <> 'intreg' then
*eroare 'indicele trebuie sa fie de tip intreg'
else
tipv = TS[loc2].TIP
endif
endif



*fie loc3 si loc4 indicii in TS unde se afla identificator₃, respectiv identificator₄
if TS[loc3].CLASA <> 'nume de structura ' then
*eroare 'identificator₃ nu este nume de structura'
else
if TS[loc4].CLASA = 'nume de camp' then
*cauta in TS[loc4].LISTA_REC un nod cu continutul = loc3
if nu s-a gasit then
*eroare 'identificator₄ nu este camp al lui identificator₃'
else
tipv = TS[loc4].TIP
endif
else
*eroare 'identificator₄ nu este camp al lui identificator₃'
endif
endif



if tipv <> tipe_1 then
if tipv = 'caracter' or tipe_1 = 'caracter' or tipv = 'intreg' then
*eroare 'nu se poate converti tipe_1 la tipv'
endif
endif

 
 

Expresii aditive
Expresie -> Termen₁ |
Expresie₁ Op_ad Termen₂

Notam cu:

• tipe, tipe_1, tipt_i valorile lui Atrib_tip pentru Expresie, Expresie₁ si respectiv Termen_i (i=1..2);
• lval, lvalt_i valorile atributului Atrib_lvalue pentru Expresie si respectiv Termen_i (i=1..2).



lval = 'adresa '



tipe = tipt_1
lval = lvalt_1



lval = 'valoare'



if tipe_1 = 'caracter' or tipt_2 = 'caracter' then
*eroare 'tipuri incompatibile cu operatia'
else
if tipe_1 = 'real' or tipt_2 = 'real' then
tipe = 'real'
else
tipe = tipe_1
endif
endif

 
 

Expresii multiplicative

Se trateaza in mod similar cu cele aditive, aplicand insa regulile enuntate pentru operatiile multiplicative
 

Factori

Factor -> identificator₁ |
identificator₂[ Expresie₁ ] |
identificator₃. identificator₄ |
identificator₅ ( Lista_expresii ) |
( Expresie₂ ) |
Constanta

Lista_expresii -> Expresie₃ |

Lista_expresii , Expresie₃

Notam cu :

• tipf si tipe_i valorile lui Atrib_tip pentru Factor si respectiv Expresie_i (i=1..3);
• lvalf si lvale_i valorile lui Atrib_lvalue pentru Factor si respectiv Expresie_i (i=1..3).

loc1 = Cauta _TS(identificator₁)
select TS[loc1].CLASA of
'nume de constanta' :
ltc = TS[loc1].VAL
tipf = TAB_CONST[ltc].TIP_CONST
lvalf = 'valoare'
'nume de variabila', 'nume de parametru transmis prin adresa':
tipf = TS[loc1].TIP
lvalf = 'adresa'
'nume de parametru transmis prin valoare':
tipf = TS[loc1].TIP
lvalf = 'valoare'
'nume de functie':
if TS[loc1].NR_PAR <> 0 then
*eroare 'numar eronat de parametri la apel'
else
tipf = TS[loc1].TIP
lvalf = 'valoare'
endif
default:
*eroare 'simbol nepermis intr-o expresie'
endselect



*fie loc2 locul din TS corespunzator lui identificator₂
*se fac verificarile de tipuri ca si pentru Variabila
tipf = TS[loc2].TIP
lvalf = 'adresa'



*se fac verificarile de tipuri ca si pentru Variabila
tipf = TS[loc4].TIP
lvalf = 'adresa'



*fie loc5 locul din TS corespunza tor lui identificator₅
if TS[loc5].CLASA <> 'nume de functie' then
*eroare 'identificator₅ nu este nume de functie'
else
cont_par = 0
tipf = TS[loc5].TIP
lvalf = 'valoare'
endif



tipf = tipe_2
lvalf = lvale_2



*fie ltc locul din TAB_CONST unde ALEX a inserat constanta
tipf = TAB_CONST[ltc].TIP_CONST
lvalf = 'valoare'



cont_par = cont_par + 1
if cont_par > TS[loc5].NR_PAR then
*eroare 'numar de parametri prea mare'
else
tipp = TS[loc5].LISTA_PAR[cont_par].tip_parametru
trp = TS[loc5].LISTA_PAR[cont_par].tip_transmisie
if tipe_3 <> tipp then
if (tipe_3 = 'caracter' or tipp = 'caracter') or (tipp = 'real' and trp = 'adresa ') then
*eroare 'param. de pe poz. cont_par nu corespunde ca tip'
endif
endif
if lvale_3 <> trp and trp = 'adresa' then
*eroare 'param. de pe poz. cont_par nu poate fi transmis prin adresa'
endif
endif



if cont_par <> TS[loc5].NR_PAR then
*eroare 'numar de parametri prea mic'
endif

 

Stabilirea marcajelor si a rutinelor aferente pentru analiza tipurilor la instructiunile for si case este propusa studentilor ca exercitiu
 
 

Desfasurarea lucrarii

Dupa modelul procedurilor prezentate in capitolul Analiza expresiilor si in Anexa D, se va completa compilatorul realizat pana acum cu rutinele de analiza a tipurilor. In vederea testarii se vor alege texte sursa care sa contina in principal definitii si referiri de constante, atribuiri, apeluri de subprograme, expresii de diverse grade de complexitate, instructiuni for. Pentru aceste categorii sintactice se vor tipari informatii legate de atributele Atrib_tip, Atrib_lvalue si Atrib_val, precum si mesaje privind eventualele erori semantice semnalate la analiza de tip.
Pentru a realiza integrarea rutinelor semantice cu analizoarele sintactice realizate in lucrarile anterioare se vor utiliza modelele prezentate in Anexa D.