LABORATORAREA COMPILATOARELOR

UNIVERSITATEA DIN CRAIOVA

FACULTATEA DE AUTOMATICA, CALCULATOARE SI ELECTRONICA

LABORATOR

PROIECTAREA COMPILATOARELOR

Laborator nr.1

Enunt:

Sa se implementeze un analizor lexical pentru urmatoarele simboluri de baza:

-identificatori ;

-constante sir ;

-cuvintele cheie 'switch' , 'default' si 'case';

-caracterele speciale '+', ':';

-secventele de caractere speciale '++' si '<>';

Implementare:

Continutul fisierelor header:

L1.h:

#pragma once

#include 'resource.h'

#include <stdio.h>

#include <string>

using namespace std;

typedef enum

TCod_t;

Pos.h

#pragma once

#include 'L1.h'

class CPos

Scanner.h

#pragma once

#include <iostream>

#include <fstream>

using namespace std;

#include 'Token.h'

class CScanner

Token.h

#pragma once

#include 'pos.h'

class CToken

Continutul fisierelor sursa:

L1.cpp

// L1.cpp : Defines the entry point for the console application.

#include 'stdafx.h'

#include 'L1.h'

#include 'Scanner.h'

#ifdef _DEBUG

#define new DEBUG_NEW

#endif

// The one and only application object

CWinApp theApp;

using namespace std;

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])

else

}

}

system('pause');

return nRetCode;

//Clasa cu informatii legate de pozitia unui atribut in fisierul de intrare

Pos.cpp

#include 'Pos.h'

CPos::CPos()

CPos::~CPos()

//clasa pentru analiza lexicala

Scanner.cpp

#include 'Scanner.h'

#include <iostream>

using namespace std;

CScanner::CScanner(char filename[200])

strcpy(name,filename);

ch = 0;

CScanner::~CScanner(void)

/* metoda care face analiza lexicala */

CToken CScanner::NextToken(void)

if (('n' == ch) || ('r' == ch))

if ('t' == ch)

c = (c/8 + 1) * 8; //eleimina tab de 8 spatii

ch = tape.get();

//printf('_%c_n',ch);

};

token.position.column = c;

c++;

token.atribut += ch;

/* verifica daca este identificator */

if (isalpha(ch) || ( == ch))

if ((!isalnum(ch)) && (!( == ch)))

/* verifica daca e cuvantul cheie switch */

if (token.atribut == 'switch')

else

if (token.atribut == 'default')

else /* verifica daca e cuvantul cheie case */

if (token.atribut == 'case')

else

}

else

/* verifica daca e constanta sir */

if (ch == )

token.atribut += ch;

if ( == ch)

}

else

/* verifica daca este : */

if (ch == )

else

/* verifica daca este plus */

if (ch == )

else

//token.position.column = c;

//c = ReadCh(c);

ok = true;

}

else

/* verifica daca este < */

if ('<' == ch)

else

ok = true;

}

if (!ok)

else

/* citeste un caracter din fisier si elimina spatiile albe */

int CScanner::ReadCh(int c)

if (('t' == ch))

return c;

//clasa cu informatii despre simbolul analizat

Token.cpp

#include 'Token.h'

CToken::CToken(void)

CToken::~CToken(void)

Laborator nr.2

Enunt:

Sa se implementeze un analizor sintactic descendent cu reveniri pentru gramatica de mai jos:

*S->'b' | 'a'A | 'd'B.

A->'a'A B | 'b'C'c' | 'd'C'a'.

B-> B A C | 'b''d' | 'c''c'|'a'D.

C-> 'a' | 'b' | 'c'.

D-> 'a'|'b'.

Implementare:

Continutul fisierului header:

Head.h:

#ifndef __head__

#define __head__

#include <stdio.h>

#include <string.h>

#include <conio.h>

class AnaSin

#endif

Continutul fisierelor sursa:

Tema2.cpp:

//constructorul clasei

AnaSin::AnaSin()

AnaSin::~AnaSin()

void AnaSin::SetCuv(char *cuv)

int AnaSin::Analiza() //S->'b' | 'a'A | 'd'B

