Sunteți pe pagina 1din 18

CUPRINS:

?   




 
   

        

     

  
    

    
    


   

!
   






2
       
"  
  #
   

 
$

%  &' 
  ( 

?  &
1.‘ G descrierea eformală a u ui limbaj dată să se evide ieze lexemele. Pe tru fiecare tip de lexemă să
se co struiască u automat fi it, care acceptă lexeme corecte.
2.‘ Determi ai dacă automatele co struite su t determi iste.
.‘ Dacă automatul fi it u este detrmi ist, să se co struiască pe tru el u automat fi it determi ist
echivale t.
4.‘ Co struii schema a alizatorului lexical pe tru limbajul dat.
5.‘ Testai lucrul a alizatorului lexical pe 5 şiruri de i trare corecte şi  şiruri, care co i lexeme
i corecte sau simboluri eacceptate de limbaj, co strui d pe tru aceste şiruri:
‘ -ectorul si taxic;
‘ -ectorul sema tic;
‘ Completarea tabelului pe tru fiecare tip de lexemă.
6.‘ Elaborai u program pe tru a alizatorul lexical şi demo strai lucrul programului pe tru şirurile de
i trare co struite.

 
  &
'   (  
Rolul a alizei lexicale este de a traduce textul programului i tr-o secve ă de atomi lexicali. I acest
mod se obi e u "text" mai uşor de prelucrat de către celelalte compo e te ale compilatorului,Iri a
Atha asiu 12002 Limbaje formale şi automate 84deoarece se realizează o abstractizare a u ei i fi ităi
de şiruri de i trare i atomi de tip - ide tificatori,co sta te, etc.
De aseme ea pri elimi area bla curilor şi a altor separatori ireleva i (ca de exemplucome tarii),
textul prelucrat se poate reduce drastic. De cele mai multe ori a aliza lexicală realizează şi alte activitati
auxiliare ca de exemplu păstrarea evide ei umărului de li ii citite. O astfel de i formaie este foarte
utilă pe tru co struirea mesajelor de eroare.
Ca d se proiectează u a alizor lexical se pu e i ge eral problema care este ivelul decomplexitate
al atomilor lexicali co siderai. De exemplu i cazul i care u limbaj utilizează umerecomplexe, se
pu e problema dacă a alizorul lexical va fi cel care va recu oaşte o co sta tă de forma:(<real>,
<real>)produca d u atom lexical corespu zător sau recu oaşterea u ei astfel de co sta te rama e
i sarci a ivelului a alizei si tactice.
I ge eral u a alizor lexical este specificat sub forma :
p1 {actiu e 1}

p2 {actiu e 2}
...
p {actiu e }
u de pi este o expresie regulata, iar actiu e i este o secve ă de operaii care se execută pe tru
fiecaresubşir care corespu de modelului oferit de pi.
Să co siderăm de exemplu şirurile de caractere 99.E10 şi 99.EQ.10, care pot să apara i tr-
u program PLI. I primul caz este vorba de umărul 99 x 1010, i al doilea caz de o expresierelaio ală.
Dacă a aliza se opreşte dupa ide tificarea pu ctului zecimal cu co cluzia că s-a ide tificatu umăr real
se observa că i primul caz oprirea se face prea devreme iar i al doilea caz prea tarziu.
O soluie co stă di ide tificarea acestor situaii realiza du-se aşa umita căutare i ai te.
Astfel,pe tru cazul co siderat, după recu oaşterea şirului 99. ҏse mai cercetează cel pui u caracter
pe tru ase hotari dacă a aliza trebuie să se i cheie la 99 sau trebuie să co ti ue pa ă la 99.E10 . O
abordare maibu ă co sta di căutarea sistematică a celui mai lu g subşir care satisface u ul di modelele
p1,...,p . Dacăexistă mai multe modele de aceaşi lu gime care su t satisfăcute se va alege o co ve ie de
alegere :
de exemplu i ordi ea p1,...,p .
U a alizor lexical este de fapt impleme tarea u ui automat fi it. Ceea ce se schimbă de la
u a alizor lexical la altul este umai specificarea modelelor căutate şi a aciu ilor asociate.

i ceput subsir
--------------------------------
| buffer de i trare
--------------------------------
\ cap de citire
\
+-----------+
| simulator |--------------+
| automat | |
+-----------+ |
||
+-----------+ +-----------+
| tabela | | tabela |
| de | | proceduri |
| tra zitii | | tratare |
+-----------+ | actiu i |
4
+-----------+
Y  
    
Dupa cum se ştie a alizorul lexical fu cio eză ca u modul i cadrul u ui compilator sau aoricărui
program care realizează prelucrări ce ecesită ide tificarea u or şiruri ce pot fi descrise de ogramatică
regulată. I fu cio area sa a alizorul lexical i teracio ează cu celelalte compo e t ale compilatorului
pri i termediul u ei i terfee specifice :
+---------------+ i sert_s +-------------------+
| | +---------> | |
| Program sursa | | | tabela de simboli |
| | | +------| |
+---------------+ | | +-------------------+
| |\ | |
| |reve ire | \| lookup_s
| | +------------------+
| +-------| |
| | A alizor lexical |<------+
+----------- | | | lookup_c
ava s_i trare() +------------------+ |
a lex | | | i sert_c |
+--------------------+ | | | +---------------------+
|||||||
| A alizor si tactic |<--+ | +---Ҡ | tabela de co sta te |
|||||
+--------------------+ | +---------------------+
\| eroare
+---------------+
||
| Tratare erori |
||
+---------------+
I teraciu ea cu fişierul sursă se face pri i termediul a două subprograme : ava s_i trare (care
preia caracterul următor di programul sursa) şi reve ire (care realizeza reve irea i apoi i textul
sursă,dacă i totdeau a reve irea se face cu u si gur caracter se poate utiliza o fu cie de tip u getc).

5
Tabela de simboli este o structură de date al carui rol este de a memora i formaii referitoare
laatomii lexicali de tip ide tificator recu oscui de către a alizorul lexical. I formaiile referitoarela acesti
simboli su t utilizate atat i cadrul a alizei si tactice cat şi i faza de ge erare de cod.
I troducerea simbolilor i tabela de simboli se face de către a alizorul lexical,
completareai formaiilor realiza du-se de către a alizorul si tactic care va adăuga i formaii ca de
exemplu tipulsimbolului (procedura, variabila, eticheta, etc) şi modul de utilizare. Legatura cu tabela de
simboli se facepri i termediul a doua proceduri : i sert_s şi lookup_s. Procedura i sert_s are ca
argume te u şir decaractere şi codul atomului lexical repreze tat de şir. Rezultatul procedurii este adresa
i tabela desimboli la care s-a facut memorarea simbolului. Procedura lookup_s are ca argume t u şir iar
carezultat adresa i tabela de simboli la care se găseşte simbolul repreze tat de şirul respectiv. Dacă
i tabela u există şirul căutat rezultatul este 0.
Pe tru cuvi tele cheie de obicei se face o tratare speciala, de exemplu se poate i itializa tabela
desimboli cu i trari corespu zătoare tuturor cuvi telor cheie di limbajul respectiv executa d apeluri
deforma :
i sert_s("if", cod_if);
i sert_s("else", cod_else);
etc. i ai te de a se i cepe execuia efectivă a compilatorului. I acest caz recu oaşterea cuvi telorcheie se
va face apoi i tr-u mod similar cu a oricarui alt ide tificator. Se observă deci de ce i majoritatea
limbajelor de programare cuvi tele cheie u pot să fie utilizate ca ume cu altăsem ificaie. O astfel de
tratare are ava tajul ca i cazul i care se face o declaraie de tip de forma:
typedef i t i treg;
după i troducerea i tabela de simboli a cuvi tului i treg de către a alizorul lexical, a alizorulsi tactic va
putea să completeze apoi i trarea i tabela de simboli cu i formaiile corespu zătoare umelui u ui tip. I
acest mod i următoarele i tal iri ale acestui cuva t a alizorul lexical va puteasă tra smită ca ieşire
atomul lexical corespu zător u ui ume de tip.
I cazul co sta telor a alizorul lexical realizează recu oaşterea acestora şi memoreazăvalorile
corespu zătoare i tabela de co sta te pe tru a permite utilizarea ulterioară i cadrul ge erăriide
cod.A alizorul si tactic apelează de obicei a alizorul lexical ca pe o fu cie care are ca valoarecodul
atomului lexical recu oscut de către a alizorul lexical. I ge eral i tre a alizorul lexical şia alizorul
si tactic trebuie să se mai tra sfere şi alte i formaii ca de exemplu adresa i tabela desimboli sau i
tabela de co sta te a u ui ide tificator, cuva tul cheie respectiv co sta ta ide tificata decătre a alizorul
lexical. Aceste i formaii reprezi tă atributele atomului lexical.
U compilator recu oaşte erori i toate fazele sale: a aliza lexicală, si tactică şi i ge erareade
cod. Dacă se i tal eşte o eroare, se pu e problema localizării sale cat mai precise şi apoi amodului i care
se co ti ua a aliza astfel i cat i co ti uare să se sem aleze cat mai pui e erori caredecurg di aceasta.
6
U aspect importa t al i terfetei a alizorului lexical o co stituie i terfaa cu sistemul deoperare
corespu zătoare citirii textului programului sursă. I ge eral este bi e ca i terfaa cu sistemul deoperare
să fie cat mai bi e separată de restul compilatorului pe tru a se obi e u cod portabil pri păstrarea
aspectelor depe de te de maşi ă i cadrul fu ciilor care formează aceasta i terfaă.
Di timpul co sumat de către procesul de compilare o parte foarte importa tă se co sumă i cadrul
a alizei lexicale. La ra dul sau partea cea mai co sumatoare de timp este de obicei partealegată de
operaiile de citire. I mod sta dard obi erea u ui caracter i execuia u ui programpresupu e copierea
acestuia i mai multe etape - de pe disc i zo a tampo a sistemului de operare, di această zo ă i zo a
prevazută i program, de u de apoi se face copierea i variabila care memoreazăcaracterul cure t.
Chiar şi i cazul u ui a alizor lexical foarte simplu care ar trebui să recu oască şirurile : xxyy,
xxşi y dacă i şirul de i trare se i tal este şirul xxy trebuie să se mai citească i că u caracter pe tru a
seputea stabili dacă este vorba de atomul lexical xxyy sau de atomii lexicali xx şi y. Se observă ca i acest
caz utilizarea u ei proceduri de tip u getc() u este suficie tă.
I ge eral o colecie de fu cii care asigură citirea textului sursă pe tru a alizorul lexicaltrebuie să
satisfacă următoarele co diii:
-‘ fu ciile trebuie să fie cat mai rapide, realiza d u umăr mi im de copieri pe tru
caractereleparcurse;
-‘ existe a u ui meca ism care să permită exami area u or caractere i ava s şi reve irea pe
şirul dei trare;
-‘ să admită atomi lexicali suficie t de lu gi;
Pe tru a obi e o utilizare eficie tă a operaiilor legate de accesul la disc este ecesar
cadime siu ea bufferuluisă fie adaptată modului de alocare a spatiului pe disc. Astfel, pe tru sistemul
deoperare MS-DOS utilizarea u ui buffer mai mic decat 512 octei u are ici o justificare (o operaie
decitire va citii cel pui u sector de pe disc). De preferat este ca bufferul să fie u multiplu al u ităiide
alocare a spatiului pe disc.

    
Această fază a compilatorului realizează traducerea textului programului i tr-o forma mai uşor
deprelucrat de către celelalte compo e te. A alizorul lexical co sideră textul primit la i trare ca fii d
format di u ităi lexicale pe care le recu oaşte produca d atomi lexicali. U atom lexical poate să fie de
exemplu, u cuva t cheie al limbajului (for, while, etc) dar şi u umăr sau u ume. Nu există
ocorespo de ă biu ivocă i tre şirurile de i trare şi atomii lexicali. Adică, dacă pe tru atomul
lexicalcorespu zător cuva tului cheie ƒ   există u si gur şir de i trare, pe tru atomul lexical
corespu zătoru ui umăr i treg pot să existe foarte multe şiruri de i trare. U a di tre deciziile ce trebuie
luate lai ceputul proiectării u ui compilator co stă di stabilirea atomilor lexicali. De exemplu, se pu e
U
problemadacă să existe cate u atom lexical pe tru fiecare operator de comparaie (<, <=, >, >=) sau să
existe u u ic atom lexical - corespu zător operaiei de comparaie. I primul caz ge erarea de cod poate
să fie maisimplă. Pe de altă parte existe a u ui umăr mare de atomi lexicali poate complica i mod
exagerata aliza si tactică. I ge eral, operatorii care au aceeaşi prioritate şi asociativitate pot să fie
grupaiimpreu ă.
Rolul u ui a alizor lexical este de a traduce şirurile de i trare i atomi lexicali. U atom lexical
esterepreze tat pri tr-u cod umeric care specifica clasa acestuia şi o serie de atribute care su t specific
fiecărei clase. Astfel, poate să existe clasa operatorilor relaio ali pe tru care u atribut trebuie să
sespecifice tipul co cret al operatorului. Tipul atomului lexical este ecesar pe tru a aliza si tactică i
timp
ce valoarea atributului este sem ificativă pe tru a aliza sema tică şi ge erarea de cod. Pe tru u
atomlexical de tip umăr atributele vor descrie tipul umărului şi valoarea acestuia.
U a alizor lexical apare i ge eral ca o fu cie care i teracio ează cu restul compilatorului
pri tr-oi terfaă simplă : ori de cate ori a alizorul si tactic are evoie de u ou atom lexical va apela
a alizorullexical care ii va da atomul lexical următor.

     
A aliza si tactică descompu e textul programului sursa i compo e tele sale "gramaticale",
co strui d u arbore care reflectă această structură. Să co siderăm de exemplu expresia :
A*B+C*D
Această expresie poate să fie descrisă de următorul tip de arbore umit arbore si tactic:
+
\
\
\
**
\\
\\
ABCD
I acest arbore au fost evide iate relaiile (di pu ctul de vedere al modului de evaluare)
i trecompo e tele expresiei. Dacă se doreşte i să să se evide ieze structura expresiei di pu ctul de
vedere alu ităilor si tactice di care este formată, atu ci se va utiliza pe tru repreze tarea expresiei u
arbore dederivare (parse tree). Pe tru exemplul co siderat u arbore de derivare ar putea să fie de forma:

expresie
8
|\
expresie + expresie
\\\
\\\
\\
expresie * expresie expresie * expresie
||||
ume ume ume ume
||||
ABCD
Orice a alizor si tactic realizează traducerea u ui şir de atomi lexicali i tr-u astfel de arbore de
derivare care descrie relaia ierarhică i tre o descriere ge erală a propoziiei a alizate (rădăci a arborelui)
şi şirul de atomi lexicali di care este format (fru zele). U a alizor si tactic poate să co struiască efectiv
o structură de date de tip arbore (cu poi teri şi i registrări) sau poate să si tetizeze i formaiile di care se
poate face co strucia acestuia.


    
Această fază este de obicei i corporată i faza de a aliză si tactică. Rolul acestei faze co stă di
verificarea di pu ct de vedere sema tic a structurilor recu oscute drept corecte di pu ct de vedere
si tactic. Majoritatea verificărilor realizate de către această fază se referă la tipurile co struciilor.De
aseme ea această fază completează arborele de derivare cu o serie de i formaii ecesare ge erării de
cod.

-   ))

