Analisador Sintático - Compiladores

Analisador Sintático:
Construir uma classe que implemente um analisador sintático. Essa classe deve se chamar
“Sintatico”, e deve ser um analisador descendente recursivo.
O objetivo desse módulo é verificar se uma seqüência de tokens pode ser gerada pela gramática
definida abaixo. O analisador sintático deve ser montado num esquema Produtor/Consumidor,
com o analisador léxico (classe Lexico).
O analisador sintático deve ser o ponto de entrada do compilador, e deve chamar o
procedimento lexico.nextToken() cada vez que um novo token seja necessário.
O uso da tabela de símbolos torna-se fundamental neste ponto, auxiliando no controle de escopo.
Esse controle será realizado no próximo passo de implementação.
Verificações Semânticas:
O módulo Sintático deve também executar as diversas verificações semânticas requeridas pela
linguagem. No caso do presente projeto, será exigida minimamente as verificações semânticas
definidas abaixo:
1. Todo identificador deve ser declarado ANTES de ser utilizado em qualquer operação.

Considere que o identificador usado como nome do programa é declarado na cláusula que inicia
um programa.
2. Um identificador só pode ser declarado uma vez. Não haverá controle de escopo no programa
(todos os identificadores compartilham o mesmo escopo global).
Gramática:
A gramática abaixo descreve as regras sintáticas da linguagem de programação que deve ser
implementada. O aluno deve dedicar um tempo ao estudo dessa gramática antes de iniciar a
implementação do analisador sintático. Esse estudo tem como objetivo identificar pontos de
melhoria, como ambigüidades, recursões à esquerda e possibilidades de fatoração.

O aluno deve construir uma tabela sintática preditiva, que auxiliará na construção das funções de
reconhecimento do analisador.
Como parte da entrega desta etapa, o aluno deve incluir um relatório contendo todas as
alterações que julgou serem necessárias.
Notação: palavras em letras minúsculas representam tokens (símbolos terminais da gramática).
Tratam-se dos mesmos tokens definidos na 1a Etapa do projeto, mas grafados em letras
minúsculas. Espaços em branco são usados para fins de clareza na leitura das produções, não
devendo interferir no processo de reconhecimento.
Produções
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
S -> program id term bloco end_prog term
bloco -> begin cmds end
| cmd
cmds -> declare dcflw
| if ifflw cmds
| repf cmds
| repw cmds
| id idflw
| ε
ifflw -> l_par exp_l r_par then bloco cndb
idflw -> attrib_op atrib2 term cmds
dcflw -> id type term cmds
cmd -> decl
| cond
| rep
| atrib
decl -> declare id type term
cond -> if l_par exp_l r_par then bloco cndb
cndb -> else bloco
| ε
atrib -> id attrib_op atrib2 term
atrib2 -> id atr_id
| val_n atr_vn
| l_par exp_n r_par exp_l2
| literal | logic_val /* para não mudar numeração */
atr_id -> exp_l2
atr_vn -> exp_n2 at_vn2
at_vn2 -> rel_op exp_n
| ε
exp_l -> logic_val exp_l2
| id exp_l2
| val_n exp_n2 rel_op exp_n
| l_par exp_n r_par
exp_l2 -> rel_op exp_n exp_l3
| exp_l3
exp_l3 -> logic_op exp_l
| ε
exp_n -> id exp_n2
| val_n exp_n2
| l_par exp_n r_par exp_n2
exp_n2 -> addsub_op exp_n
| multdiv_op exp_n
| ε
val_n -> num_int
| num_float
rep -> repf
| repw
repf -> for id attrib_op exp_n to exp_n bloco
repw -> while l_par exp_l r_par bloco

posso enviar o pdf.