1. Sa se scrie analizorul sintactic pentru urmatoarea gramatica:

 
propozitii: propozitii propozitie
propozitie: ( subiectSimplu ARE | subiectCompus AU ) numar .
subiectSimplu: ID
subiectCompus: ID (, subiectCompus | epsilon)
numar: INT LEI ( SI INT BANI | epsilon ) | INT BANI

1. Write the parser for the following grammar:

sentences: sentences sentence

sentence: (subjectSimple ARE | subjectComposed AU) number.
subjectSimple: ID
subjectCompus: ID (, subjectCompus | epsilon)
number: INT LEI (SI INT MONEY | epsilon) | YOU HAVE MONEY

Please I need the source code

 
 

2. Sa se scrie analizorul lexical care valideaza persoane cu nume corespunzatoare urmatorului format:

PERSOANA: NUME SPATIU PRENUME

NUME: LITERA_MARE LITERA_MICA+
PRENUME: LITERA_MARE LITERA_MICA+ ( ( MINUS LITERA_MARE LITERA_MICA+ ) | epsilon )

 Lexical Analyzer
%{
#include<stdio.h>
int valid=0;
%}
%%
[A-Z][a-z]+[\t][A-Z][a-z]+{valid=1;}
%%
int main(void)
{
yylex();
if(valid==1)
{
printf("Name is valid");
}
else
{
printf("Name is invalid");
}
}

3. Sa se scrie analizorul sintactic pentru urmatoarea gramatica:

 
clasa: CLASS ID {   listaDecl   }
decl: declVar | declFunc
listaDecl: listaDecl decl | epsilon
declVar: ID ID
declFunc: ID ID ( argumente )
argumente: declVar ( , argumente | epsilon ) | epsilon

Write the parser for the following grammar:

class: CLASS ID {listDecl}

decl: declVar | declFunc
Decllist: Decl list decl | epsilon
declVar: ID ID
declFunc: ID ID (arguments)
arguments: declVar (, arguments | epsilon) | epsilon

Please I need the source code

4. Sa se realizeze analizorul lexical pentru gramatica de mai jos:

LITERA ::= a..z | A..Z

DIGIT ::= 0..9
ID ::= LITERA ( LITERA | DIGIT )*
REAL ::= DIGIT+ [ . DIGIT+ ]

4. Make the lexical analyzer for the grammar below:

LETTER :: = a..z | A..Z
DIGIT :: = 0..9
ID :: = LITER (LITER | DIGIT) *
REAL :: = DIGIT + [. DIGIT +]
Please I need the source code
5. Sa se realizeze analizorul sintactic pentru gramatica de mai jos. Analizorul lexical se considera
cunoscut. Componentele scrise ingrosat sunct considerati atomi lexicali.

tesut: celule fibre| tesut

celule: (celula)+
celula: ADN ARN

. Make the grammar parser for the grammar below. The lexical analyzer is considered known. The
components written in bold are considered
woven: cell fiber| woven
cells: (cell)+
cell: ADN ARN
Please I need the source code

Ans : There are 12 tokens

fiber, cells , | , woven , cell , cell ,( , ) , +, cell , ADN , ARN

there are 2 lexical atoms.

ADN , ARN

There are twelve tokens available.

cells ,fiber, | , woven , cell , cell ,( , ) , +, cell , ADN , ARN

There are two lexical atoms present. ADN , ARN

6. Realizati un analizor sintactic pentru urmatoarea gramatica ok

<lista_ramuri> -> <ramura>|<lista_ramuri> <ramura>
<ramura> -> <lista_val> : <instr> ;
<lista_val> -> <constanta> , <lista_val>|<constanta>
<constanta> -> <constanta_num>|<constanta_car>
<constanta_car> -> litera
<const_num> -> <nr_intreg>|<nr_real>
<nr_intreg> -> <nrBaza10>|<baza>@ cifra

 Deoarece in cazul: <lista_ramuri> =  <ramura>|<lista_ramuri> <ramura>, exista recursivitate la

stanga, aceasta trebuie eliminata prin introducerea unui neterminal nou:

<lista_ramuri> =  <ramura> <lista_ramuri_prim>

<lista_ramuri_prim> = epsilon| ; <ramura> <lista_ramuri_prim>

void error(int error_code); /* raporteaza eroare */

void lista_ramuri(void);
void lista_ramuri_prim(void);
void ramura(void);
void lista_val(void);
void constanta(void);
 void constanta_car(void);
