Sunteți pe pagina 1din 18

2

CUPRINS:


Sarcina .................................... ...3

Notiuni teoretice ............................................................................................................................. .......3

Descrierea limbajului dat ................................... .9

Efectuarea sarcinii ................................... .9

Listingul programului ................................... .16

Rezultatele programului ................................... .18

Concluzie ................. .................. ..19

Bibliografie................................... 19























3

Lucrarea de curs la disciplina
Limbaje formale i proiectarea compilatoarelor

Tema: Analizatorul lexical

Sarcina:
1. n descrierea neformal a unui limbaj dat s se evidenieze lexemele. Pentru fiecare tip de lexem s
se construiasc un automat finit, care accept lexeme corecte.
2. Determinai dac automatele construite sunt deterministe.
3. Dac automatul finit nu este detrminist, s se construiasc pentru el un automat finit determinist
echivalent.
4. Construii schema analizatorului lexical pentru limbajul dat.
5. Testai lucrul analizatorului lexical pe 5 iruri de intrare corecte i 3 iruri, care conin lexeme
incorecte sau simboluri neacceptate de limbaj, construind pentru aceste iruri:
Vectorul sintaxic;
Vectorul semantic;
Completarea tabelului pentru fiecare tip de lexem.
6. Elaborai un program pentru analizatorul lexical i demonstrai lucrul programului pentru irurile de
intrare construite.
Notiuni teoretice:
Analiza lexicala
Rolul analizei lexicale este de a traduce textul programului intr-o secven de atomi lexicali. In acest
mod se obine un "text" mai uor de prelucrat de ctre celelalte componente ale compilatorului,Irina
Athanasiu 3/1/2002 Limbaje formale i automate 84deoarece se realizeaz o abstractizare a unei infiniti
de iruri de intrare in atomi de tip - identificatori,constante, etc.
De asemenea prin eliminarea blancurilor i a altor separatori irelevani (ca de exemplucomentarii),
textul prelucrat se poate reduce drastic. De cele mai multe ori analiza lexical realizeaz i alte activitati
auxiliare ca de exemplu pstrarea evidenei numrului de linii citite. O astfel de informaie este foarte
util pentru construirea mesajelor de eroare.
Cand se proiecteaz un analizor lexical se pune in general problema care este nivelul decomplexitate
al atomilor lexicali considerai. De exemplu in cazul in care un limbaj utilizeaz numerecomplexe, se
pune problema dac analizorul lexical va fi cel care va recunoate o constant de forma:(<real>,
<real>)producand un atom lexical corespunztor sau recunoaterea unei astfel de constante ramane
insarcina nivelului analizei sintactice.
In general un analizor lexical este specificat sub forma :
p1 {actiune 1}
4

p2 {actiune 2}
...
pn {actiune n}
unde pi este o expresie regulata, iar actiune i este o secven de operaii care se execut pentru
fiecaresubir care corespunde modelului oferit de pi.
S considerm de exemplu irurile de caractere 99.E10 i 99.EQ.10, care pot s apara intr-
unprogram PL/I. In primul caz este vorba de numrul 99 x 1010, in al doilea caz de o expresierelaional.
Dac analiza se oprete dupa identificarea punctului zecimal cu concluzia c s-a identificatun numr real
se observa c in primul caz oprirea se face prea devreme iar in al doilea caz prea tarziu.
O soluie const din identificarea acestor situaii realizandu-se aa numita cutare inainte.
Astfel,pentru cazul considerat, dup recunoaterea irului 99. se mai cerceteaz cel puin un caracter
pentru ase hotari dac analiza trebuie s se incheie la 99 sau trebuie s continue pan la 99.E10 . O
abordare maibun consta din cutarea sistematic a celui mai lung subir care satisface unul din modelele
p1,...,pn. Dacexist mai multe modele de aceai lungime care sunt satisfcute se va alege o convenie de
alegere :
de exemplu in ordinea p1,...,pn.
Un analizor lexical este de fapt implementarea unui automat finit. Ceea ce se schimb de la
unanalizor lexical la altul este numai specificarea modelelor cutate i a aciunilor asociate.

inceput subsir
--------------------------------
| buffer de intrare
--------------------------------
\ cap de citire
\
+-----------+
| simulator |--------------+
| automat | |
+-----------+ |
| |
+-----------+ +-----------+
| tabela | | tabela |
| de | | proceduri |
| tranzitii | | tratare |
+-----------+ | actiuni |
5

