Tradução dirigida por sintaxe

Transcrição

1 epartamento de Estatística e Informática Universidade Federal de Sergipe Compiladores Tradução dirigida por sintaxe André Luis Meneses Silva andreluis.ms@gmail.com 1

2 efinições dirigidas por sintaxe Gramática + regras (ações) semânticas Cada símbolo possui um atributo Regras definem os valores dos atributos Cada produção tem sua(s) regra(s) Regras são avaliadas quando a produção é aplicada Gramática de atributos efn. dirigida por sintaxe onde as regras não têm efeitos colaterais (paradigma funcional) 2

3 Exemplo em CUP terminal Integer UM; non terminal Integer expr;... expr ::= expr:a PLUS expr:b {: RESULT = new Integer(a.intValue() + b.intvalue()); :} expr:a TIMES expr:b {: RESULT = new Integer(a.intValue() * b.intvalue()); :} LPARE expr:a RPARE {: RESULT = a :} UM : i {: RESULT = i :} ; 3

4 Atributos sintetizados e herdados Considere a árvore de derivação: O valor de um atributo sintetizado é definido em função dos valores dos atributos dos filhos Exemplo anterior Atributos herdados dependem dos irmãos e/ou o pai T L { L.type = T.type } L id, L1 { L1.type = L.type; id.type=l.type } L id { id.type = L.type } Cup só trabalha com atributos sintetizados 4

5 Exemplo: números simples 1 {.v = 1.v*10 +.v } {.v =.v } 0 {.v = 0 } 1 {.v = 1 }... 9 {.v = 9 } 5

6 Exemplo: números simples Qual é mais adequada para definir o valor semântico de somente com atributos sintetizados? 1 {.v = 1.v*10 +.v } {.v =.v } 0 {.v = 0 } 1 {.v = 1 }... 9 {.v = 9 } S {.h = 0; } 1 {.s = 1.s ; 1.h =.h*10 +.s } {.s =.h*10 +.s; } 0 {.s = 0 } 1 {.s = 1 }... 9 {.s = 9 } 6

7 Árvore de derivação 901 árvore de derivação

8 Árvore de derivação 901 árvore de derivação 1 {.v = 1.v*10+.v } {.v =.v } 0 {.v = 0 } 1 {.v = 1 }... 9 {.v = 9 }

9 Árvore de derivação 901 árvore de derivação 1 {.v = 1.v*10+.v } {.v =.v } 0 {.v = 0 } 1 {.v = 1 }... 9 {.v = 9 } 1 0.v = 9 9 9

10 Árvore de derivação 901 árvore de derivação 1 {.v = 1.v*10+.v } {.v =.v } 0 {.v = 0 } 1 {.v = 1 }... 9 {.v = 9 }.v = v =

11 Árvore de derivação 901 árvore de derivação 1 {.v = 1.v*10+.v } {.v =.v } 0 {.v = 0 } 1 {.v = 1 }... 9 {.v = 9 }.v = 9.v = 9.v = 90 0.v =

12 Árvore de derivação 901 árvore de derivação.v = {.v = 1.v*10+.v } {.v =.v } 0 {.v = 0 } 1 {.v = 1 }... 9 {.v = 9 }.v = 9.v = 9.v = v = 0.v =

13 Implementando Atributos Sintetizados LR Empilha-se o valor do atributo junto com o símbolo/estado Quando há redução, a respectiva regra semântica é avaliada (, * 8 $) (<UM,2>, + 4 * 8 $) (<expr,2>, + 4 * 8 $) ( <expr,2><plus>, 4 * 8 $) (<expr,2><plus><um,4>, * 8 $) (<expr,2><plus><expr,4>, * 8 $) (<expr,2><plus><expr,4><times>, 8 $) (<expr,2><plus><expr,4><times><um,8>, $) (<expr,2><plus><expr,4><times><expr,8>, $) (<expr,2><plus><expr,32>, $) (<expr,34>, $) 13

14 Ações com efeitos colaterais Gramáticas de atributos são declarativas As vezes é interessante escrever ações com efeitos colaterais Maior cuidado pois a execução das ações depende da ordem em que as produções são reduzidas Ex. Uma calculadora interativa com ações imperativas 4+9 ; <ETER> 13 5*(4+2); <ETER> 30 <EOF> 14

15 Implementação com o CUP terminal SEMI, PLUS, TIMES, LPARE, RPARE; terminal Integer UMBER; // com atributo non terminal Integer expr; non terminal expr_, calc; // com atributo precedence left PLUS; precedence left TIMES; 15

