PROVA 1 – COMPILADORES (CIC220)

Nome: Rafael Greca Vieira Matrícula: 2018000434

1)

estado := 0

while(1){

c := cadeia.proximo_caractere()

switch(estado){

case(0):

se(c=’0’):
cont:=0
c := cadeia.proximo_caractere()
se c = 1 ou c = 0 faça
cont++
senao se c==’$’ faça
estado = 1
break
senao
retorna “falhou”

se(c=’1’):
cont:=0
c := cadeia.proximo_caractere()
se c = 1 ou c = 0 faça
cont++
senao se c==’$’ faça
estado = 2
break
senao
retorna “falhou”

case(1):

se cont % 2 != 0 e cont > 4:

return cadeia, “ímpar”
senao:
return “Não foi reconhecida”

case(2):

se cont % 2 == 0 e cont > 4:

return cadeia, “par”
senao:
 return “Não foi reconhecida”

senao:
retornar “falhou”

2)

%{
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int total_palavras = 0;
int palavra_vogalvogal = 0;
int palavra_vogalcons = 0;
int palavra_consvogal = 0;
int palavra_conscons = 0;
%}

ALFABETO [a-zA-Z]
CONSOANTES [bBcCdDfFgGhHjJkKlLmMnNpPqQrRsStTvVwWxXyYzZ]
VOGAIS [aAeEiIoOuU]
VOGALVOGAL {VOGAIS}({ALFABETO})*{VOGAIS}
VOGALCONS {VOGAIS}({ALFABETO})*{CONSOANTES}
CONSVOGAL {CONSOANTES}({ALFABETO})*{VOGAIS}
CONSCONS {CONSOANTES}({ALFABETO})*{CONSOANTES}

%%

{VOGALVOGAL} {total_palavras++; palavra_vogalvogal++;}

{VOGALCONS} {total_palavras++; palavra_vogalcons++;}
{CONSVOGAL} {total_palavras++; palavra_consvogal++;}
{CONSCONS} {total_palavras++; palavra_conscons++;}

%%

int yywrap();

int main(){
yylex();
printf("Quantidade total de palavras: %d\n", total_palavras);
printf("Quantidade total de palavras que começam e terminam com vogal: %d\n",
palavra_vogalvogal);
printf("Quantidade total de palavras que começam e terminam com consoante: %d\n",
palavra_conscons);
printf("Quantidade total de palavras que começam com vogal e terminam com consoante: %d\n",
palavra_vogalcons);
printf("Quantidade total de palavras que começam com consoante e terminam com vogal: %d\n",
palavra_consvogal);
}

int yywrap(){
return 1;
}

3)

a)

Gramática G3:

Lexp → num | (Op Lexp-seq)

Op → + | - | *
Lexp-seq → Lexp-seq Lexp | Lexp
num → 0 | … | 9 | num0 | … | num9

Tratando a recursividade a esquerda:

Lexp-seq →Lexp Lexp-seq’

Lexp-seq’ → Lexp Lexp-seq’| ε

num → 0 num’ | … | 9 num’

num’ → 0num’ | … | 9num’ | ε

Gramática G3’ que agora é LL(1):

Lexp → num | (Op Lexp-seq)

Op → + | - | *
Lexp-seq →Lexp Lexp-seq’
Lexp-seq’ → Lexp Lexp-seq’| ε
num → 0 num’ | … | 9 num’
num’ → 0 num’ | … | 9 num’ | ε

b)

int Lexpseq();
void LexpseqLinha();
int Lexp();
int num();
void numLinha();

void LexpseqLinha(){
Lexpseq();
}

void numLinha(){
num();
}

int num(){
if(cadeia for um numero){
 numLinha();
return 1;
}

return 0;
}

int Lexp(){

if(cadeia for um numero){

num();
return 1;
}else{
if(cadeia for abre parênteses){

if(cadeia.proximo_caracter() for um operador){

return 1;
}else{
return 0;
}

Lexpseq();
}

return 1;
}

return 0;
}

Lexp();

4)

a) A gramática G4 não é LL(1), pois possui recursividade a esquerda.

S → SAB | abA | baC

A → aSb | d
B → bScC | c
C →cCa | b

Tratando a recursividade em S:

S →abAS’ | baCS’
S’ → ABS’ | ε

Gramática G4’ que agora é LL(1):

S →abAS’ | baCS’
S’ → ABS’ | ε
A → aSb | d
B → bScC | c
C →cCa | b

b)

FIRST(S) = {a, b}
FIRST(S’) = {ε, a, d}
FIRST(A) = {a, d}
FIRST(B) = {b, c}
FIRST(C) = {c, b}

FOLLOW(S) = {$, b, c}
FOLLOW(S’) = {$, b, c}
FOLLOW(A) = {$, a, b, c, d}
FOLLOW(B) = {$, a, b, c, d}
FOLLOW(C) = {$, a, b, c, d}

c)

vai →for “$” ou pertencer ao follow

varre →pertencer ao follow ou first E não ser “$”

a b c d $
S S→ abAS’ S → baCS’ VARRE VARRE SAI
S’ S’ → ABS’ S’ → ε S’ → ε S’ → ABS’ S’ → ε
A A →aSb SAI SAI A→d SAI
B SAI B → bScC B→c SAI SAI
C SAI C→b C → cCa SAI SAI

d)

PILHA ENTRADA REGRA

$S bacbddc$ S → baCS’
$S’Cab bacbddc$
$S’Ca acbddc$
$S’C cbddc$ C → cCa
$S’aCc cbddc$
$S’aC bddc$ C→b
$S’ab bddc$
$S’a ddc$ SAI
$S’ ddc$ S’ → ABS’
$S’BA ddc$ A→d
$S’Bd ddc$
$S’B dc$ SAI
$S’ dc$ S’ → ABS’
$S’BA dc$ A→d
$S’Bd dc$
$S’B c$ B→c
$S’c c$
$S’ $ S’ → ε
$ $ Cadeia reconhecida