+-----------+
Interfata analizorului lexical
Dupa cum se tie analizorul lexical funcionez ca un modul in cadrul unui compilator sau aoricrui
program care realizeaz prelucrri ce necesit identificarea unor iruri ce pot fi descrise de ogramatic
regulat. In funcionarea sa analizorul lexical interacioneaz cu celelalte component ale compilatorului
prin intermediul unei interfee specifice :
+---------------+ insert_s +-------------------+
| | +---------> | |
| Program sursa | | | tabela de simboli |
| | | +------| |
+---------------+ | | +-------------------+
| /|\ | |
| |revenire | \|/ lookup_s
| | +------------------+
| +-------| |
| | Analizor lexical |<------+
+-----------| | | lookup_c
avans_intrare() +------------------+ |
anlex | | | insert_c |
+--------------------+ | | | +---------------------+
| | | | | | |
| Analizor sintactic |<--+ | +--- | tabela de constante |
| | | | |
+--------------------+ | +---------------------+
\|/ eroare
+---------------+
| |
| Tratare erori |
| |
+---------------+
Interaciunea cu fiierul surs se face prin intermediul a dou subprograme : avans_intrare (care
preia caracterul urmtor din programul sursa) i revenire (care realizeza revenirea inapoi in textul
surs,dac intotdeauna revenirea se face cu un singur caracter se poate utiliza o funcie de tip ungetc).
6

Tabela de simboli este o structur de date al carui rol este de a memora informaii referitoare
laatomii lexicali de tip identificator recunoscui de ctre analizorul lexical. Informaiile referitoarela acesti
simboli sunt utilizate atat in cadrul analizei sintactice cat i in faza de generare de cod.
Introducerea simbolilor in tabela de simboli se face de ctre analizorul lexical,
completareainformaiilor realizandu-se de ctre analizorul sintactic care va aduga informaii ca de
exemplu tipulsimbolului (procedura, variabila, eticheta, etc) i modul de utilizare. Legatura cu tabela de
simboli se faceprin intermediul a doua proceduri : insert_s i lookup_s. Procedura insert_s are ca
argumente un ir decaractere i codul atomului lexical reprezentat de ir. Rezultatul procedurii este adresa
in tabela desimboli la care s-a facut memorarea simbolului. Procedura lookup_s are ca argument un ir iar
carezultat adresa in tabela de simboli la care se gsete simbolul reprezentat de irul respectiv. Dac
intabela nu exist irul cutat rezultatul este 0.
Pentru cuvintele cheie de obicei se face o tratare speciala, de exemplu se poate initializa tabela
desimboli cu intrari corespunztoare tuturor cuvintelor cheie din limbajul respectiv executand apeluri
deforma :
insert_s("if", cod_if);
insert_s("else", cod_else);
etc. inainte de a se incepe execuia efectiv a compilatorului. In acest caz recunoaterea cuvintelorcheie se
va face apoi intr-un mod similar cu a oricarui alt identificator. Se observ deci de ce inmajoritatea
limbajelor de programare cuvintele cheie nu pot s fie utilizate ca nume cu altsemnificaie. O astfel de
tratare are avantajul ca in cazul in care se face o declaraie de tip de forma:
typedef int intreg;
dup introducerea in tabela de simboli a cuvintului intreg de ctre analizorul lexical, analizorulsintactic va
putea s completeze apoi intrarea in tabela de simboli cu informaiile corespunztoarenumelui unui tip. In
acest mod in urmtoarele intalniri ale acestui cuvant analizorul lexical va puteas transmit ca ieire
atomul lexical corespunztor unui nume de tip.
In cazul constantelor analizorul lexical realizeaz recunoaterea acestora i memoreazvalorile
corespunztoare in tabela de constante pentru a permite utilizarea ulterioar in cadrul generriide
cod.Analizorul sintactic apeleaz de obicei analizorul lexical ca pe o funcie care are ca valoarecodul
atomului lexical recunoscut de ctre analizorul lexical. In general intre analizorul lexical ianalizorul
sintactic trebuie s se mai transfere i alte informaii ca de exemplu adresa in tabela desimboli sau in
tabela de constante a unui identificator, cuvantul cheie respectiv constanta identificata dectre analizorul
lexical. Aceste informaii reprezint atributele atomului lexical.
Un compilator recunoate erori in toate fazele sale: analiza lexical, sintactic i in generareade
cod. Dac se intalnete o eroare, se pune problema localizrii sale cat mai precise i apoi amodului in care
se continua analiza astfel incat in continuare s se semnaleze cat mai puine erori caredecurg din aceasta.
7