if(cuv[cCuv]=='a') //S->'a'A

cCuv=temp;

}

if(cuv[cCuv]=='d') //S->'d'B

cCuv=temp;

}

printf('nCuvant respins!');

getch();

return 0;

int AnaSin::A() //A->'a'A B | 'b'C'c' | 'd'C'a'.

if(cuv[cCuv]=='b')//A->'bC'c'

cCuv=temp;

}

if(cuv[cCuv]=='d')//A->'d C'a'

cCuv=temp;

}

return 0;

int AnaSin::B() //B-> B A C | 'b''d' | 'c''c'|'a'D.

if(cuv[cCuv]=='b')//B-> 'b''d'

cCuv=temp;

}

if(cuv[cCuv]=='c')//B-> 'c''c'

cCuv=temp;

}

if(cuv[cCuv]=='a')//B->'a'D

return 0;

int AnaSin::C()//C-> 'a' | 'b' | 'c'.

if(cuv[cCuv]=='b')//C-> 'b'

if(A())//C-> A

cCuv=temp;

if(cuv[cCuv]=='c')//C-> 'c'

return 0;

int AnaSin::D()//D-> 'a' | 'b' .

int temp=cCuv;

if(cuv[cCuv]=='a')//D-> 'a'

if(cuv[cCuv]=='b')//D-> 'b'

return 0;

main.cpp:

void main()

Laborator nr.3

Enunt:

Sa se implementeze un analizor sintactic descendent recursiv pentru gramatica de mai jos:

program 'b' lista_instructiuni 'e' .

lista_instructiuni instructiune || ';' .

instructiune 'r' lista_instructiuni 'u' expresie |

'b' lista_instructiuni 'e' .

'v' '=' expresie .

expresie termen || '+' .

termen 'c' | '(' expresie ')' .

Implementare:

Continutul fisierului header:

Analizor.h:

#pragma once

#include <fstream>

#include <iostream>

using namespace std ;

#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include<string.h>

#include 'CaractFisier.h'

class Analizor

CaractFisier.h

#pragma once

#include <fstream>

using namespace std;

#include <fstream>

#include <iostream>

using namespace std ;

#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include<string.h>

class CaractFisier

Continutul fisierelor sursa:

Analizor.cpp:

#include 'Analizor.h'

#include 'CaractFisier.h'

'bv=(c+c);v=ce'

'brv=cue"

'bbv=cee'

Analizor::Analizor()

Analizor::~Analizor(void)

void Analizor::Program(void)

else

}

else

void Analizor::ListaInstructiuni(void)

Instructiuni();

while (ch== )

void Analizor::Expresie(void)

else

*/

Termen();

while (ch== )

void Analizor::Termen(void)

else

}

else

void Analizor::Instructiuni(void)

else

}

else

else

}

else

else

}

else

}

CaractFisier.cpp:

#include 'stdafx.h'

#include 'CaractFisier.h'

CaractFisier::CaractFisier(void)

CaractFisier::~CaractFisier(void)

char CaractFisier::nextChar(void)

if (('n' == ch) || ('r' == ch))

if ('t' == ch)

col = (col/8 + 1) * 8;

ch = tape.get();

};

col++;

//printf('%c',ch);

return ch;

cristina.txt:

"brbv=ceuce"

'bv=(c+c);v=ce'

'brv=cue"

'bbv=cee'

Laborator nr.4

Enunt:

Sa se implementeze un analizor sintactic dirijat de tabele pentru gramatica de mai jos:

program 'b' lista_instructiuni 'e' .

lista_instructiuni instructiune || ';' .

instructiune 'r' lista_instructiuni 'u' expresie |

'b' lista_instructiuni 'e' .

'v' '=' expresie .

expresie termen || '+' . termen 'c' | '(' expresie ')' .

Implementare:

Continutul fisierului header:

Analizor.h:

// Analizor.h: interface for the Analizor class.

#if !defined(AFX_ANALIZOR_H__D4367086_D352_4A81_832A_8614605B425F__INCLUDED_)

#define AFX_ANALIZOR_H__D4367086_D352_4A81_832A_8614605B425F__INCLUDED_

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