16 calc ::= expr_ SEMI calc expr_ SEMI {: System.out.println("BYE"); :} ; expr_ ::= expr:e {: System.out.println(e.toString()); :} ; expr ::= expr:a PLUS expr:b {: RESULT = new Integer(a.intValue() + b.intvalue()); :} expr:a TIMES expr:b {: RESULT = new Integer(a.intValue() * b.intvalue()); :} LPARE expr:a RPARE {: RESULT = a :} UM : i {: RESULT = i :} ; 16

17 Ações imperativas exigem cuidado Como se comportam os parsers das seguinte gramáticas? calc ::= expr:e SEMI calc {: System.out.println(e.toString()); :} expr:e SEMI {: System.out.println(e.toString()); System.out.println("BYE"); :} ; expr ::=... 17

18 Ações imperativas exigem cuidado Como se comportam os parsers das seguinte gramáticas? calc ::= expr:e SEMI calc {: System.out.println(e.toString()); :} expr:e SEMI {: System.out.println(e.toString()); System.out.println("BYE"); :} ; expr ::=... calc ::= calc expr:e SEMI {: System.out.println(e.toString()); :} expr:e SEMI {: System.out.println(e.toString()); System.out.println("BYE"); :} ; expr ::=... 18

19 s ::= calc {: System.out.println("BYE"); :} ; calc ::= calc expr:e SEMI {: System.out.println(e.toString()); :} expr:e SEMI {: System.out.println(e.toString()); :} ; expr ::=... 19

20 Ações embutidas calc ::= calc expr:e {: System.out.println(e.toString()); :} SEMI expr:e SEMI {: System.out.println(e.toString()); :} ; expr ::=... Quando são executadas as ações embutidas? São tratadas como não terminais (um novo para c/ação) Uma produção vazia é adicionada para c/ação Conflitos podem ser introduzidos calc ::= calc expr:e $_1 SEMI... $_1 ::= {: System.out.println(e.toString()); :} ; 20

21 Implementação totalmente imperativa import java.util.*; action code {: List pilha = new Vector(); void push(int a) { pilha.add(pilha.size(), new Integer(a)); } int pop() { Integer i = (Integer) pilha.remove(pilha.size()-1); return i.intvalue(); } :} terminal PLUS, TIMES, SEMI, LPARE, RPARE; terminal Integer UM; non terminal expr, expr_, calc; precedence left PLUS; precedence left TIMES; 21

22 calc ::= expr_ SEMI calc expr_ SEMI {: System.out.println("BYE"); :} ; expr_ ::= expr {: System.out.println(pop()); :} ; expr ::= expr PLUS expr {: int a = pop(); int b = pop(); push(a+b); :} expr TIMES expr {: int a = pop(); int b = pop(); push(a*b); :} LPARE expr RPARE UM : i {: push(i.intvalue()); :} ; 22

23 Exemplo estendido: Todo um interpretador em Ações semânticas Prog Stm Stm Stm ; Stm id := Exp print ( ExpList ) Sintaxe de Straight-line Exp Exp BinOp Exp Stm, Exp ( Exp ) id num ExpList Exp, ExpList Exp BinOp + * 23

24 Interprete em Estilo Imperativo terminal Integer UM; terminal String I; terminal PLUS, TIMES, SEMI, COMMA, LPARE, RPARE, ASSIG, PRIT ; non terminal exp, stm, exps, prog; precedence right SEMI; precedence left PLUS; precedence left TIMES; 24

25 action code {: List pilha = new Vector(); void push(int a) { pilha.add(pilha.size(), new Integer(a)); } int pop() { Integer i = (Integer) pilha.remove(pilha.size()-1); return i.intvalue(); } :} Map mem = new HashMap(); void store(int v, String id) { mem.put(id, new Integer(v)); } int get(string id) { Integer v = (Integer) mem.get(id); return v.intvalue(); } 25

26 prog ::= stm ; stm ::= stm SEMI stm I:id ASSIG exp {: store(id,pop()); :} PRIT LPARE exps RPARE {: System.out.println(); :} ; exps ::= exp {: System.out.println(pop()); :} exps COMMA exp {: System.out.println(pop()); :} ; exp ::= exp PLUS exp {: int a = pop(); int b = pop(); push(a+b); :} exp TIMES exp {: int a = pop(); int b = pop(); push(a*b); :} LPARE exp RPARE stm COMMA exp UM : i {: push(i.intvalue()); :} I : id {: push(get(id)); :} ; 26