Un aspect important al interfetei analizorului lexical o constituie interfaa cu sistemul deoperare
corespunztoare citirii textului programului surs. In general este bine ca interfaa cu sistemul deoperare
s fie cat mai bine separat de restul compilatorului pentru a se obine un cod portabil prinpstrarea
aspectelor dependente de main in cadrul funciilor care formeaz aceasta interfa.
Din timpul consumat de ctre procesul de compilare o parte foarte important se consum incadrul
analizei lexicale. La randul sau partea cea mai consumatoare de timp este de obicei partealegat de
operaiile de citire. In mod standard obinerea unui caracter in execuia unui programpresupune copierea
acestuia in mai multe etape - de pe disc in zona tampon a sistemului de operare, dinaceast zon in zona
prevazut in program, de unde apoi se face copierea in variabila care memoreazcaracterul curent.
Chiar i in cazul unui analizor lexical foarte simplu care ar trebui s recunoasc irurile : xxyy,
xxi y dac in irul de intrare se intalneste irul xxy trebuie s se mai citeasc inc un caracter pentru a
seputea stabili dac este vorba de atomul lexical xxyy sau de atomii lexicali xx i y. Se observ ca inacest
caz utilizarea unei proceduri de tip ungetc() nu este suficient.
In general o colecie de funcii care asigur citirea textului surs pentru analizorul lexicaltrebuie s
satisfac urmtoarele condiii:
- funciile trebuie s fie cat mai rapide, realizand un numr minim de copieri pentru
caractereleparcurse;
- existena unui mecanism care s permit examinarea unor caractere in avans i revenirea pe
irul deintrare;
- s admit atomi lexicali suficient de lungi;
Pentru a obine o utilizare eficient a operaiilor legate de accesul la disc este necesar
cadimensiunea bufferuluis fie adaptat modului de alocare a spatiului pe disc. Astfel, pentru sistemul
deoperare MS-DOS utilizarea unui buffer mai mic decat 512 octei nu are nici o justificare (o operaie
decitire va citii cel puin un sector de pe disc). De preferat este ca bufferul s fie un multiplu al unitiide
alocare a spatiului pe disc.

Analiza lexicala
Aceast faz a compilatorului realizeaz traducerea textului programului intr-o forma mai uor
deprelucrat de ctre celelalte componente. Analizorul lexical consider textul primit la intrare ca fiind
format din uniti lexicale pe care le recunoate producand atomi lexicali. Un atom lexical poate s fie de
exemplu, un cuvant cheie al limbajului (for, while, etc) dar i un numr sau un nume. Nu exist
ocoresponden biunivoc intre irurile de intrare i atomii lexicali. Adic, dac pentru atomul
lexicalcorespunztor cuvantului cheie while exist un singur ir de intrare, pentru atomul lexical
corespunztorunui numr intreg pot s existe foarte multe iruri de intrare. Una dintre deciziile ce trebuie
luate lainceputul proiectrii unui compilator const din stabilirea atomilor lexicali. De exemplu, se pune
8

problemadac s existe cate un atom lexical pentru fiecare operator de comparaie (<, <=, >, >=) sau s
existe ununic atom lexical - corespunztor operaiei de comparaie. In primul caz generarea de cod poate
s fie maisimpl. Pe de alt parte existena unui numr mare de atomi lexicali poate complica in mod
exageratanaliza sintactic. In general, operatorii care au aceeai prioritate i asociativitate pot s fie
grupaiimpreun.
Rolul unui analizor lexical este de a traduce irurile de intrare in atomi lexicali. Un atom lexical
estereprezentat printr-un cod numeric care specifica clasa acestuia i o serie de atribute care sunt specific
fiecrei clase. Astfel, poate s existe clasa operatorilor relaionali pentru care un atribut trebuie s
sespecifice tipul concret al operatorului. Tipul atomului lexical este necesar pentru analiza sintactic in
timp
ce valoarea atributului este semnificativ pentru analiza semantic i generarea de cod. Pentru un
atomlexical de tip numr atributele vor descrie tipul numrului i valoarea acestuia.
Un analizor lexical apare in general ca o funcie care interacioneaz cu restul compilatorului
printr-ointerfa simpl : ori de cate ori analizorul sintactic are nevoie de un nou atom lexical va apela
analizorullexical care ii va da atomul lexical urmtor.