#include <stdio.h>

#include <string.h>

#define NrT 12;

#define NrNT 7;

class Analizor

void Push(int iX)

int Code(char ch);

char DeCode(int i);

char *Prod[11];

void init()

0 1 2 3 4 5 6 7 8 9 10 11

TA[7][12] = $ b e ; r u v = + c ( )

P 0 -1, 0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,

L 1 -1,-1,-1,-1, 1,-1, 1,-1,-1,-1,-1,-1,

A 2 3,-1, 3, 2,-1, 3,-1,-1,-1,-1,-1,-1, // e u

I 3 -1,-1,-1,-1, 4,-1, 5,-1,-1,-1,-1,-1,

E 4 -1,-1,-1,-1,-1,-1,-1,-1,-1, 6, 6,-1,

B 5 8,-1, 8, 8,-1, 8,-1,-1, 7,-1,-1, 8, // e ; u ) // u pt cazul BAu, unde A e lambda

T 6 -1,-1,-1,-1,-1,-1,-1,-1,-1, 9,10,-1,

for (int k=0; k<iNrNT; k++)

for (int j=0; j<iNrT; j++) TA[k][j]=-1;

TA[0][1]=0;

TA[1][4]=1; TA[1][6]=1;

TA[2][0]=3; TA[2][2]=3; TA[2][3]=2; TA[2][5]=3;

TA[3][4]=4; TA[3][6]=5;

TA[4][9]=6; TA[4][10]=6;

TA[5][0]=8; TA[5][2]=8; TA[5][3]=8; TA[5][5]=8; TA[5][8]=7; TA[5][11]=8;

TA[6][9]=9; TA[6][10]=10;

Prod[0]='bLe';

Prod[1]='IA';

Prod[2]=';IA';Prod[3]= ;

Prod[4]='rLuE'; Prod[5]='v=E';

Prod[6]='TB';

Prod[7]='+TB'; Prod[8]= ;

Prod[9]='c'; Prod[10]='(E)';

}

public

Analizor();

void Analiza(char* cuv);

virtual ~Analizor();

#endif // !defined(AFX_ANALIZOR_H__D4367086_D352_4A81_832A_8614605B425F__INCLUDED_)

Continutul fisierelor sursa:

Analizor.cpp:

// Analizor.cpp: implementation of the Analizor class.

#include 'Analizor.h'

#include <string.h>

#include <stdio.h>

// Construction/Destruction

Analizor::Analizor()

Analizor::~Analizor()

void Analizor::Analiza(char *cuv)

}

else

bErr=1; // varful stivei nu este identic cu caracterul urmator

else

else

bErr=1;

}

}

if(bErr||(strlen(cuv)!=iPos))

printf('nCuvant incorect!n');

else

printf('nCuvant corect!n');

int Analizor::Code(char ch)

return _ERR;

char Analizor::DeCode(int i)

return ;

Main.cpp:

#include 'Analizor.h'

void main(void)

Verificare:

Dati cuvantul : bv=ce

Bag $

Stiva este: $

Bag P

Stiva este: P $

Scot P

Stiva este: $

Bag e

Stiva este: e $

Bag L

Stiva este: L e $

Bag b

Stiva este: b L e $

Scot b

Stiva este: L e $

Sirul de intrare este: v=ce

Scot L

Stiva este: e $

Bag A

Stiva este: A e $

Bag I

Stiva este: I A e $

Scot I

Stiva este: A e $

Bag E

Stiva este: E A e $

Bag =

Stiva este: = E A e $

Bag v

Stiva este: v = E A e $

Scot v

Stiva este: = E A e $

Sirul de intrare este: =ce

Scot =

Stiva este: E A e $

Sirul de intrare este: ce

Scot E

Stiva este: A e $

Bag B

Stiva este: B A e $

Bag T

Stiva este: T B A e $

Scot T

Stiva este: B A e $

Bag c

Stiva este: c B A e $

Scot c

Stiva este: B A e $

Sirul de intrare este: e

Scot B

Stiva este: A e $

Scot A

Stiva este: e $

Scot e

Stiva este: $

Cuvant corect!

Press any key to continue . . .