void const_num(void);
void nr_intreg(void);

void get_next_lex(void); /* citeste urmatorul element lexical */

COD_LEXICAL codLex; /* elementul lexical citit */
int main()
{
get_next_lex();
lista_ramuri();
return 0;
}

void lista_ramuri()
{
ramura();
lista_ramuri_prim();
}

void ramura()
{
lista_val();

get_next_lex();
if( codLex != ':' )
{
error(1); /* se astepta " : " */
return;
}

get_next_lex();
instr(); /* verifica daca e instructiune */
 get_next_lex();
if( codLex != ';')
{
error(2); /* se astepta " ; " */
return;
}
}

void lista_ramuri_prim()
{
get_next_lex();

ramura();
lista_ramuri_prim();
}

void lista_val()
{
get_next_lex();
constanta();

get_next_lex();
if(codLex != ',')
{
error(3); /* se astepta " , " */
return;
}

lista_val();
}

void constanta()
{
const_num();
constanta_car();
}
void const_num()
{
nr_intreg();
nr_real();
}
void constanta_car
{
get_next_lex();

if(((codLex <= 'a') || (codLex >= 'z') ) && ((codLex <= 'A') || (codLex >= 'Z')))
{
error(4); /* se astepta un caracter */
return;
}
}
void nr_intreg()
{
get_next_lex();

if((codLex < 0)||(codLex > 9))

{
error(5); /* se astepta un numar */
return;
}
}

Analizorul sintactic obtinut:

7. Assignment 1 Se cere analizorul sintactic pentru urmatoarea gramatica:
Fisier= fisier (linie | epsilon)
Linie=(ID (lista_param | epsilon) | epsilon) NL
Lista_param = param (, lista_param | epsilon)
Param=( ID | F) (param | epsilon)