Analiza sintactica
Analiza sintactic descompune textul programului sursa in componentele sale "gramaticale",
construind un arbore care reflect aceast structur. S considerm de exemplu expresia :
A * B + C * D
Aceast expresie poate s fie descris de urmtorul tip de arbore numit arbore sintactic:
+
/ \
/ \
/ \
* *
/ \ / \
/ \ / \
A B C D
In acest arbore au fost evideniate relaiile (din punctul de vedere al modului de evaluare)
intrecomponentele expresiei. Dac se dorete ins s se evidenieze structura expresiei din punctul de
vedere alunitilor sintactice din care este format, atunci se va utiliza pentru reprezentarea expresiei un
arbore dederivare (parse tree). Pentru exemplul considerat un arbore de derivare ar putea s fie de forma:

expresie
9

/ | \
expresie + expresie
/ / / \ \ \
/ / / \ \ \
/ / / \ \
expresie * expresie expresie * expresie
| | | |
nume nume nume nume
| | | |
A B C D
Orice analizor sintactic realizeaz traducerea unui ir de atomi lexicali intr-un astfel de arbore de
derivare care descrie relaia ierarhic intre o descriere general a propoziiei analizate (rdcina arborelui)
i irul de atomi lexicali din care este format (frunzele). Un analizor sintactic poate s construiasc efectiv
o structur de date de tip arbore (cu pointeri i inregistrri) sau poate s sintetizeze informaiile din care se
poate face construcia acestuia.

Analiza semantica
Aceast faz este de obicei incorporat in faza de analiz sintactic. Rolul acestei faze const din
verificarea din punct de vedere semantic a structurilor recunoscute drept corecte din punct de vedere
sintactic. Majoritatea verificrilor realizate de ctre aceast faz se refer la tipurile construciilor.De
asemenea aceast faz completeaz arborele de derivare cu o serie de informaii necesare generrii de
cod.

Varianta II

Constantele binare n limbajul de programare PL/I se definesc ca numere ntregi, de precizie fix
sau flotante. Numrul ntreg este o secven arbitrar de cifre binare (0,1), urmat de litera B. Numrul de
precizie fix este o secven arbitrar de cifre binare cu punct zecimal. La sfritul numrului zecimal se
scrie litera B. Numrul flotant binar se definete ca un numr binar ntreg sau flotant, urmat de litera E i
coeficientul exponenial. Coeficientul exponenial este o secven arbitrar de cifre zecimale cu semn.
Semnul + nu este obligatoriu. La sfritul numrului flotant de asemenea se scrie litera B.
Programele propuse spre analizare se definesc cu ajutorul urmtoarelor producii:

<programa>p< secven de numere binare >
< secven de numere binare >p< numr binar >
< secven de numere binare >p< numr binar >< separator>< secven de numere binare >
10

<numr binar>p< numr ntreg >
<numr binar>p< numr de precizie fix >
<numr binar>p< numr flotant >
<separator>p +
<separator>p< separator><blanc>
<separator>p<blanc>< separator>
Utilizind abreviaturile: R < program >, L < secven de numere binare >,
N < numr binar>, S < separator>, i-< numr ntreg>,
p < numr de precizie fix>, f < numr flotant >, _ - <blanc>,
fragmentul de mai sus se transcrie in felul urmator:
Gramatica: G = {V
N
,V
T
,P, R}
V
N
= {R, L, N, S}
V
T
= {+, _,i, p, f}
P ={
1. R L
2. L N
3. L N S L
4. N i
5. N p
6. N f
7. S +
8. S S _
9. S _ S }


1. Tabelul i codul lexemelor pentru limbajul dat:


Lexemele Codul
+ 1
<numar intreg> 2
<numar cu precizie fixa> 3
11

<numar flotant> 4


Automatele finite, care accept lexemele corecte pentru separatori, numere intregi, numere cu
precizie fixa si numere flotante:

AF pentru separatori (determinist):
AF = (Q, ,H , q
0
, F)
Q = {q
0
, q
1
} +
= {+, _}
H (q
0
, _) = {q
0
}
H (q
0
, +) = {q
1
}
H (q
1
, _) = {q
1
}
F = {q
1
}
AFpentru numere intregi (determinist):

b ={0,1}
AF = (Q, ,H ,q
0
, F) B
Q = {q
0
, q
1
}
= {b, B}
H (q
0
, b) = { q
0
}
H (q
0
, B) = { q
1
}
F = { q
1
}



AF pentru numere de precizie fixa (determinist):