Co sta tele bi are î limbajul de programare PLI se defi esc ca umere î tregi, de precizie fixă
sau flota te. Numărul î treg este o secve ă arbitrară de cifre bi are (0,1), urmată de litera B. Numărul de
precizie fixă este o secve ă arbitrară de cifre bi are cu pu ct zecimal. La sfîrşitul umărului zecimal se
scrie litera B. Numărul flota t bi ar se defi eşte ca u umăr bi ar î treg sau flota t, urmat de litera E şi
coeficie tul expo e ial. Coeficie tul expo e ial este o secve ă arbitrară de cifre zecimale cu sem .
Sem ul ³+´ u este obligatoriu. La sfîrşitul umărului flota t de aseme ea se scrie litera B.
Programele propuse spre a alizare se defi esc cu ajutorul următoarelor producii:

<programa>r< secve ă de umere bi are >


< secve ă de umere bi are >r< umăr bi ar >
< secve ă de umere bi are >r< umăr bi ar >< separator>< secve ă de umere bi are >
9
< umăr bi ar> r< umăr î treg >
< umăr bi ar> r< umăr de precizie fixă >
< umăr bi ar> r< umăr flota t >
<separator>r +
<separator>r< separator><bla c>
<separator>r<bla c>< separator>
Utilizi d abreviaturile: R ± ü  , L ± ü 
      ,