Laborator nr.5

Enunt:

Sa se implementeze un analizor sintactic descendent recursiv cu recuperarea erorilor pentru gramatica de mai jos:

program 'b' lista_instructiuni 'e' .

lista_instructiuni instructiune || ';' .

instructiune 'r' lista_instructiuni 'u' expresie |

'b' lista_instructiuni 'e' .

'v' '=' expresie .

expresie termen || '+' .

termen 'c' | '(' expresie ')' .

Implementare:

Continutul fisierului header:

AnalizorErori.h

#pragma once

#include <fstream>

#include <iostream>

using namespace std ;

#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include <string.h>

#include 'Fisier.h'

class AnalizorErori

Fisier.h

#pragma once

#include <fstream>

using namespace std;

#include <fstream>

#include <iostream>

using namespace std ;

#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include<string.h>

class ChFis

Continutul fisierelor sursa:

AnalizorErori.h

#include 'AnalizorErori.h'

#include 'Fisier.h'

AnalizorErori::AnalizorErori(void)

AnalizorErori::~AnalizorErori(void)

/* Functia pentru program

program -> 'b' lista_instructiuni 'e' */

void AnalizorErori:: P(char *sSymbols)

else

cout<<'n Atentie ! Eroare : Pe Linia '<<ob->Linie<<' si Coloana '<<ob->Coloana<<' Trebuia Sa Se Afle 'b' '<<endl;

sprintf(sTemp,'e%s',sSymbols);

L(sTemp);

if(Caracter=='e') Caracter=ob->nextChar();

else

cout<<'n Atentie ! Eroare : Pe Linia '<<ob->Linie<<' si Coloana '<<ob->Coloana<<' Trebuia Sa Se Afle 'e' '<<endl;

/* Functia pentru 'lista_instructiuni'

lista_instructiuni -> instructiune || ';' . */

void AnalizorErori::L(char * sSymbols)

/* Functia pentru 'expresie'

expresie -> termen || '+' . */

void AnalizorErori:: E(char * sSymbols)

/* Functia pentru 'termen'

termen -> 'c' | '(' expresie ')'. */

void AnalizorErori::T(char * sSymbols)

/* Functia pentru 'instructiune'

instructiune -> 'r' lista_instructiuni 'u' expresie |

'b' lista_instructiuni 'e' |

'v' '=' expresie .

*/

void AnalizorErori::I(char * sSymbols)

if(Caracter=='b')

if(Caracter=='v')

// Functia care raporteaza erorile

void AnalizorErori::Eroare(int Cod_Eroare, char cSymbol)

// // Functia pentru TEST

void AnalizorErori::TEST(int Cod_Eroare,char * sSymbols)

Fisier.cpp

#include 'Fisier.h'

ChFis::ChFis(void)

/* Se elimina spatiile, ENTER-ul si TAB-ul */

ChFis::~ChFis(void)

char ChFis::nextChar(void)

if (('n' == Caracter) || ('r' == Caracter))

if ('t' == Caracter)

Coloana = (Coloana/8 + 1) * 8;

Caracter = tape.get();

};

Coloana++;

return Caracter;

Main.cpp

#include 'AnalizorErori.h'

int main(int argc, char* argv[])

Laborator nr.6

Enunt:

Sa se scrie folosind abstractizarea datelor un modul de program care implementeaza o tabela de simboluri folosind o tabela de dispersie la care rezolvarea coliziunilor se face prin redispersarea patratica.

Implementare:

Continutul fisierului header:

Tabela.h:

#pragma once

#include<stdio.h>

#include<conio.h>

#include<string.h>

#include<stdlib.h>

#include<math.h>

#define N 29

class Informatie;

class Tabela

void Adauga(char simbol[],char tip[]);

bool Cauta(char simbol[]);

bool DetermAtrib(char tip[],char simbol[]);//dau gi => intreg

void SeteazaAtrib(char simbol[],char tip[]);//caut gi si modif tipul

void Afiseaza();

Continutul fisierelor sursa:

Tabela.cpp:

#include 'StdAfx.h'

#include 'Tabela.h'

Tabela::Tabela()