b={0,1}
AF = (Q, ,H ,q
0
, F)
Q = {q
0,
q
1
, q
2
, q
3
, q
4
}
= { . , b, B}
H (q
0
, . ) = {q
1
} . b
H (q
0
, b) = {q
3
} B
H (q
1
, b) = {q
2
}
H (q
2
, b) = {q
2
} b .
H (q
2
, B) = {q
4
}
H (q
3
, b) = {q
3
}
H (q
3
, . ) = {q
2
}
F= {q
4
}








q
0
q
1
_ _
q
0
q
1
b
q
0
q
1
q
2
q
3
q
4
b
b
12






AF pentru numere flotante (determinist):

b ={0, 1}
c ={0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
AF = (Q, , H , q
0
, F)
Q = (q
0,
q
1
, q
2
, q
3
, q
4
, q
5
, q
6
, q
7
)
= { . , b, c, +, -, E, B} b
H (q
0
, .) = {q
1
}
H (q
0
,b) = {q
3
} . +
H (q
1
, b) = {q
2
} E
H (q
2
, b) = {q
2
} . -
H (q
2
, E) = {q
4
} c
H (q
3
,.) = {q
2
} b E B
H (q
3
, b) = {q
3
} c
H (q
3
, E) = {q
4
}
H (q
4
,-) = {q
5
}
H (q
4
,+) = {q
5
}
H (q
4
,c) = {q
6
}
H (q
5
,c) = {q
6
}
H (q
6
,c) = {q
6
}
H (q
6
, B) = {q
7
}
F = {q
7
}
2. Automatele finite construite pentru separatori, numere intregi, numere de precizie fixa si
numere flotantesunt deterministe, deoarece toate funciile de tranziie sunt de forma:
i
q a q ! ) , ( H sau ! ) , ( a q H





















q
0
q
1
q
2
q
3
q
4
q
5
q
6
q
7
b
b
c
13






4. Schema analizatorului lexical pentru limbajul dat:

intrare








__ DA

+ NU





0,1 DA

. NU




alt
simbol


EOF







5.iruri acceptate de limbaj:

irul de intrare 1:01101B _ + _ _ 101.11B _ + 0111E-54B _ + _ 001.010B

i p f
1 01101B 101.11B 0111E-54B
2 001.010B

Next, i
AF pentru
separator
AF pentru
numere
ERROR unknown symbol
Iesire
Completarea
vectoruluisintactic
ERROR illegal separator
Cautarea dupa TN,
Completarea vect.Sint i Sem.

ERROR illegal bit number
14











irul de intrare 2:1001.001B _ + _ 11E29B _ + _ _ _ 010.110E-112B + .0001B +11011B

i p f
1 11011B 1001.001B 11E29B
2 .0001B 010.110E-112B







irul de intrare 3: .011101B _ + 110001B + 000100B + _ 1.001E71B _ _ + 01011B + _ _ _ 101.B

i p f
1 110001B .011101B 1.001E71B
2 000100B 101.B
3 01011B








irul de intrare4: 011.10001E+15B _ + 001.001B + _ 010B + 101E -55

i p f
1 010B 001.001B 011.10001E+15B
2 101E-55






irul de intrare 5: 110.01E22B _ _ + _ _ _ 010.111E-3B _ + _ _ _ 1001.001B _ + 1010E12B _ + _
0111.111B
Vectorul
sintactic
2 1 3 1 4 1 3
Vectorul
semantic
1 1 1 2
Vectorul
sintactic
3 1 4 1 4 1 3 1 2
Vectorul
semantic
1 1 2 2 1
Vectorul
sintactic
3 1 2 1 2 1 4 1 4 1 3
Vectorul
semantic
1 1 2 1 3 2
Vectorul
sintactic
4 1 3 1 2 1 4
Vectorul
semantic
1 1 1 2
i p f
15












iruri neacceptate de limbaj:

irul de intrare 6: 1001.B _ _ + _ + _ .011E4B _ _ + _ 101EB + _ 210B
ERROR(1) illegal separator(_ _ + _ + _)
ERROR(2) illegal bit number(101EB)
ERROR(3) unknown symbol (210B)

i p f
1 1001.B .011E4B







irul de intrare 7: 110.01.1B _ + 110.01B + 11021B + _ + _ 01.E+ -24B _ + 11B
ERROR(1) illegal bit number (110.01.1B)
ERROR(2) illegal bit number (11021B)
ERROR(3) illegal separator (+ _ + _)
ERROR(4) illegal bit number (01.E+-24B)

i p f
1 11B 110.01B







irul de intrare 8: 101.011E-247B _ + _ .11101E1AB + _ _ + 110B _ _ _ + . _ + 71011BE
ERROR(1) illegal bit number ( .11101E1AB)
ERROR(2) illegal separator (+ _ _ +)
ERROR(3) illegal bit number ( . )
ERROR(4) unknown symbol (71011BE)


i p f
1 110B 101.011E-247B
1 1001.001B 110.01E22B
2 0111.111B 010.111E-3B
3 1010E12B
Vectorul
sintactic
4 1 4 1 3 1 4 1 3
Vectorul
semantic
1 2 1 3 2
Vectorul
sintactic
3 -1 4 1 -1 1 -1
Vectorul
semantic
1 1
Vectorul
sintactic
-1 1 3 1 -1 -1 -1 1 2
Vectorul
semantic
1 1
16







6. Listingul programului :
#include<stdio.h>
#include<conio.h>
#include<string.h>
int control(char *q)
{ int k=0;
int e=0;
int gf=0;
for(int i=0;i<strlen(q);i++)
{ if (q[i]=='E') e=1;
if ((q[i]=='E')&&(q[i]=='B'))
{ gf=2; break;}
if ((q[i]>49)&&(q[i]<56)&&(e==0))
{gf=3; break; }
if (q[i]=='.')
{ k++; break; }
if (k==2)
{gf=2; break; }
if (q[i]=='A')
{ gf=4; break;}
}
return gf;
}
int f1(char *s,int *q)
{ int i;
int j=0;
int k=1;
int h=0;
char w[20];
for (i=0;i<strlen(s);i++)
{

if ((s[i]=='+')&&(s[i]!='E'))

if (q[j-1]==1)
{ q[j++]=-1;
printf("\nERROR:illegal separator\n"); }
else
q[j++]=1;

else
if (s[i]!='_')
w[h++]=s[i];
if ((s[i]=='B')||(s[i]==' \0'))
{
w[h]='\0';
Vectorul
sintactic
4 1 -1 -1 2 1 -1 1 -1
Vectorul
semantic
1 1
17

h=0;
int e=0;
// puts(w);
/// verificam daca nu este gresit ceva
k=1;
if (control(w)!=0)
{ q[j++];continue; }
for (int f=0;f<strlen(w);f++)
{
if ((w[f]=='.')||(w[f]=='E')||(w[f]=='B'))
{ k++; }
if (w[f]=='E')
{ e=1; break; }


}
if (e==1)
q[j++]=4;
else
q[j++]=k

}

}

return j;

}
void f2(int *q,int n)
{
int l[5]={0,0,0,0};
printf("\n");
for (int i=0;i<n;i++)
if (q[i]<2){ printf(" "); continue; }
else
{ l[q[i]]+=1;

printf(" %d",l[q[i]]);

}
}
void main()
{ clrscr();
char s[]={'0','1','1','0','1','B','_','+','_','+','_','1','0','1','.','1','1',
'B','_','+','0','1','.','1','E',' -','5','4','B','_','+','_','0','0','1','.',
'0','1','0','B'};
puts("Introduceti un sir:");
gets(s);

int q[10];
int n=f1(s,q);
printf("\nVectorul sintactic\n");
18

for (int i=0;i<n;i++)
printf(" %d",q[i]);
printf("\nVectorul semantic\n");
f2(q,n);
getch();



Rezultatele programului:

Introducem un sir corect





Introducem un sir gresit:


19









Concluzie:

Efectuind acest proiect de curs am studiat si am aplicat in practica notiuni, definitii, si tehnici
necesare pentru proiectarea unui analizator lexical. Pentru fiecare tip de lexem am construit cite un
automat finit.
Am construit schema de lucru a unui analizator lexical. Am elaborat un program pentru
analizatorul lexical dat, acesta reprezintind de fapt proiectarea unui mic tip de compilator, dupa care am
testat lucrul acestuia pentru siruri corecte si incorecte cu erorile descrise.Astfel am ntrit conotinele n
ceea ce privete programarea limbajelor formale.


Bibliografie (resurse internet):
1. (.)
http://www.codenet.ru/progr/compil/cons/001.php

2. ., . , . . 1:
. .: , 1978. -- 612 .

3. Irina Athanasiu Limbaje formale

4. Ciclu de prelegeri citit la facultate la disciplina L.F.P.C.