N ± ü   , S ± ü  , i-ü    ,
p ± ü   
 , f ± ü    , _ - <
>,
fragme tul de mai sus se tra scrie i felul urmator:
Gramatica: G = {-N,-T,P, R}
-N= {R, L, N, S}
-T = {+, _,i, p, f}
P ={
1.‘ R ĺ L
2.‘ L ĺ N
.‘ L ĺ N S L
4.‘ N ĺ i
5.‘ N ĺ p
6.‘ N ĺ f
U.‘ S ĺ +
8.‘ S ĺ S _
9.‘ S ĺ _ S }

‘ %   #
  (  
      &


 (   
 

+ 1

<    > 2

< 
 
 > 

10
<   > 4



'
     *      +  (    
         
*       *      
  (    
 &

AF pe tru separatori (determi ist):


AF = (Q, Ü , , q0, F)
Q = {q0, q1 } +
_ _
Ü = {+, _} q0 q1
(q0, _) = {q0 }
(q0, +) = {q1 }
(q1, _) = {q1 }
F = {q1 }
AFpe tru umere i tregi (determi ist):

b ={0,1}
AF = (Q, Ü , ,q0, F) b B
Q = {q0, q1 } q0 q1
Ü = {b, B}
(q0, b) = { q0 }
(q0, B) = { q1 }
F = { q1 }

AF pe tru umere de precizie fixa (determi ist):

b={0,1}
AF = (Q, Ü , ,q0, F)
Q = {q0, q1, q2, q, q4 }
Ü = { . , b, B} q1 b
(q0, . ) = {q1 } . b
(q0, b) = {q } q0 q2 B q4
(q1, b) = {q2 }
(q2, b) = {q2 } b .
(q2, B) = {q4 } q
(q, b) = {q }
(q, . ) = {q2 } b
F= {q4 }

11
AF pe tru umere flota te (determi ist):

b ={0, 1}
c ={0, 1, 2, , 4, 5, 6, U, 8, 9}
AF = (Q, Ü , , q0, F) b
Q = (q0, q1, q2, q, q4, q5, q6, qU)
Ü = { . , b, c, +, -, E, B} b
(q0, .) = {q1 } q1 q2
(q0,b) = {q } . + q5
(q1, b) = {q2 } E
(q2, b) = {q2 } . -
q0 q4
(q2, E) = {q4 } c qU
(q,.) = {q2} b E B
(q, b) = {q } q c
(q, E) = {q4 } q6
(q4,-) = {q5 } b
(q4,+) = {q5 } c
(q4,c) = {q6 }
(q5,c) = {q6 }
(q6,c) = {q6 }
(q6, B) = {qU }
F = {qU }
c‘ '
   
        
*     *      ( 
   
     *
  
 ,    ,    
 &
(, ) !   (  ,  ) ! 8 

12
-?    
   (       &

i trare

 Next, i





 Completarea
ùù DA vectoruluisi tactic
AF pe tru
+ separator NU

 ERROR ± illegal separator

Cautarea dupa TN,


0,1 DA Completarea vect.Si t şi Sem.
AF pe tru
. umere NU
ERROR ± illegal bit umber

alt ERROR ± u k ow symbol


simbol

EOF
Iesire

./      &



şirul de i trare 1:01101B _ + _ _ 101.11B _ + 0111E -54B _ + _ 001.010B

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

1
-ectorul 2 1  1 4 1 
si tactic
-ectorul 1 1 1 2
sema tic

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

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

-ectorul  1 4 1 4 1  1 2
si tactic
-ectorul 1 1 2 2 1
sema tic

şirul de i trare : .011101B _ + 110001B + 000100B + _ 1.001EU1B _ _ + 01011B + _ _ _ 101.B

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

-ectorul  1 2 1 2 1 4 1 4 1 
si tactic
-ectorul 1 1 2 1  2
sema tic

şirul de i trare4: 011.10001E+15B _ + 001.001B + _ 010B + 101E -55

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

-ectorul 4 1  1 2 1 4
si tactic
-ectorul i 1 p 1 1f 2
sema tic

şirul de i trare 5: 110.01E22B _ _ + _ _ _ 010.111E -B _ + _ _ _ 1001.001B _ + 1010E12B _ + _


0111.111B

14
1 1001.001B 110.01E22B
2 0111.111B 010.111E-B
 1010E12B

-ectorul 4 1 4 1  1 4 1 
si tactic
-ectorul 1 2 1  2
sema tic

/      &

şirul de i trare 6: 1001.B _ _ + _ + _ .011E4B _ _ + _ 101EB + _ 210B


ERROR(1) ± illegal separator(µ_ _ + _ + _¶)
ERROR(2) ± illegal bit umber(µ101EB¶)
ERROR() ± u k ow symbol (µ210B¶)

i p f
1 1001.B .011E4B

-ectorul  -1 4 1 -1 1 -1
si tactic
-ectorul 1 1
sema tic

şirul de i trare U: 110.01.1B _ + 110.01B + 11021B + _ + _ 01.E+ -24B _ + 11B


ERROR(1) ± illegal bit umber (µ110.01.1B¶)
ERROR(2) ± illegal bit umber (µ11021B¶)
ERROR() ± illegal separator (µ+ _ + _¶)
ERROR(4) ± illegal bit umber (¶01.E+-24B¶)

i p f
1 11B 110.01B

-ectorul -1 1  1 -1 -1 -1 1 2
si tactic
-ectorul 1 1
sema tic

şirul de i trare 8: 101.011E-24UB _ + _ .11101E1AB + _ _ + 110B _ _ _ + . _ + U1011BE


ERROR(1) ± illegal bit umber (µ .11101E1AB¶)
ERROR(2) ± illegal separator (µ+ _ _ +¶)
ERROR() ± illegal bit umber (µ . ¶)
ERROR(4) ± u k ow symbol (µU1011BE¶)

i p f
1 110B 101.011E-24UB
15
-ectorul 4 1 -1 -1 2 1 -1 1 -1
si tactic
-ectorul 1 1
sema tic

  


   &
#i clude<stdio.h>
#i clude<co io.h>
#i clude<stri g.h>
i t co trol(char *q)
{ i t k=0;
i t e=0;
i t gf=0;
for(i t i=0;i<strle (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=; break; }
if (q[i]=='.')
{ k++; break; }
if (k==2)
{gf=2; break; }
if (q[i]=='A')
{ gf=4; break;}
}
retur gf;
}
i t f1(char *s,i t *q)
{ i t i;
i t j=0;
i t k=1;
i t h=0;
char w[20];
for (i=0;i<strle (s);i++)
{

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

if (q[j-1]==1)
{ q[j++]=-1;
pri tf("\ ERROR:illegal separator\ "); }
else
q[j++]=1;

else
if (s[i]!='_')
w[h++]=s[i];
if ((s[i]=='B')||(s[i]=='\0'))
{
w[h]='\0';
16
h=0;
i t e=0;
 puts(w);
 verificam daca u este gresit ceva
k=1;
if (co trol(w)!=0)
{ q[j++];co ti ue; }
for (i t f=0;f<strle (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

retur j;

}
void f2(i t *q,i t )
{
i t l[5]={0,0,0,0};
pri tf("\ ");
for (i t i=0;i< ;i++)
if (q[i]<2){ pri tf(" "); co ti ue; }
else
{ l[q[i]]+=1;

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

}
}
void mai ()
{ 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("I troduceti u sir:");
gets(s);

i t q[10];
i t =f1(s,q);
pri tf("\ -ectorul si tactic\ ");
1U
for (i t i=0;i< ;i++)
pri tf(" %d",q[i]);
pri tf("\ -ectorul sema tic\ ");
f2(q, );
getch();

    
   &

I troducem u sir corect

I troducem u sir gresit:

18







  &

Efectui d acest proiect de curs am studiat si am aplicat i practica otiu i, defi itii, si teh ici
ecesare pe tru proiectarea u ui a alizator lexical. Pe tru fiecare tip de lexemă am co struit cite u
automat fi it.
Am co struit schema de lucru a u ui a alizator lexical. Am elaborat u program pe tru
a alizatorul lexical dat, acesta reprezi ti d de fapt proiectarea u ui mic tip de compilator, dupa care am
testat lucrul acestuia pe tru siruri corecte si i corecte cu erorile descrise.Astfel am î tărit co oşti ele î
ceea ce priveşte programarea limbajelor formale.

!
  0     1&

1.‘ V  ɩɨ ɨɧɫɬɪɭɪɨɜɚɧ ɨɦɩɬɨɪɨɜ (ɪɭɫ.)


http:www.code et.ruprogrcompilco s001.php

2.‘ Ⱥɯɨ Ⱥ., ɍɦɚɧ Ⱦɠ. Ɍ ɨɪ ɫɧɬɚɫ ɫɨɝɨ ɚɧɚ ɚ, ɩ ɪ ɜɨɞɚ  ɨɦɩ. Ɍ. 1:
ɋɧɬɚɫ ɫ
ɚɧɚ . Ɇ.: Ɇɪ, 19U8. -- 612 ɫ.

.‘ Iri a Atha asiu Äë  

4.‘ Ciclu de prelegeri citit la facultate la discipli a ³L.F.P.C´.

19