Compiladores. Prof. Bruno Moreno Aula 11 20/05/2011
|
|
|
- Neusa Balsemão Chagas
- 7 Há anos
- Visualizações:
Transcrição
1 Compiladores Prof. Bruno Moreno Aula 11 20/05/2011
2 2- Recursivo preditivo
3 Análise Recursiva Preditiva O símbolo sobre o cabeçote de leitura determina exatamente qual produção deve ser aplicada na expansão de cada nãoterminal Deve ser possível determinar, dado um símbolo a, qual não-terminal deve ser derivado
4 Análise Recursiva Preditiva Exemplo COMANDO if EXPR then COMANDO while EXPR do COMANDO repeat LISTA until EXPR id := EXPR Se as produções de COMANDO fossem escritas assim: COMANDO CONDICIONAL ITERATIVO ATRIBUIÇÃO CONDICIONAL if EXPR then COMANDO ITERATIVO repeat LISTA until EXPR while EXPR do COMANDO ATRIBUIÇÃO id := EXPR
5 Análise Recursiva Preditiva Ainda assim continuaria sendo possível determinar univocamente a produção a ser usada Porém, seria necessário determinar quais terminais iniciam as sentenças deriváveis a partir de CONDICIONAL, ITERATIVO e ATRIBUIÇÃO CONDICIONAL if EXPR then COMANDO ITERATIVO repeat LISTA until EXPR ATRIBUIÇÃO id := EXPR while EXPR do COMANDO
6 Conjunto PRIMEIROS PRIMEIROS ou FIRST(b) Todos os terminais que iniciam sentenças deriváveis a partir de uma forma sentencial b (1) Se b E Então E é um elemento de FIRST(b) (2) Se b aa a é um elemento de FIRST(b) se a é um símbolo terminal E a é uma forma sentencial qualquer, podendo ser E
7 Análise Recursiva Preditiva Dado um símbolo não-terminal A definido por várias alternativas Se A b 1 b 2... b N A implementação de um reconhecedor recursivo preditivo para A exige que os conjuntos FIRST de b 1 b 2... b N sejam disjuntos dois a dois Exemplo CONDICIONAL if EXPR then COMANDO ITERATIVO repeat LISTA until EXPR while EXPR do COMANDO ATRIBUIÇÃO id := EXPR FIRST(CONDICIONAL) = {if} FIRST(ITERATIVO) = {while, repeat} FIRST(ATRIBUIÇÃO) = {id}
8 Implementãção do recursivo preditivo Para o não terminal COMANDO: SE token = if ENTÃO INVOCA CONDICIONAL SENÃO SE token = while OU token = repeat ENTÃO INVOCA ITERATIVO SENÃO SE token = id ENTÃO INVOCA ATRIBUIÇÃO SENÃO RETORNA FALSE
9 Análise Recursiva Preditiva Exigem que (1) A gramática não tenha recursividade à esquerda (2) A gramática esteja fatorada à esquerda (3) Os não-terminais com mais de uma regra de produção possuam conjunto PRIMEIROS capazes de identificar univocamente
10 Análise Recursiva Preditiva Exigem que (1) A gramática não tenha recursividade à esquerda (2) A gramática esteja fatorada à esquerda (3) Os não-terminais com mais de uma regra de produção possuam conjunto PRIMEIROS capazes de identificar univocamente
11 FATORAÇÃO DE GRAMÁTICA
12 Fatoração de Gramática Gramática fatorada à esquerda é uma gramática que não apresenta produções do tipo A ab 1 ab 2 Exemplo de gramática não fatorada A B + C B * C
13 Fatoração de Gramática Gramática fatorada à esquerda é uma gramática que não apresenta produções do tipo A ab 1 ab 2 Exemplo de gramática não fatorada A B + C B * C
14 Fatoração de Gramática Gramática fatorada à esquerda é uma gramática que não apresenta produções do tipo A ab 1 ab 2 Fatorando... A aa A b 1 b 2 Exemplo comando if expr then comando else comando if expr then comando
15 Fatoração de Gramática Gramática fatorada à esquerda é uma gramática que não apresenta produções do tipo A ab 1 ab 2 Fatorando... A aa A b 1 b 2 Exemplo comando if expr then comando else comando if expr then comando
16 Fatoração de Gramática Gramática fatorada à esquerda é uma gramática que não apresenta produções do tipo A ab 1 ab 2 Fatorando... A aa A b 1 b 2 Exemplo comando if expr then comando else comando if expr then comando comando if expr then comando resto_do_if resto_do_if else comando E
17 Exemplo - Implementação Considere a gramática DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID, id TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ]
18 Exemplo - Implementação Considere a gramática DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID, id TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ]
19 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID, id TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] Essa gramática possui recursividade a esquerda?
20 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID, id TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] Eliminando-se a recursividade à esquerda...
21 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID, id TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] Eliminando-se a recursividade à esquerda... DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ]
22 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ]
23 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E Símbolo de partida TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ]
24 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] INICIO invoca(lê_token) invoca(decl) FIM
25 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento DECL: invoca(lista_id);
26 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento DECL: invoca(lista_id); SE token = : ENTÃO invoca(lê_token);
27 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento DECL: invoca(lista_id); SE token = : ENTÃO invoca(lê_token); invoca(tipo); SENÃO retorna erro;
28 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento LISTA_ID:
29 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento LISTA_ID: SE token = id ENTÃO
30 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento LISTA_ID: SE token = id ENTÃO invoca(lê_token); invoca(lista_id ); SENÃO retorna erro;
31 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento LISTA_ID :
32 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento LISTA_ID : SE token =, ENTÃO
33 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento LISTA_ID : SE token =, ENTÃO invoca(lê_token); SE token = id ENTÃO
34 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento LISTA_ID : SE token =, ENTÃO invoca(lê_token); SE token = id ENTÃO invoca(lê_token); invoca(lista_id ); SENÃO retorna erro; SENÃO retorna;
35 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento TIPO:
36 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento TIPO: SE token = int OU token = real ENTÃO invoca(simples);
37 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento TIPO: SE token = int OU token = real ENTÃO invoca(simples); SENÃO SE token = mat OU token = conj ENTÃO invoca(agregado); SENÃO retorna erro;
38 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento SIMPLES:
39 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento SIMPLES: SE token = int ENTÃO invoca(lê_token);
40 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento SIMPLES: SE token = int ENTÃO invoca(lê_token); SENÃO SE token = real ENTÃO invoca(lê_token); SENÃO retorna erro;
41 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento AGREGADO:
42 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento AGREGADO: SE token = mat ENTÃO invoca(lê_token);
43 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento AGREGADO: SE token = mat ENTÃO invoca(lê_token); invoca(dimensão);
44 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento AGREGADO: SE token = mat ENTÃO invoca(lê_token); invoca(dimensão); invoca(simples);
45 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento AGREGADO: SE token = mat ENTÃO invoca(lê_token); invoca(dimensão); invoca(simples); SENÃO invoca(lê_token); invoca(simples);
46 Exemplo - Implementação DECL LISTA_ID : TIPO LISTA_ID id LISTA_ID LISTA_ID, id LISTA_ID E TIPO SIMPLES AGREGADO SIMPLES int real AGREGADO mat DIMENSÃO SIMPLES conj SIMPLES DIMENSÃO [ num ] procedimento DIMENSÃO: SE token = [ ENTÃO invoca(lê_token); SE token = n ENTÃO invoca(lê_token); SE token = u ENTÃO invoca(lê_token); SE token = m ENTÃO invoca(lê_token); SE token = ] ENTÃO SENÃO retorna erro;
47 3- Tabular preditivo
48 Análise Preditiva Tabular Analisador não recursivo Utiliza uma pilha explícita, ao invés de chamadas recursivas Implementa um autômato de pilha controlado por uma tabela de análise O princípio do reconhecimento preditivo é a determinação da produção a ser aplicada
49 Análise Preditiva Tabular O analisador busca a produção a ser aplicada na tabela de análise, levando em conta: Não terminal no topo da pilha Token sob o cabeçote de leitura
50 Análise Preditiva Tabular Entrada contém sentença a ser analisada seguida de $ Inicialmente, pilha contém $, que marca sua base, seguido do símbolo inicial da gramática
51 Análise Preditiva Tabular A tabéla de análise é uma tabela com n linhas e t+1 colunas n é o número de símbolos não-terminais t é o número de símbolos terminais Incluindo $
52 Análise Preditiva Tabular O analisador é controlado por um programa que analisa a pilha, a entrada e a tabela de análise Exemplo Considere X como símbolo no topo da pilha a como terminal da fita de entrada sob o cabeçote de leitura
53 Análise Preditiva Tabular O analisador executa uma das três ações possíveis Se X = a = $ Pára a sentença Se X = a $ Desempilha a e avança o cabeçote de leitura Se X é um não terminal Entrada M[X, a] da tabela é consultada Essa entrada poderá conter uma produção ou ter vazio.
54 Análise Preditiva Tabular Se X é um não terminal Entrada M[X, a] da tabela é consultada Essa entrada poderá conter uma produção ou ter vazio. Se X não for vazio (X UVW, por exemplo) X da pilha é substituido por WVU Se X for vazio Erro! Analisador chama rotina de tratamento de erro
55 Construção da Tabela de Análise Noção de conjuntos PRIMEIROS e SEGUIDORES FIRST e FOLLOW Conjunto PRIMEIROS Se a é uma forma sentencial FIRST(a) é o conjunto dos terminais que iniciam as formas derivadas de a, sendo que vazio pode fazer parte
56 Construção da Tabela de Análise SEGUIDORES Definida para não-terminais FOLLOW(A) Conjunto de terminais que aparecem imediatamente a direita de A em alguma forma sentencial
57 Construção da Tabela de Análise Como computar FIRST? Se a é um terminal FIRST(a) = {a} Se X E Então E pertence a FIRST(X) Se X ay 1 Y 2...Y k Se a é um terminal FIRST(X)= {a} Se a é um vazio FIRST(X) = FIRST(Y 1 )
58 Construção da Tabela de Análise Como computar FOLLOW? Se S é o símbolo inicial da gramática e $ é o marcador de fim da sentença, então $ pertence a FOLLOW(S) Se A axb Então FOLLOW(X) contém todos os elementos de FIRST(b) Se A ax ou A axb sendo b E Então FOLLOW(X) contém todos os elementos de FOLLOW(A)
59 Veremos como contruir a gramática em um exemplo!
60 Análise Preditiva Tabular (Exemplo) E E v T T T T & F F F F id Qual o primeiro problema que deve ser resolvido nesta gramática? Recursividade a esquerda!
61 Análise Preditiva Tabular (Exemplo) E E v T T T T & F F F F id E T E E v T E E T F T T & F T E F F id
62 Análise Preditiva Tabular (Exemplo) Conjunto primeiros FIRST(E) E T E E v T E E T F T T & F T E F F id
63 Análise Preditiva Tabular (Exemplo) Conjunto primeiros FIRST(E) = FIRST(T) E T E E v T E E T F T T & F T E F F id
64 Análise Preditiva Tabular (Exemplo) Conjunto primeiros FIRST(E) = FIRST(T) = FIRST(F) E T E E v T E E T F T T & F T E F F id
65 Análise Preditiva Tabular (Exemplo) Conjunto primeiros FIRST(E) = FIRST(T) = FIRST(F) = {, id} E T E OK! E v T E E T F T OK! T & F T E F F id OK!
66 Análise Preditiva Tabular (Exemplo) Conjunto primeiros FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = E T E OK! E v T E E T F T OK! T & F T E F F id OK!
67 Análise Preditiva Tabular (Exemplo) Conjunto primeiros FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } E T E OK! E v T E E T F T OK! T & F T E F F id OK! OK!
68 Análise Preditiva Tabular (Exemplo) Conjunto primeiros FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T) = E T E OK! E v T E E T F T OK! T & F T E F F id OK! OK!
69 Análise Preditiva Tabular (Exemplo) Conjunto primeiros FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} E T E OK! E v T E E T F T OK! T & F T E F F id OK! OK! OK!
70 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
71 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} FOLLOW(E) E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
72 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} FOLLOW(E) = {$} E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
73 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} FOLLOW(E) = {$} FOLLOW(E ) E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
74 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} FOLLOW(E) = {$} FOLLOW(E ) E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
75 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} FOLLOW(E) = {$} FOLLOW(E ) E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
76 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} FOLLOW(E) = {$} FOLLOW(E ) FOLLOW(E ) contém FOLLOW(E) E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
77 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} FOLLOW(E) = {$} FOLLOW(E ) = {$} FOLLOW(E ) contém FOLLOW(E) E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
78 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} FOLLOW(E) = {$} FOLLOW(E ) = {$} FOLLOW(T) E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
79 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} FOLLOW(E) = {$} FOLLOW(E ) = {$} FOLLOW(T) 1- FIRST(E ) = {v, E} E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
80 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} FOLLOW(E) = {$} FOLLOW(E ) = {$} FOLLOW(T) 1- FIRST(E ) = {v, E} 2- E pode ser vazio? E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
81 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} FOLLOW(E) = {$} FOLLOW(E ) = {$} FOLLOW(T) 1- FIRST(E ) = {v, E} 2- E pode ser vazio? FOLLOW(E ) = {$} E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
82 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} FOLLOW(E) = {$} FOLLOW(E ) = {$} FOLLOW(T) 1- FIRST(E ) = {v, E} 2- E pode ser vazio? FOLLOW(E ) = {$} E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
83 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} FOLLOW(E) = {$} FOLLOW(E ) = {$} FOLLOW(T) = {v, $} FOLLOW(T ) E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
84 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} FOLLOW(E) = {$} FOLLOW(E ) = {$} FOLLOW(T) = {v, $} FOLLOW(T ) FOLLOW(T) = {v, $} E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
85 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} FOLLOW(E) = {$} FOLLOW(E ) = {$} FOLLOW(T) = {v, $} FOLLOW(T ) = {v, $} E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
86 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} FOLLOW(E) = {$} FOLLOW(E ) = {$} FOLLOW(T) = {v, $} FOLLOW(T ) = {v, $} E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
87 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} FOLLOW(E) = {$} FOLLOW(E ) = {$} FOLLOW(T) = {v, $} FOLLOW(T ) = {v, $} FOLLOW(F) 1- FIRST(T ) = {&, E} E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
88 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} FOLLOW(E) = {$} FOLLOW(E ) = {$} FOLLOW(T) = {v, $} FOLLOW(T ) = {v, $} FOLLOW(F) 1- FIRST(T ) = {&, E} 2- T pode ser vazio? E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
89 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} FOLLOW(E) = {$} FOLLOW(E ) = {$} FOLLOW(T) = {v, $} FOLLOW(T ) = {v, $} FOLLOW(F) 1- FIRST(T ) = {&, E} 2- T pode ser vazio? FOLLOW(T ) = {v, $} E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
90 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} FOLLOW(E) = {$} FOLLOW(E ) = {$} FOLLOW(T) = {v, $} FOLLOW(T ) = {v, $} FOLLOW(F) = {&, v, $} 1- FIRST(T ) = {&, E} 2- T pode ser vazio? FOLLOW(T ) = {v, $} E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
91 Conjunto SEGUIDORES FIRST(E) = FIRST(T) = FIRST(F) = {, id} FIRST(E ) = {v, E } FIRST(T ) = {&, E} FOLLOW(E) = {$} FOLLOW(E ) = {$} FOLLOW(T) = {v, $} FOLLOW(T ) = {v, $} FOLLOW(F) = {&, v, $} E T E E v T E E T F T T & F T E F F id Como construir FOLLOW Se S é símb. inicial $ pertence a FOLLOW(S) Se A axb FOLLOW(X) contém FIRST(b) Se A ax ou A axb sendo b E FOLLOW(X) contém FOLLOW(A)
92 E a tabela?
93 Construção da Tabela Para cada produção A a de G Para cada terminal a de FIRST(a) Adicione na tabela A a a M[A, a] Se FIRST(a) inclui E, então adicione A a a M[A, b] para cada b em FOLLOW(A)
94 Análise Preditiva Tabular (Exemplo) Tabela de análise preditiva Para cada regra da gramática... E E T T F id v & $
95 Análise Preditiva Tabular (Exemplo) Tabela de análise preditiva Para E TE FIRST(TE ) = {, id} E T E E v T E E T F T T & F T E F F id id v & $ E E T T F
96 Análise Preditiva Tabular (Exemplo) Tabela de análise preditiva Para E TE FIRST(TE ) = {, id} E T E E v T E E T F T T & F T E F F id id v & $ E E T T F
97 Análise Preditiva Tabular (Exemplo) Tabela de análise preditiva Para E TE FIRST(TE ) = {, id} E T E E v T E E T F T T & F T E F F id id v & $ E E T T F E TE
98 Análise Preditiva Tabular (Exemplo) Tabela de análise preditiva Para E TE FIRST(TE ) = {, id} E T E E v T E E T F T T & F T E F F id id v & $ E E TE E TE E T T F
99 Análise Preditiva Tabular (Exemplo) Tabela de análise preditiva Para E vte E T E E v T E E T F T T & F T E F F id id v & $ E E TE E TE E T T F
100 Análise Preditiva Tabular (Exemplo) Tabela de análise preditiva Para E vte FIRST(TE ) = {v} E T E E v T E E T F T T & F T E F F id id v & $ E E TE E TE E T T F
101 Análise Preditiva Tabular (Exemplo) Tabela de análise preditiva Para E vte FIRST(TE ) = {v} E T E E v T E E T F T T & F T E F F id id v & $ E E TE E TE E E vte T T F
102 Análise Preditiva Tabular (Exemplo) Tabela de análise preditiva Para E E FOLLOW(E ) = {$} E T E E v T E E T F T T & F T E F F id id v & $ E E TE E TE E E vte E E T T F
103 Análise Preditiva Tabular (Exemplo) Tabela de análise preditiva Para T F T FIRST(FT ) = {, id} E T E E v T E E T F T T & F T E F F id id v & $ E E TE E TE E E vte E E T T F
104 Análise Preditiva Tabular (Exemplo) Tabela de análise preditiva Para T F T FIRST(FT ) = {, id} E T E E v T E E T F T T & F T E F F id id v & $ E E TE E TE E E vte E E T T F T T F
105 Análise Preditiva Tabular (Exemplo) Tabela de análise preditiva Para T F T FIRST(FT ) = {, id} E T E E v T E E T F T T & F T E F F id id v & $ E E TE E TE E E vte E E T T F T T F T T F
106 Análise Preditiva Tabular (Exemplo) Tabela de análise preditiva Para T & F T FIRST(&FT ) = {&} E T E E v T E E T F T T & F T E F F id id v & $ E E TE E TE E E vte E E T T F T T F T T F
107 Análise Preditiva Tabular (Exemplo) Tabela de análise preditiva Para T & F T FIRST(&FT ) = {&} E T E E v T E E T F T T & F T E F F id id v & $ E E TE E TE E E vte E E T T F T T F T T T & F T F
108 Análise Preditiva Tabular (Exemplo) Tabela de análise preditiva Para T E FOLLOW(T ) = {v, $} E T E E v T E E T F T T & F T E F F id id v & $ E E TE E TE E E vte E E T T F T T F T T T & F T F
109 Análise Preditiva Tabular (Exemplo) Tabela de análise preditiva Para T E FOLLOW(T ) = {v, $} E T E E v T E E T F T T & F T E F F id id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T F
110 Análise Preditiva Tabular (Exemplo) Tabela de análise preditiva Para T E FOLLOW(T ) = {v, $} E T E E v T E E T F T T & F T E F F id id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F
111 Análise Preditiva Tabular (Exemplo) Tabela de análise preditiva Para F F id FIRST( F) = { } E T E E v T E E T F T T & F T E F F id id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F
112 Análise Preditiva Tabular (Exemplo) Tabela de análise preditiva Para F F id FIRST( F) = { } E T E E v T E E T F T T & F T E F F id id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F F
113 Análise Preditiva Tabular (Exemplo) Tabela de análise preditiva Para F F id FIRST(id) = {id} E T E E v T E E T F T T & F T E F F id id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F F
114 Análise Preditiva Tabular (Exemplo) Tabela de análise preditiva Para F F id FIRST(id) = {id} E T E E v T E E T F T T & F T E F F id id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F
115 Análise Preditiva Tabular (Exemplo) Pronto! Tabela montada! E agora? id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F
116 Análise Preditiva Tabular (Exemplo) Observação importante... Se em cada entrada da tabela existe apenas uma produção, então a gramática é LL(1) id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F
117 Análise Preditiva Tabular (Exemplo) Processamento do analisador para a sentença idvid&id id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F
118 Sentença: id v id & id Pilha inicia com $ e Símbolo de partida PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F E $
119 Sentença: id v id & id Verifica a decisão que relaciona elemento da pilha com sentença PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F E $
120 Sentença: id v id & id Substitui produção PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F T E $
121 Sentença: id v id & id Produção do símbolo do topo da pilha T PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F T E $
122 Sentença: id v id & id Substitui produção PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F F T E $
123 Sentença: id v id & id Substitui produção do topo da pilha Topo é igual a Sentença! PILHA Id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F id T E $
124 Sentença: id v id & id Desempilha! PILHA Id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F id T E $
125 Sentença: id v id & id Decisão do elemento que tá no topo em relação ao próximo da sentença PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F T E $
126 Sentença: id v id & id T gera vazio... Substitui na pilha PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F T E $
127 Sentença: id v id & id O próximo da pilha é E PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F E $
128 Sentença: id v id & id E vazio gera vte... Coloca na pilha PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F v T E $
129 Sentença: id v id & id O elemento do topo da pilha é igual ao da sentença PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F v T E $
130 Sentença: id v id & id Desempilha! PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F T E $
131 Sentença: id v id & id T e id estão relacionado com que regra de produção? PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F T E $
132 Sentença: id v id & id Coloca a produção de T na pilha PILHA Id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F F T E $
133 Sentença: id v id & id F gera id... Substitui na pilha PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F id T E $
134 Sentença: id v id & id Desempilha! PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F T E $
135 Sentença: id v id & id Produção de T... PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F T E $
136 Sentença: id v id & id Coloca produção de T na pilha PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F & F T E $
137 Sentença: id v id & id Elemento do topo é igual a entrada PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F & F T E $
138 Sentença: id v id & id Desempilha! PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F F T E $
139 Sentença: id v id & id F gera id PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F id T E $
140 Sentença: id v id & id Desempilha! PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F T E $
141 Sentença: id v id & id $ O elemento da sentença agora é $ Temos que zerar a pilha e achar o elemento que é $ PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F T E $
142 Sentença: id v id & id $ O elemento da sentença agora é $ Temos que zerar a pilha e achar o elemento que é $ T gera VAZIO PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F T E $
143 Sentença: id v id & id $ PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F E $
144 Sentença: id v id & id $ E gera VAZIO PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F E $
145 Sentença: id v id & id $ Sentença aceita! PILHA id v & $ E E TE E TE E E vte E E T T F T T F T T T E T & F T T E F F id F F $
146 Fim! =)
Análise Sintática. Análise Sintática. Tipos de Analisadores Gramáticais: PARSERS
Análise Sintática Tipos de Analisadores Gramáticais: PARSERS * Analisadores TOP-DOWN: Árvore de derivação começa pela raiz indo para as folhas => Análise Descendente Tipo LL(1): Left to right / Leftmost
Compiladores. Análise Sintática
Compiladores Análise Sintática Cristiano Lehrer, M.Sc. Introdução (1/3) A análise sintática constitui a segunda fase de um tradutor. Sua função é verificar se as construções usadas no programa estão gramaticalmente
Compiladores. Transformações de GLCs. Plano da aula. Análise Top-Down. Análise Top-Down Exemplo. Gramáticas Livres de Contexto.
Gramáticas Livres de Contexto Análise Top-Down Compiladores ε Análise sintática (2) Análise Top-Down Top-Down AB AB cb A c ccbb B cbb ccbca B ca 2 Transformações de GLCs Eliminação de produções vazias
Análise Sintática Descendente
Análise Sintática Descendente Uma tentativa de construir uma árvore de derivação da esquerda para a direita Cria a raiz e, a seguir, cria as subárvores filhas. Produz uma derivação mais à esquerda da sentença
COMPILADORES. Análise sintática. Prof. Geovane Griesang Universidade de Santa Cruz do Sul UNISC Departamento de informática
Universidade de Santa Cruz do Sul UNISC Departamento de informática COMPILADORES Análise sintática Parte 02 Prof. geovanegriesang@unisc.br Data Conteúdo 23/09/2013 3. Análise Sintática: 3.1 analisadores
Gramáticas Livres de Contexto
Conteúdo da aula Gramáticas Livres de Contexto Marcelo Johann Trabalho - primeira etapa Definição, código e estrutura Mais elementos e detalhes de lex GLCs Gramática, produção, derivações, árvores Ambíguas,
Compiladores. Exemplo. Caraterísticas de Gramáticas. A αβ 1 αβ 2. A αx X β 1 β 2. Lembrando... Gramáticas Livres de Contexto
Compiladores Análise sintática (2) Análise Top-Down Lembrando... Gramáticas Livres de Contexto Análise sintática = parsing. Baseada em GLCs Gramática: S A B Top-Down Bottom-Up S AB cb ccbb ccbca S AB A
Analisadores Descendentes Tabulares; Cjs First Follow
Conteúdo da aula nalisadores Descendentes Tabulares; Cjs First Follow Marcelo Johann nalisadores Descendentes Recursivos com Retrocesso Recursivos Preditivos Conjunto FIRT e Implementação nalisador Preditivo
Análise Sintática (Cap. 04) Análise Sintática Descendente
(Cap. 04) Análise Sintática Descendente Análise Sintática Análise sintática descendente Constrói a árvore de derivação de cima para baixo, da raíz para as folhas, criando os nós da árvore em pré ordem
COMPILADORES. Análise sintática. Prof. Geovane Griesang Universidade de Santa Cruz do Sul UNISC Departamento de informática
Universidade de Santa Cruz do Sul UNISC Departamento de informática COPILADORES Análise sintática Parte 03 Prof. geovanegriesang@unisc.br Analisador sem recursão Analisador sintático sem recursão pode
Compiladores Aula 6. Celso Olivete Júnior.
Aula 6 Celso Olivete Júnior olivete@fct.unesp.br Na aula passada Analisadores Sintáticos Descendentes ASD com retrocesso ASD preditivo recursivo não-recursivo 2 ASD Preditivo Recursivo Projeto Parte 2
Compilação: Erros. Detecção de Erros: * Analisadores Top-Down - Preditivo Tabular (LL) - Feito a mão. * Analisadores Botton-Up: - Shift-Reduce (SLR)
Compilação: Erros Detecção de Erros: * Analisadores Top-Down - Preditivo Tabular (LL) - Feito a mão * Analisadores Botton-Up: - Shift-Reduce (SLR) * Erros no Lex * Erros no Yacc * Erros na Definição da
Análise sintática. Análise sintática. Top-down ou descendente. Com retrocesso: por tentativa e erro. Preditiva: para gramáticas LL(1) 09/04/2012
Análise sintática Função, interação com o compilador Análise descendente e ascendente Especificação e reconhecimento de cadeias de tokens válidas Implementação Tratamento de erros Prof. Thiago A. S. Pardo
Compiladores. Análise Sintática
Compiladores Análise Sintática Análise Sintática Vejamos um exemplo, seja a seguinte instrução de atribuição: posicao = inicial + incremento * 60 Na análise sintática tenta-se construir uma frase correta
Análise Sintática LL(1)
FACULDADE ANGLO AMERICANO FOZ DO IGUAÇU Curso de Ciência da Computação 7º Periodo Disciplina: Compiladores Prof. Erinaldo Sanches Nascimento Análise Sintática LL(1) Análise Sintática Descendente Introdução
LL Parser ( TOP-DOWN)
LL Parser ( TOP-DOWN) CT-200 Thiago Silva de Oliveira Duarte Marcus Kimura Lopes TOP DOWN x BOTTON UP PARSER TOP DOWN Algoritmo começa do símbolo de início aplicando produções até alcançar a string desejada
Um Tradutor Dirigido por Sintaxe
Um tradutor dirigido por sintaxe 1 Um Tradutor Dirigido por Sintaxe Aula introdutória às técnicas de compilação. Ilustra técnicas desenvolvendo um programa Java que traduz instruções de uma linguagem de
Compiladores - Análise LL(1)
Compiladores - Análise LL(1) Fabio Mascarenhas - 2013.1 http://www.dcc.ufrj.br/~fabiom/comp Gramáticas LL(1) Uma gramática é LL(1) se toda predição pode ser feita examinando um único token à frente Muitas
Análise Sintática Bottom-up
MAB 471 2011.2 Análise Sintática Bottom-up http://www.dcc.ufrj.br/~fabiom/comp Recapitulando parsers top-down Constróem árvore sintática da raiz até as folhas Recursão à esquerda faz parsers entrarem em
Compiladores - Análise LL(1)
Compiladores - Análise LL(1) Fabio Mascarenhas 2017.1 http://www.dcc.ufrj.br/~fabiom/comp Gramáticas LL(1) Uma gramática é LL(1) se toda predição pode ser feita examinando um único token à frente Muitas
Como construir um compilador utilizando ferramentas Java
Como construir um compilador utilizando ferramentas Java p. 1/2 Como construir um compilador utilizando ferramentas Java Aula 6 Análise Sintática Prof. Márcio Delamaro delamaro@icmc.usp.br Como construir
Construção de Compiladores. José de Oliveira Guimarães Departamento de Computação UFSCar - São Carlos, SP Brasil
Construção de Compiladores José de Oliveira Guimarães Departamento de Computação UFSCar - São Carlos, SP Brasil e-mail: jose@dc.ufscar.br March 26, 2007 Contents 1 Introdução 2 1.1 Compiladores e Ligadores..................................
Compiladores. Parser LL 10/13/2008
Compiladores Fabiano Baldo Usa uma pilha explícita ao invés de chamadas recursivas para realizar a análise sintática. LL(k) parsing significa que ktokensà frente são utilizados. O primeiro L significa
Árvores de Derivação para GLC Ambigüidade nas GLC Precedência, Prioridade e Associatividade de operadores
Árvores de Derivação para GLC Ambigüidade nas GLC Precedência, Prioridade e Associatividade de operadores 1 Árvores de Derivação para GLC GLC são as mais importantes para a definição de linguagens de programação
Compiladores Aula 4. Celso Olivete Júnior.
Aula 4 Celso Olivete Júnior olivete@fct.unesp.br Na aula de hoje... Revisão: gramáticas Relações em uma gramática: Cabeça, Último, Primeiro (First) e Seguinte (Follow) Capítulo 4 (seção 4.4.2) do livro
03. [Sebesta, 2000] Descreva a operação de um gerador de linguagem geral.
![03. [Sebesta, 2000] Descreva a operação de um gerador de linguagem geral.](/thumbs/42/22989864.jpg "03. [Sebesta, 2000] Descreva a operação de um gerador de linguagem geral.")
01. [Sebesta, 2000] Defina sintaxe e semântica. 02. [Sebesta, 2000] A quem se destinam as descrições de linguagem? 03. [Sebesta, 2000] Descreva a operação de um gerador de linguagem geral. 04. [Sebesta,
V Análise Sintática. V.1.1 Gramáticas Livres de Contexto Definições de GLC
V Análise Sintática V.1 Fundamentos Teóricos V.1.1 G.L.C V.1.2 Teoria de Parsing V.2 Especificação Sintática de Ling. de Prog. V.3 - Implementação de PARSER s V.4 - Especificação Sintática da Linguagem
Dada uma gramática GLC G: Obter G tal que L(G )=L(G) e G seja LL(1); Conforme a conveniência, efetuar eliminação de regras e de recursões à direita, usando a notação EBNF; Criar, para cada símbolo não-terminal
Parsing Preditivo. Antes de ser abordado o Parsing Preditivo, será apresentado o Analisador Sintático Descendente Recursivo.
UPE Caruaru Sistemas de Informação Disciplina: Compiladores Prof.: Paulemir G. Campos Parsing Preditivo Antes de ser abordado o Parsing Preditivo, será apresentado o Analisador Sintático Descendente Recursivo.
Análise Sintáctica. Definições: Conjuntos First() e Follow() Compiladores, Aula Nº 19 João M. P. Cardoso. Conjunto First(β)
Análise Sintáctica Compiladores, Aula Nº 19 João M. P. Cardoso 1 Definições: Conjuntos First() e Follow() 2 Notação T é terminal, NT é nãoterminal, S é terminal ou não-terminal, e α e β representam sequências
Plano da aula. Compiladores. Os erros típicos são sintáticos. Análise Sintática. Usando Gramáticas. Os erros típicos são sintáticos
Plano da aula Compiladores Análise sintática (1) Revisão: Gramáticas Livres de Contexto 1 Introdução: porque a análise sintática? Noções sobre Gramáticas Livres de Contexto: Definição Propriedades Derivações
V Teoria de Parsing. Termos Básicos: Parser Analisador Sintático Parsing Analise Sintática Parse Representação da analise efetuada
V Teoria de Parsing Termos Básicos: Parser Analisador Sintático Parsing Analise Sintática Parse Representação da analise efetuada Ascendentes: S + x (* Seq. Invertida Reducao *) dir Exemplo: Descendentes:
Compiladores: P ASCAL jr
Compiladores: P ASCAL jr Rogério Eduardo da Silva, M.Sc. 2005/2 Sumário 1 Introdução 1 1.1 Evolução das Linguagens de Programação.................. 1 1.2 Introdução à Compilação............................
Compiladores - Análise SLR
Compiladores - Análise SLR Fabio Mascarenhas - 2013.1 http://www.dcc.ufrj.br/~fabiom/comp Um exemplo que funciona Todo estado com um item de redução e algum outro item causa conflito LR(0)! A técnica LR(0)
p. 2 Trechos de Material Didático (Apostila) e Conteúdo do Livro Texto, de autoria de Marcus Ramos, João José Neto e Ítalo Vega i <= 1
Observação: os trechos extraídos do livro apresentados a seguir já incluem as correções da errata (http://www.univasf.edu.br/~marcus.ramos/livro-lfa/errata.pdf). Para outras passagens não incluídas nesse
Analisadores Sintáticos. Análise Recursiva com Retrocesso. Análise Recursiva Preditiva. Análise Recursiva Preditiva 05/04/2010
Anlisdores intáticos Análise Descendente (Top-down) Anlisdores sintáticos descendentes: Recursivo com retrocesso (bcktrcking) Recursivo preditivo Tbulr preditivo Análise Redutiv (Bottom-up) Anlisdores
Revisão de GLC e Analisadores Descendentes
Conteúdo da aula 1. xemplos de Gramáticas Revisão de GLC e Analisadores Descendentes Marcelo Johann 2. Propriedades: Ambíguas, sem ciclos, ε-livres, fatoradas à esquerda, recursivas à esquerda, simplificadas
Capítulo 5 Análise sintática
Capítulo 5 1. Objetivo 2. Estratégias gerais de parsing 3. descendente (top-down) 3.1. Analisador sintático com retrocesso (backtracking) 3.2. Analisador sintático predicativo recursivo 3.3. Analisador
Compiladores - Análise Preditiva
Compiladores - Análise Preditiva Fabio Mascarenhas 207.2 http://www.dcc.ufrj.br/~fabiom/comp Analisador Preditivo Uma simplificação do parser recursivo com retrocesso que é possível para muitas gramáticas
Análise Sintática II: Analisadores Descendentes Preditivos
Análise Sintática II: Analisadores Descendentes Preditivos Exercícios LL(1) = Left to right, Left-most derivation, 1 símbolo look-ahead 1. LL(1): definição 2. Para toda produção A -> α β Se β =>* λ, então
Análise Léxica. Sumário
Análise Léxica Renato Ferreira Sumário Definição informal de Análise Léxica Identifica tokens numa string de entrada Alguns detalhes Lookahead Ambiguidade Especificação de Analisadores Léxicos Expressões
LFA Aula 09. Gramáticas e Linguagens Livres de Contexto 18/01/2016. Linguagens Formais e Autômatos. Celso Olivete Júnior.
LFA Aula 09 Gramáticas e Linguagens Livres de Contexto (Hopcroft, 2002) 18/01/2016 Celso Olivete Júnior olivete@fct.unesp.br www.fct.unesp.br/docentes/dmec/olivete/lfa 1 Classes Gramaticais Linguagens
Paradigmas de Linguagem de Programação
Paradigmas de Linguagem de Programação Sintaxe Introdução Sintaxe: conjunto de regras que definem a forma da linguagem; Como as sentenças podem ser formadas como sequências de componentes básicos palavras;
Compiladores Analisador Sintático. Prof. Antonio Felicio Netto Ciência da Computação
Compiladores Analisador Sintático Prof. Antonio Felicio Netto antonio.felicio@anhanguera.com Ciência da Computação 1 Análise Sintática - A Análise Sintática constitui a segunda fase de um tradutor de uma
Compiladores. Capítulo 3: Análise Sintática Introdução
Compiladores Capítulo 3: Análise Sintática 3.1 - Introdução O problema da análise sintática para uma dada gramática livre de contexto, consiste em descobrir, para uma cadeia x qualquer, se a cadeia pertence
COMPILADORES. Análise sintática. Prof. Geovane Griesang Universidade de Santa Cruz do Sul UNISC Departamento de informática
Universidade de Santa Cruz do Sul UNISC Departamento de informática COMPILADORES Análise sintática Parte 05 Prof. geovanegriesang@unisc.br Data Conteúdo 23/09/2013 3. Análise Sintática: 3.1 analisadores
Compiladores - Análise Preditiva
Compiladores - Análise Preditiva Fabio Mascarenhas 205.2 http://www.dcc.ufrj.br/~fabiom/comp Analisador Preditivo Uma simplificação do parser recursivo com retrocesso que é possível para muitas gramáticas
Geração de Código para LALG
Geração de Código para LALG Ambiente de execução para LALG Máquina hipotética Repertório de instruções Prof. Thiago A. S. Pardo 1 Geração de código para LALG Código-alvo será um código de montagem Portanto,
INE5317 Linguagens Formais e Compiladores AULA 9: Propriedades e Reconhecimento das Linguagens Livres do Contexto
INE5317 Linguagens Formais e Compiladores AULA 9: Propriedades e Reconhecimento das Linguagens Livres do Contexto baseado em material produzido pelo prof Paulo Bauth Menezes e pelo prof Olinto José Varela
Linguagens Livres do Contexto. Adaptado de H. Brandão
Linguagens Livres do Contexto Adaptado de H. Brandão Linguagens Livres do Contexto Para as LLC, temos as Gramáticas Livres do Contexto; Linguagens Livres do Contexto Para as LLC, temos as Gramáticas Livres
DEP. INFORMÁTICA - UNIVERSIDADE DA BEIRA INTERIOR
DEP. INFORMÁTICA - UNIVERSIDADE DA BEIRA INTERIOR Eng. Informática Linguagens Formais e Compilação 2º Semestre Resolução da Frequência 1 06/Abril/2011 Pergunta A.1 A.2 A.3 B. B.1 B.2 B.3 B.4 B.5 B.6 C.1
Compiladores - Especificando Sintaxe
Compiladores - Especificando Sintaxe Fabio Mascarenhas - 2013.1 http://www.dcc.ufrj.br/~fabiom/comp Análise Sintática A análise sintática agrupa os tokens em uma árvore sintática de acordo com a estrutura
Análise Sintática. Fabiano Baldo
Compiladores Análise Sintática Fabiano Baldo Gramáticas Livre de Contexto (GLC) É utilizada na especificação formal lda sintaxe de uma linguagem de programação. É um conjunto de produções ou regras gramaticais
Compiladores. Prof. Bruno Moreno Aula 8 02/05/2011
Compiladores Prof. Bruno Moreno Aula 8 02/05/2011 RECONHECIMENTO DE TOKENS Reconhecimento de Tokens Até aqui aprendemos a identificar tokens Para reconhecimento, a única abordagem utilizada foi árvores
Análise Sintática Introdução
Análise Sintática Introdução Renato Ferreira Linguagens e Automatas Linguagens formais são importantes em Computação Especialmente em linguagens de programação Linguagens regulares A linguagem formal mais
INE5318 Construção de Compiladores. AULA 4: Análise Sintática
INE5318 Construção de Compiladores AULA 4: Análise Sintática Ricardo Azambuja Silveira INE CTC UFSC E Mail: silveira@inf.ufsc.br URL: www.inf.ufsc.br/~silveira Definições preliminares Parser (Analisador
01. Mario, ao chegar a uma cidade com princípios lógicos, viu na placa de Bem Vindo! o ( ) x Px Bx Vx. Mais adiante, em outra placa, havia a
PROVA DE RACIOCÍNIO LÓGICO EDIÇÃO JUNHO 2009 01. Mario, ao chegar a uma cidade com princípios lógicos, viu na placa de Bem Vindo! o ( ) seguinte escrito: ( ) x Px Bx Vx. Mais adiante, em outra placa, havia
Folha 4.1 Análise sintática descendente
1. Dada a seguinte gramática G = (Σ, T, P, S), onde : Σ = { S, A, B } T = { a, b, c } S a b A c A A a S b S c B B a B b S b) Verifique que G é do tipo LL(1). c) Construa a tabela sintática predicativa
Compiladores - Análise Ascendente
Compiladores - Análise Ascendente Fabio Mascarenhas - 2013.1 http://www.dcc.ufrj.br/~fabiom/comp Análise Descendente vs. Ascendente As técnicas de análise que vimos até agora (recursiva com retrocesso,
Roteiro da aula. MA091 Matemática básica. Conjuntos. Subconjunto. Aula 12 Conjuntos. Intervalos. Inequações. Francisco A. M. Gomes.
Roteiro da aula MA091 Matemática básica Aula 1... Francisco A. M. Gomes UNICAMP - IMECC Março de 016 1 3 4 Francisco A. M. Gomes (UNICAMP - IMECC) MA091 Matemática básica Março de 016 1 / 8 Francisco A.
Compiladores - Análise Ascendente
Compiladores - Análise Ascendente Fabio Mascarenhas - 2013.2 http://www.dcc.ufrj.br/~fabiom/comp Análise Descendente vs. Ascendente As técnicas de análise que vimos até agora (recursiva com retrocesso,
Linguagens Livres de Contexto
Linguagens Livres de Contexto 1 Roteiro Gramáticas livres de contexto Representação de linguagens livres de contexto Formas normais para gramáticas livres de contexto Gramáticas ambíguas Autômatos de Pilha
Análise sintática. Análise sintática ascendente. Parte-se dos símbolos terminais em direção ao símbolo inicial da gramática. Derivação mais à direita
Análise sintática Função, interação com o compilador Análise descendente e ascendente Especificação e reconhecimento de cadeias de tokens válidas Implementação Tratamento de erros Prof. Thiago A. S. Pardo
Tratamento de Erros Sintáticos em A.S.D. com implementação de Procedimentos Recursivos. Error Report, Recovery and Repair
Tratamento de Erros Sintáticos em A.S.D. com implementação de Procedimentos Recursivos Error Report, Recovery and Repair Erros Sintáticos Tipos: ausência de um símbolo: var x: integer Símbolo mal escrito:
Revisão: Tipo Abstrato de Dados Recursividade
Algoritmos e Estrutura de Dados II Revisão: Tipo Abstrato de Dados Recursividade Prof a Karina Oliveira kkco@dei.unicap.br Introdução Estudo das estruturas de dados envolve dois objetivos complementares:
Eduardo Belo de Araújo. Analisador ANSI-C
Eduardo Belo de Araújo Analisador ANSI-C Monografia apresentada ao Departamento de Ciência da Computação da Universidade Federal de Lavras, como parte das exigências do curso de Pós-Graduação Lato Sensu
Análise Sintática (Cap. 04) Análise Sintática Ascendente Analisador Sintático LR
Análise Sintática (Cap. 04) Análise Sintática Ascendente Analisador Sintático LR Análise Sintática LR Analisadores sintáticos LR(k): L, verificação da entrada da esquerda para direita R, constrói a derivação
INE5317 Linguagens Formais e Compiladores. AULA 10: Anális e S intática
INE5317 Linguagens Formais e Compiladores AULA 10: Anális e S intática baseado em material produzido pelo prof Paulo B auth Menezes e pelo prof Olinto Jos é Varela Furtado Ricardo Azambuja Silveira INE-CTC-UFSC
COMPILADORES. Análise sintática. Prof. Geovane Griesang Universidade de Santa Cruz do Sul UNISC Departamento de informática
Universidade de Santa Cruz do Sul UNISC Departamento de informática COMPILADORES Análise sintática Parte 04 Prof. geovanegriesang@unisc.br Data Conteúdo 23/09/2013 3. Análise Sintática: 3.1 analisadores
Algoritmos e Estruturas de Dados I. Recursividade. Pedro O.S. Vaz de Melo
Algoritmos e Estruturas de Dados I Recursividade Pedro O.S. Vaz de Melo Problema Implemente uma função que classifique os elementos de um vetor em ordem crescente usando o algoritmo quicksort: 1. Seja
Análise Sintática I. Eduardo Ferreira dos Santos. Abril, Ciência da Computação Centro Universitário de Brasília UniCEUB 1 / 42
Análise Sintática I Eduardo Ferreira dos Santos Ciência da Computação Centro Universitário de Brasília UniCEUB Abril, 2017 1 / 42 Sumário 1 Introdução 2 Derivações 3 Ambiguidade 4 Análise sintática descendente
Compiladores - Análise Recursiva
Compiladores - Análise Recursiva Fabio Mascarenhas 2015.2 http://www.dcc.ufrj.br/~fabiom/comp Geradores x Reconhecedores A definição formal de gramática dá um gerador para uma linguagem Para análise sintática,
Um Compilador Simples. Definição de uma Linguagem. Estrutura de Vanguarda. Gramática Livre de Contexto. Exemplo 1
Definição de uma Linguagem Linguagem= sintaxe + semântica Especificação da sintaxe: gramática livre de contexto, BNF (Backus-Naur Form) Especificação Semântica: informal (textual), operacional, denotacional,
Compiladores I. Caracterizar um método de análise bottom-up. Compreender os mecanismos básicos envolvidos no processo de análise LR.
Compiladores I Gerson Geraldo Homrich Cavalheiro Caracterizar um método de análise bottom-up Compreender oecanismos básicos envolvidos no processo de análise LR Oferecer as bases para utilização de uma
BNF (Backus-Naur Form) Gramática Livres de Contexto / Estruturas Recursivas
Sintae => Usualmente Gramática Livre do Conteto (GLC) BNF (Backus-Naur Form) Gramática Livres de Conteto / struturas Recursivas comando => IF epressao THN epressao LS epressao epressao => (epressao) OR
www.souvestibulando.com.br CURSO PRÉ-VESTIBULAR MATEMÁTICA AULA 2 TEORIA DOS CONJUNTOS
1 CURSO PRÉ-VESTIULR MTEMÁTIC UL 02 SSUNTO: TEORI DOS CONJUNTOS Esta aula é composta pelo texto da apostila abaixo e por um link de acesso à UL VIRTUL gravada. Estude com atenção o texto antes de acessar
Geração de Código para LALG
Geração de Código para LALG Ambiente de execução para LALG Máquina hipotética Repertório de instruções Prof. Thiago A. S. Pardo 1 Geração de código para LALG Código-alvo será um código de montagem Portanto,
Os movimentos do reconhecedor correspondem ao uso de derivações mais à esquerda; A árvore de sintaxe é montada de cima para baixo (da raiz em direção
Os movimentos do reconhecedor correspondem ao uso de derivações mais à esquerda; A árvore de sintaxe é montada de cima para baixo (da raiz em direção às folhas); Caracteriza a classe das gramáticas (e
Compiladores - Análise Léxica
Compiladores - Análise Léxica Fabio Mascarenhas 2017.2 http://www.dcc.ufrj.br/~fabiom/comp Introdução Primeiro passo do front-end: reconhecer tokens Tokens são as palavras do programa O analisador léxico
Universidade Federal de Alfenas
Universidade Federal de Alfenas Linguagens Formais e Autômatos Aula 12 Linguagens Livres do Contexto humberto@bcc.unifal-mg.edu.br Linguagens Livres do Contexto Para as LLC, temos as Gramáticas Livres
2 Casamento Inexato, Alinhamento de Sequências e Programação DRAFT
Biologia Computacional - 2004/2 09/11/04 Aula 1: Casamento Inexato, Alinhamento de Sequências e Programação Dinâmica Instrutor: Berilhes Borges Garcia Escriba: André C. M. Costa DRAFT 1 Pesquisando Banco
Escalas ESCALAS COTAGEM
Escalas Antes de representar objectos, modelos, peças, etc. Deve-se estudar o seu tamanho real. Tamanho real é a grandeza que as coisas têm na realidade. Existem coisas que podem ser representadas no papel
Introdução Análise Sintática Descendente Análise Sintática Ascendente. Aula Prática. Fernando Antônio Asevedo Nóbrega
Análise Sintática Aula Prática Fernando Antônio Asevedo Nóbrega Instituto de Ciências Matemáticas e de Computação USP SCC-206 Introdução à Compilação 9 de maio de 2012 1 / 16 Agenda 1 Introdução 2 Análise
Análise de Algoritmos
Análise de Algoritmos Profa. Sheila Morais de Almeida DAINF-UTFPR-PG março - 2016 A invariante de laço pode ser definida como uma relação entre as variáveis de um algoritmo que é verdadeira em um determinado
Compiladores - Análise Léxica
Compiladores - Análise Léxica Fabio Mascarenhas 2018.1 http://www.dcc.ufrj.br/~fabiom/comp Introdução Primeiro passo do front-end: reconhecer tokens Tokens são as palavras do programa O analisador léxico
Compiladores - Análise Recursiva
Compiladores - Análise Recursiva Fabio Mascarenhas - 2013.2 http://www.dcc.ufrj.br/~fabiom/comp Analisador Recursivo Maneira mais simples de implementar um analisador sintático a partir de uma gramática,
V.2 Especificação Sintática de Linguagens de Programação
V.2 Especificação Sintática de Linguagens de Programação Deve ser baseada: No planejamento da Linguagem / Compilador Objetivos, Filosofia, Potencialidades,... Nos critérios de projeto/avaliação Legibilidade,
Linguagens de Programação Aula 5
Aula 5 Celso Olivete Júnior olivete@fct.unesp.br Na aula anterior Ambiguidade Análise léxica Exercício calculadora 2/@ Na aula anterior AF calculadora 3/@ Na aula de hoje Análise léxica implementação Gramática
Construção de Compiladores
Construção de Compiladores Parte 1 Introdução Linguagens e Gramáticas F.A. Vanini IC Unicamp Klais Soluções Motivação Porque compiladores? São ferramentas fundamentais no processo de desenvolvimento de
Recursividade. Métodos iterativos. Prof. Cesar Augusto Tacla. Métodos iterativos utilizam estruturas de repetição
Recursividade Prof. Cesar Augusto Tacla Métodos iterativos Métodos iterativos utilizam estruturas de repetição For While Do while Normalmente, um método invoca outros métodos, não a si mesmo. 2 1 Recursividade
BCC202 - Estrutura de Dados I
BCC202 - Estrutura de Dados I Aula 14: Ordenação: QuickSort Reinaldo Fortes Universidade Federal de Ouro Preto, UFOP Departamento de Computação, DECOM Website: www.decom.ufop.br/reifortes Email: reifortes@iceb.ufop.br
Compiladores Análise Semântica
Compiladores Análise Semântica Fabio Mascarenhas - 2013.1 http://www.dcc.ufrj.br/~fabiom/comp Árvores Sintáticas Abstratas (ASTs) A árvore de análise sintática tem muita informação redundante Separadores,
Aula 01 Introdução Custo de um algoritmo, Funções de complexidad e Recursão
MC3305 Algoritmos e Estruturas de Dados II Aula 01 Introdução Custo de um algoritmo, Funções de complexidad e Recursão Prof. Jesús P. Mena-Chalco jesus.mena@ufabc.edu.br 2Q-2015 1 Custo de um algoritmo
Vantagens de uma Gramática. Sintaxe de uma Linguagem. Analisador Sintático - Parser. Papel do Analisador Sintático. Tiposde Parsers para Gramáticas
Sintaxe de uma Linguagem Cada LP possui regras que descrevem a estrutura sintática dos programas. specificada através de uma gramática livre de contexto, BNF (Backus-Naur Form). 1 Vantagens de uma Gramática
Análise Sintática - Final
MAB 471 2011.2 Análise Sintática - Final http://www.dcc.ufrj.br/~fabiom/comp LR(k ) vs LL(k ) Encontrando o próximo passo em uma derivação LR(k) Cada redução na análise detectável com o contexto esquerdo
Compiladores. Bruno Lopes. Bruno Lopes Compiladores 1 / 12. Instituto de C
ompiladores Análise Sintática Bruno Lopes Bruno Lopes ompiladores 1 / 12 Front-end Lida com a linguagem de entrada Teste de pertinência: código fonte linguagem fonte? Programa está bem formado? Sintaticamente?
Se o símbolo inicial não fizer parte do conjunto de símbolos férteis, a linguagem gerada pela gramática é vazia.
Transformações em G.L.C Uma vez que existem métodos de análise, cada qual exigindo gramáticas com características específicas é importante que uma gramática possa ser transformada, porém, sem perder a
O uso de gramáticas traz vantagens para projetistas de linguagens e escritores de compiladores pelas seguintes razões:
3. ANÁLISE SINTÁTICA INTRODUÇÃO Toda linguagem de programação tem regras que descrevem sua estrutura sintática (ou sintaxe). A sintaxe de uma LP pode ser descrita por uma gramática livre de contexto 1
PROPOSIÇÕES. Proposições Simples e Proposições Compostas. Conceito de Proposição
PROPOSIÇÕES Conceito de Proposição Definição: chama-se proposição todo o conjunto de palavras ou símbolos que exprimem um pensamento de sentido completo. As proposições transmitem pensamentos, isto é,