27 Misturando estilos // declarações de símbolos e precedências como antes, salvo: non terminal Integer exp ; action code {:... // só definições de get e store:} prog ::= stm ; stm ::= stm SEMI stm I:id ASSIG exp:e {: store(id,e.intvalue()); :} PRIT LPARE exps RPARE {: System.out.println(); :} ; exps ::= exp:e {: System.out.println(e.intValue()); :} exps COMMA exp:e {: System.out.println(e.intValue()); :} ; Impressão: ações semânticas com efeitos colaterais Avaliação de expressões: gramática de atributos

28 exp ::= exp:e1 PLUS exp:e2 {: RESULT = new Integer(e1.intValue()+ e2.intvalue(); :} exp TIMES exp {: RESULT = new Integer(e1.intValue()* e2.intvalue(); :} LPARE exp:e RPARE {: RESULT = e; :} stm COMMA exp:e {: RESULT = e; :} UM : i {: RESULT = i; :} I : id {: RESULT = new Integer(get(id)); :} ; 28

29 Ações Semânticas em LL Ações semânticas são misturadas com o fluxo de controle das ações do parser Ordem de avaliação é fácil predizer Atributos sintetizados Valor de retorno da função Atributos herdados Através de argumentos da função 29

30 Atributos sintetizados em LL E num + E1 { E.v = num.v + E1.v } num { E.v = num.v } LL(2) Atributos sintetizados são passados de filhos para pai através do retorno da função int E() { if (tok1.code == UM && tok2.code == PLUS ) { int i = tok1.value(); reconhece(um ); reconhece (PLUS); int j = E( ); return(i+j); } else if (tok1.code == UM && tok2.code == EOF) { int i = tok1.value; reconhece(um); return i; } else erro(); } 30

31 Atributos herdados em LL Se aumentarmos a operação -, o parser começa a complicar Podemos fatorar à esq. para termos LL(1) o entanto a gramáticade atributos precisa de atributos herdados E num E E + num E1 - num E { E.h = num.v ; E.v = E.v} { E1.h = E.h + num.v; E.v = E1.v } {... // similar } { E.v = E.h } O computo do + e associa a esq. ou a dir.? 31

32 Atributos herdados em LL Atributos herdados são passados de pai para filho através de argumentos da função de irmão (à esquerda) para irmão na avaliação da produção int E() {switch(tok.code) { case UM: int v = tok.value(); reconhece(um); return E (v); default: erro(); } } int E (int h) {switch(tok.code) { // h atributo herdado case PLUS: reconhece(plus); int v = reconhece(um); return E (h+v); case MIUS:... // similar case EOF : return h; default: erro(); } 32

33 Interprete de Expressões LL E T E E + T E Gramática de expressões por camadas e fatorada Primeiro(E) = { id, num, ( } T F T Primeiro(E ) = {,+, $ } T * F T... Seguinte(E) = { ), $ } F num ( E ) Seguinte(E ) = { ), $ } Exercício tipo prova:... Calcular a tabela de parser LL(1) ar uma gramática de atributos para um interpretador desta gramática Implementar na mão Extra: implementar usando JavaCC 33

34 Ações com efeitos colaterâis um interpretador de straight-line public class InterpretadorSL { Map mem =...; } void SimpleStm() {switch(tok.code) { case PRIT: reconhece(prit); reconhece(lpare); ExpList(); reconhece (RPARE) case I: String id = (String) tok.value(); reconhece (I); reconhece(assig); int v = Exp( ); mem.store(id,v); break; default: erro(); Embutimos ações semânticas no parser 34

35 void compoundstm {... } void ExpList( ) {switch(tok.code) { case...: int v = Exp( ); System.out.print(v+" "); reconhece(comma); ExpList(); break; case RPARE: System.out.println(); break; default: erro(); } int Exp ( ) {...} 35

36 Ações semânticas no JavaCC void SimpleStm( ) : { Token t; int v; } { print ( ExpList() ) t=<i> <ASSIG> v = Exp( ); { mem.store(t.image(),v); } }... void ExpList( ) : { int v; } { v = Exp( ) { System.out.print(v+" "); } ( <COMMA> v = Exp() { System.out.print(v+" "); } )* { System.out.println() } }... 36

37 Exercício opcional Completar o interpretador de straight-line na mão ou usando JavaCC 37

38 Exercício opcional Utilizando uma gramática de atributos escrita em JavaCC, dar uma implementação em estilo funcional do interpretador de straight-line efinir o tipo memória com funções int get(string), Memoria store(int,string) Atributos herdados são necessários? Atributo sintetizado de Stm Memória e Lista de valores (impressos), ou Memória (aqui a impressão será imperativa) Atributo de Exp? Atributo de Exps? Qual é a dificuldade de se fazer este exercício no Cup? 38