Struct atom {
string nume;
int categorie; // categorie lexicala
int cod;
}a;
atom *a;
// fisier=fisier (linie | epsilon)
//
// apare recursivitatea de stanga => introducem un neterminal nou si rescriem gramatica
// fisier=fisier (linie | epsilon) devine
//
// fisier = (linie | epsilon) fisierprim
// fisierprim = fisierprim | epsilon
int fisier(){
if(linie()){
a=a->next;
if(fisierprim()){
a=a->next;
return 1;
}else{
printf("Fisierprim invalid");
exit(0);
}
elseif(!linie()){
printf("Linie incorecta");
exit(0);
}
else{
if(fisierprim()){
a=a->next;
return 1;
}
} //pentru linie | epsilon
}
2
int fisier(){
if(linie()){
a=a->next;
if(fisierprim()){
a=a->next;
return 1;
}elseif(!linie()){
printf("Fisierprim invalid");
exit(0);
}
a=a->next;
return 1; //pentru epsilon
}
int fisierprim(){
if(fisierprim()){
a=a->next;
return 1;
}
elseif(!fisierprim())
printf("Fisierprim invalid");
exit(0);
else{
a=a->next;
return 1; //pentru epsilon
}
}
// linie=(ID (lista_param | epsilon) | epsilon) NL
int linie(){
if(strcmp(a->categorie, "ID") == 0){
a=a->next;
if(lista_param()){
a=a->next;
if(strcmp((a->nume), "NL")==0){
a=a->next;
return 1;
}
}elseif(!lista_param()){
printf("Lista de parametri incorecta");
exit(0);
}elseif(strcmp((a->nume), "NL")==0){
a=a->next;
return 1;
} //pentru lista_param | epsilon
}elseif(strcmp(a->categorie, "ID") != 0){
printf("ID incorect");
exit(0);
}elseif(strcmp((a->nume), "NL")==0){
a=a->next;
return 1;
} //pentru lista_param | epsilon //pentru ID | epsilon
}
3
// lista_param=param (, lista_param | epsilon)
int lista_param(){
if(param()){
a=a->next;
if(strcmp(a->nume, ",") == 0){
a=a->next;
return 1;
}
elseif(strcmp(a->nume, ",") != 0)
printf("Lipseste ,");
exit(0);
else{
a=a->next;
return 1; //pentru , lista_param | epsilon
}
}else{
printf("Eroare la parametru!");
exit(0);
}
}
// param=(ID | F) (param | epsilon)
int param(){
if((strcmp(a->categorie, "ID") == 0) || (strcmp(a->categorie, "F") == 0)){
a=a->next;
if(param()){
a=a->next;
return 1;
}
elseif(param()!=1){
printf("Parametru incorect\n");
exit(0);
}
else{
a=a->next;
return 1; //pentru (param | epsilon)
}else{
printf("ID sau F lipsa\n");
exit(0);
}
}

8. Assignment 3 Să se scrie un analizor sintactic corespunzător gramaticii de mai jos:

<declaratii>::=<declaratie>|<declaratii> ; <declaratie>
<declaratie>::= ID (<stars>|epsilon) ID ([INT] | ( <args>|epsilon) )
<stars>::=STAR|STAR <stars>
<args>::=<arg>|<arg> , <args>
<arg>::= ID (<stars>|epsilon) ID

Observații: ID, INT si STAR sunt atomi lexicali. Toate celelalte caractere care sunt îngroșate reprezintă
de asemenea atomi lexicali. Analizorul lexical pentru această gramatică se consideră deja
implementat.
enum CODURI_LEXICALE { NEDEF, ID, INT, STAR, VIRGULA, PVIRGULA,
PSTANGA, PDREAPTA };

CODURI_LEXICALE ultim; //ultimul cod lexical citit

void init_lex(void); //initializeaza analizorul lexical

void lex(void); //citeste un nou cod lexical

void eroare(int cod); //semnaleaza o eroare

void declaratii(void);

void declaratii_prim(void);

void declaratie(void);

void stars(void);

void args(void);

void arg(void);

int main()

init_lex();

lex();
 declaratii();

void declaratii(void)

declaratie();

declaratii_prim();

void declaratii_prim(void)

if (ultim == PVIRGULA)

lex();

declaratie();

declaratii_prim();

void declaratie(void)

if (ultim != ID)

eroare(1); //se astepta la ID

return;

lex();

if (ultim != PSTANGA)
{

eroare(2); //se astepta la (

return;

lex();

if (ultim != PDREAPTA)

stars();

if (ultim != PDREAPTA)

eroare(3); //se astepta la )

return;

lex();

if (ultim != ID)

eroare(1); //se astepta la ID

return;

lex();

if (ultim != PSTANGA)

eroare(2); //se astepta la (

return;
}

lex();

if (ultim == PDREAPTA)

lex();

return;

if (ultim == INT)

else

if (ultim != PSTANGA)

eroare(2); //se astepta la (

return;

lex();

if (ultim != PDREAPTA)

args();

if (ultim != PDREAPTA)

eroare(3); //se astepta la )

 return;

lex();

if (ultim != PDREAPTA)

eroare(3); //se astepta la )

return;

void stars(void)

if (ultim != STAR)

eroare(4); //se astepta la STAR

return;

lex();

if (ultim == STAR)

stars();

void args(void)

{
 arg();

if (ultim == VIRGULA)

args();

void arg(void)

if (ultim != ID)

eroare(1); //se astepta la ID

return;

lex();

if (ultim != PSTANGA)

eroare(2); //se astepta la (

return;

lex();

if (ultim != PDREAPTA)

stars();

if (ultim != PDREAPTA)
 {

eroare(3); //se astepta la )

return;

lex();

if (ultim != ID)

eroare(1); //se astepta la ID return;

lex();
}

Assignment 4 9. Se cere să se scrie un analizor sintactic pentru gramatica de mai jos.

<source_file> ::= <declarations> <code>

<declarations> ::= vars <list_of_variables> ;
<list_of_variables> ::= <variable> | <list_of_variables> , <variable>
<code> ::= <statements> .
<statements> ::= <assignment> | <statements> ; <assignment>
<assignment> ::= <variable> := <expression>
<expression> ::= <expression> + <term> | <expression> - <term> | <term>
<term> ::= <term> * <factor> | <term> / <factor> | <factor>
<factor> ::= <number> | <variable>

Analizorul lexical pentru aceasta gramatica se presupene deja implementat.

Atom a; //structura care continue atomii dfiniti de analizorul lexical

int source_file()
{
if(declarations())
{
a = getNextAtom();
if(code())
{
return 1;
}
else error "Lipseste codul";
}
else error "Lipsesc declaratiile";
}

int declarations()
{
if(strcmp(a->name, "vars"))
{
a = getNextAtom();
if(list_of_varibles())
{
a = getNextAtom();
if(strcmp(a->name, ";"))
{
return 1;
}
else error "Lipseste ;";
}
else error "Lipseste lista de variabile";
}
else error "Lipseste vars";
}

int list_of_variables()
{
if(strcmp(a->category, “variable”))
{
return 1; // s-a considerat interpretarea (<variable>) | (<list_of_variables> ,
<variable>)
 }
else if (list_of_variables())
{
a = getNextAtom();
if (strcmp(a->name, ","))
{
a = getNextAtom();
if (a->category, “variable”)
{
return 1 ;
}
else error "Lipseste variabila";
}
else error "Lipseste ,";
}
else error "Lipseste variabila sau lista de_variabile";
}
}

int code ()
{
if(statements ())
{
a=getNextAtom();
if(strcmp(a->name, "."))
{
return 1;
}
else error "Lipseste .";
}
else error "Lipseste code ";
}

int statements()
{
if((assignment())
{
return 1; // s-a considerat interpretarea (<assignment>) | (<statements> ;
<assignment>)
}
else if (statements())
 {
a = getNextAtom();
if (strcmp(a->name, ";"))
{
a = getNextAtom();
if(assignment())
{
return 1;
}
else error "Lipseste assignment";
}
else error "Lipseste ;";
}
else error "lipseste assignment sau statements";
}

int assignement()
{
if (strcmp(a->category, “variable”))
{
a = getNextAtom();
if (strcmp(a->name, ":"))
{
a = getNextAtom();
if (strcmp(a->name, "="))
{
a = getNextAtom();
if (expression())
{
return 1;
}
else error "Lipseste expression";
}
else error "Lipseste =";
}
else error "Lipseste :";
}
else error "Lipseste variable";
}

int expression()
{
if (expression())
{
a = getNextAtom();
if ((strcmp(a->name, "+")) || (strcmp(a->name, "-")))
{
a = getNextAtom();
if (term())
{
return 1;
}
else error "Lipseste term";
}
else error "Lipseste + sau -";
}
else
{
if(term())
{
return 1 ;
}
else error "Lipseste term sau expression";
}
}

int term()
{
if (term())
{
a = getNextAtom();
if ((strcmp(a->name, "*")) || (strcmp(a->name, "/")))
{
a = getNextAtom();
if (factor())
{
return 1;
}
else error " Lipseste factor";
}
else error "Lipseste * sau /";
}
 else
{
if(factor())
{
return 1 ;
}
else error "Lipseste factor sau term";
}
}

int factor()
{
if(strcmp(a->category, “number"))
{
return 1;
}
else
{
if (strcmp(a->category, “variable”))
{
return 1 ;
}
else error "Lipseste number sau variable";
}
}

In cazul in care <number> si <variable> sunt neterminale acesteaea se pot evalua similar pana la
cifra si litera.

10. Se cere analizorul sintactic pentru a citi un fisier de balante de plati Assignment 6

fisier=linie (fisier | epsilon) | epsilon

linie= ( cod (, (F (, op | epsilon) | # F) | epsilon) | F (, op | epsilon) | # F | epsilon ) NL
cod=cod -> ID | ID
op=(# | epsilon) F
cod=cod -> ID | ID
Se observa o recursivitate la stânga imediată, care trebuie eliminată, dupa metoda: A→Aαβ
⏐β ⇒
A→βA’
A’→αA’⏐ε
Vom introduce un neterminal nou, mărind numărul producțiilor:
cod = ID cod_prim
cod_prim= ->ID cod_prim | epsilon

Vom obține următorul analizator sintactic:

Linie – desfașurat după definitie

Linie – simplificat
PROGRAMUL:
//......................
enum ATOMI_LEXICALI {ID, NL, DIEZ, VIRGULA, SAGEATA, ALTUL};
void eroare(int error_code); // pentru raportarea erorilor
void fisier(void); //prelucreaza un fisier
void linie(void); // prelucreaza o linie
void cod(void); //prelucreaza un cod
void cod_prim(void); //v. mai sus – eliminarea recursivitatii la stanga
void op(void); // prelucreaza o plata
void citeste_atom(void); // citeste un atom lexical (joaca rol de ALEX)
ATOMI_LEXICALI atom_lexical; //tipul de atom lexical citit
int avem_erori=0; //aici tinem evidenta daca avem erori sau nu

int main()
{
citeste_atom(); //citeste un nou atom lexical
fisier(); //prelucrează fișierul
if (avem_erori==0)
printf ("Programul este corect dpdv. sintactic");
 return 0;
}
void fisier()
{
if (atom_lexical) //daca fisierul nu este gol
{
linie(); // prelucram linia
citeste_atom();
fisier();
}
} //end fisier

void linie()
{
if (atom_lexical ==NL) //daca e linie vida
return;
if (atom_lexical == ID) //daca avem cod (atom lexical ID)
{
cod(); //prelucreaza codul
citeste_atom(); //cautam o virgula sau un NL dupa cod
if (atom_lexical) //daca se citeste ceva
{
if (atom_lexical ==NL) //daca linia se termina dupa cod
return;
if (atom_lexical !=VIRGULA) //daca se citeste ceva care nu e virgula
{
eroare(4); // ar trebui sa urmeze o virgula
return;
}
citeste_atom(); // Daca am ajuns aici, s-a citit o virgula. Citim atomul de dupa virgula.
 if ((atom_lexical !=F) && (atom_lexical != DIEZ))
{
eroare(5); // dupa virgula trebuie sa urmeze F sau DIEZ
return;
}
}
}

if (atom_lexical == F) //daca avem o incasare (fie după virgulă, fie prima pe linie daca nu există cod)
{
citeste_atom();
if (atom_lexical) //daca se citeste ceva
{
if (atom_lexical==NL) //daca linia se termina dupa incasare
return;
if (atom_lexical !=VIRGULA) //daca se citeste ceva care nu e virgula
{
eroare(4); // ar trebui sa urmeze o virgula
return;
}
op(); // dacă am ajuns aici fără erori, atunci după virgulă ar trebui să urmeze o plată, pe
care o prelucrăm cu funcția op()
citeste_atom();
if ((atom_lexical) && (atom_lexical !=NL))
// daca mai există ceva in fisier după plată, ar trebui să urmeze pe o linie nouă
{
eroare(2); // se asteapta NL sau end of file după plată( deoarece e finalul liniei)
return;
}
}
 else if (atom_lexical == DIEZ) // F si #F nu pot coexista pe aceeași linie, deci #F e pe ramura de
else if si se ajunge la el doar daca nu am avut direct F dupa virgula
{
citeste_atom(); //aici ar trebui sa se citeasca un nr real
if(atom_lexical != F)
{
eroare(3); //se așteaptă nr. real după diez
return;
}
citeste_atom();
if ((atom_lexical) && (atom_lexical !=NL))
//daca mai exista ceva in fisier, ar trebui să urmeze pe o linie nouă
{
eroare(2); // ar trebui sa fie NL sau end of file la finalul unei linii
return;
}
}
} //end linie

void cod()
{
if (atom_lexical != ID)
{
eroare(1); // trebuia sa urmeze un ID
return;
}
citeste_atom(); //dacă nu există erori, trecem mai departe la atomul următor
cod_prim();
}
void cod_prim()
{
if (atom_lexical==SAGEATA)
{
citeste_atom();
if (atom_lexical != ID)
{
eroare(1); // Ar trebui sa urmeze un ID
return;
}
cod_prim(); //pot urma mai multe sub-coduri introduse prin săgeată, deci continuăm să
le căutăm după fiecare săgeată
}
}

void op()
{
citeste_atom();
if (atom_lexical == DIEZ) // daca incepe cu un diez, trecem la atomul urmator
citeste_atom();
if(atom_lexical != F) //ar trebui să urmeze un nr. real. Aici ajungem indiferent daca există diez
sau nu.
eroare(6); //plata ar trebui sa fie un nr real – dacă nu este, semnalăm eroarea
}

void eroare(int error_code); // pentru raportarea erorilor

{
avem_erori=1; //daca s-a ajuns aici, avem erori si punem variabila globala pe 1
switch (error_code) { //acestea sunt tipurile de erori pe care le-am putea intalni
case 1:
 printf ("Ar trebui sa urmeze un ID: sir de caractere si cifre care incep cu un
caracter.");
break;
case 2:
printf ("Ar trebui sa urmeze un NL la finalul liniei sau sa fie end of file.");
break;
case 3:
printf ("Ar trebui sa urmeze un nr real dupa DIEZ.");
break;
case 4:
printf ("Ar trebui sa urmeze o virgula.");
break;
case 5:
printf ("Dupa virgula ar trebui sa urmeze F sau DIEZ.");
break;
case 6:
printf ("Plata ar trebui sa fie un nr real.");
break;
}
}