int Tabela::FDispersie(char simbol[])

bool Tabela::Verifica(char simbol[],double i)

void Tabela::Adauga(char simbol[],char tip[])

bool Tabela::Cauta(char simbol[])

bool Tabela::DetermAtrib(char tip[],char simbol[])

return 0; // printf('Nu am gasit simbolul /n');

void Tabela::SeteazaAtrib(char simbol[],char tip[])

void Tabela::Afiseaza()

tema6.cpp:

#include 'stdafx.h'

#include 'Tabela.h'

int _tmain(int argc, _TCHAR* argv[])

break;

case :

break;

case :

break;

case :

break;

case :

break;

case :

break;

}

}while(ch!= );

return 0;

Laborator nr.7

Enunt:

Sa se implementeze schema de traducere care realizeaza traducerea expresiilor aritmetice uzuale din forma prefixata in forma infixata.

Implementare:

Continutul fisierului sursa:

L7.cpp:

Expresie -> operator Expresie Expresie | operand.

operator -> +, -, *, /.

operand -> a..z, A..Z.

#define debug(str, ch) // printf(' Making %s = '%c'n', str, ch)

#include <stdio.h>

#include <string.h>

#include <ctype.h>

#include <stdlib.h>

#include <conio.h>

typedef struct tree_node node;

typedef node* tree;

static char prefix_expr[100];

static char* pexpr;

tree MakeExpressionTree( void);

void PrintTree( tree );

void main( void)

else

puts( 'nError in prefix expression.');

getch();

}

tree MakeExpressionTree( void)

else

if ((ch == '+') || (ch == '-') || (ch == '*') || (ch == '/'))

else

}

else

return NULL;

}

void PrintTree( tree p)

else

}

}

/* End Of File luc_pc_7.c */

Exemplu:

Forma prefixata

*+a/bc-d*ef

forma infixata

(a+b/c)*(d-e*f)

Laborator nr.8

Enunt:

Sa se implementeze un analizor sintactic descendent recursiv pentru gramatica de mai jos:

program 'begin' lista_instructiuni 'end' .

lista_instructiuni instructiune || ';' .

instructiune 'repeat' lista_instructiuni 'until' expresie |

'begin' lista_instructiuni 'end' .

'v' '=' expresie .

Implementare:

Continutul fisierului header

Header.h:

#include <stdio.h>

#include <stdlib.h>

#include <iostream>

#include <fstream>

#include <ctype.h>

using namespace std;

class Triplet;

class Analizor;

Continutul fisierelor sursa:

Header.cpp:

#include 'header.h'

Analizor::Analizor()

Analizor::~Analizor()

void Analizor::citeste()

int Analizor::executa()

int Analizor::ListaInstructiuni()

return begin;

}

int Analizor::Instructiune()

else if(ch=='b')

else if(ch=='v')

else Eroare(1,'Eroare in instructiune(): Trebuie r, b sau vn');

}

int Analizor::Expresie()

return t1;

}

int Analizor::Termen()

else if(ch=='(')

else Eroare(1,'Eroare in termen(): Trebuie ( sau cn');

return t1;

}

int Analizor::GenTrip(int cod_op,int cod_arg1,int cod_arg2)

void Analizor::Eroare(int grad,char m[100])

8.cpp:

#include 'header.h'

Analizor an;

void main(void)

cout << '--------|-------|--------' << endl << 'Operand |Op 1t|Op 2t' << endl << '--------|-------|--------' << endl;

for (i=0;i<=an.intTab;i++)

cout << (char)an.triplet[i].op << 't|' <<(char) an.triplet[i].arg1 << 't|' << (char)an.triplet[i].arg2 << endl;

int ii;

//cin>>ii;

cout <<endl;

cout << '--------|-------|--------' << endl << 'Operand |Op 1t|Op 2t' << endl << '--------|-------|--------' << endl;

for (i=0;i<=an.intTab;i++)

cout << an.triplet[i].op << 't|' << an.triplet[i].arg1 << 't|' << an.triplet[i].arg2 << endl;

//int ii;

cin>>ii;

system('pause');

continutul fisierului in: bv=c+ce