Projeto de Tradutor Preditivo

Introdução Introdução Esquemas L-atribuidos são reconhecidos por analisadores Top-Down. Entre estes analisadores, se encontra o Preditivo, que é implementado via chamadas recursivas. Veremos uma forma de se implementar tal tradutor, considerando os atributos (herdados e sintetizados)

Método de execução Para cada não-terminal da gramática, construir uma função que tenha como retorno o valor do(s) atributo(s) sintetizado(s) desse não- terminal. Se esse não-terminal possuir atributos herdados, estes parâmetros deverão ser parâmetros da função criada. Os símbolos que existirem nas produções desse não terminal devem estar nessa função como variáveis locais. O código da função criada deve decidir qual produção irá processar, com base no símbolo lido na entrada.

Método de execução Exemplo: ◦ Sendo a produção A → B C {A.a = C.c} ◦ Deve ser criada uma função de nome A, que retorne o valor a (referente a A). ◦ Internamente à função deve haver a variável c: int A(); { int c; } a = A();

Método de execução Considerando as produções para o não- terminal, da esquerda para a direita, o código da função associada a este não terminal deve: 1.Para cada token x da produção, verificar se x é o token lido realmente, e avançar a leitura; 2.Para cada não-terminal B do lado direito da produção, se este não terminal tiver atributo sintetizado (bs) e herdados (b 1, b 2, b 3...), gerar uma chamada à função para esse símbolo da forma bs = B(b 1, b 2, b 3...) 3.Para cada ação semântica na produção, copiar o código, substituindo cada referência existente a algum atributo pela variável local referente a esse atributo.

Exemplo Considerando a produção: E → T {X.h = T.ptr} X {E.ptr = X.s} Vê-se que E possui apenas um atributo sintetizado (ptr), nenhum atributo herdado; T possui um atributo sintetizado (ptr); e X possui os atributos h e s. Portanto, a função E não terá parâmetros, devendo retornar o valor de ptr (de E), e terá como variáveis locais: h, s, ptr1 (de T).

Exemplo Para a gramática abaixo, vista anteriormente: E → T {X.h = T.ptr} X {E.ptr = X.s} X → + T {X 1.h = geranodo(‘+’,X.h,T.ptr)} X 1 {X.s = X 1.s} X → ε {X.s = X.h} T → num {T.ptr = gerafolha(num,num.lexval)} T → id {T.ptr = gerafolha(id,id.indice)} E sendo ptr um ponteiro para um nodo da árvore, serão definidas as funções: ◦ *node E(); ◦ *node X(h: *node); ◦ *node T();

Exemplo Para o símbolo X, que contém atributos herdados e sintetizados, e sendo op_a o token do operador de adição: X → op_a T {X 1.h = geranodo(op_a.lexval,X.h,T.ptr)} X 1 {X.s = X 1.s} | X → ε {X.s = X.h} A função a ser construida poderia ser: *nodo X(h: *nodo); { *nodo h1, ptr, s, s1; if (token == op_a) { //produção op_a T X token = letoken(); ptr = T(); h1 = geranodo(op_a.lexval, h, ptr); s1 = X(h1); s = s1; } else { s = h; } return s; }