Análise Bottom-Up. Compiladores. Parsing LR. Tabela Ações/Transições. Análise LR. Construindo tabelas LR

Transcrição

1 Análise Bottom-Up Compiladores Análise sintática 5) Gramáticas SLR), LR) e LALR String Entrada -> Símbolo Inicial Regras aplicadas em reverso adiar decisões mais poderoso Noção de handle, redução, uso de pilha Parsing Shift-Reduce empilha-reduz) LR0) SLR) LR) LALR) Exemplo: S T T T * T ) Parsing LR Tabela Ações/Transições Parser baseado em tabelas Cria derivações mais a direita Usar um autômato finito Cada estado representa produções da gramática Transições são feitas a cada terminal/não terminal Estruturas de dados: Pilha de estados {s} Tabela de ações: Action[s,a] a T Tabela de transições: Goto[s,X] X N * S3 S3 S5 S5 S5 ) S7 S8 S8 S8 $ Ok! T 6 Análise LR switch action[s, a]) caso shift u: empilha estado u ler novo a caso reduzir r: Procurar produção r: X Y..Yk pop k estados, encontrar estado u push goto[u,x] caso aceitar: fim case erro: erro Construindo tabelas LR Configuração ou ítem ou ítem LR0)) = uma regra da gramática com um ponto em algum lugar à direita. Exemplo: T T * Possui quatro ítens: T T * T T * T T * T T * O ponto representa até onde foi feita a análise Calculá-se os conjuntos canônicos de ítens = todos os ítens alcançáveis a partir de um conjunto de regras da gramática. Cada conjunto será um estado do parser

2 Cálculo dos conjuntos: echamento Propriedade de echamento: Se T X X i X i+ X n está em um conjunto, e X i+ é um não-terminal que deriva em α, então também está no conjunto: X i+ α Itera-se essa operação Calcula o conjunto como um ponto fixo Acrecenta-se um não-terminal S à gramática Adicione produção S S Conjunto de ítens Inicial é: fechamentos S) SucessorC,X) Segundo procedimento útil Pega em argumento um conjunto de ítens C e um símbolo X Retorna um conjunto de ítens Informalmente: mover o ponto pelo símbolo X. mover ponto para direita em todos os ítens onde o ponto precede X Para todas as regras A α X β em C retorna A αx β. Calcular fechamento Construção dos Conjuntos de Ítens amília de conjuntos de ítens Cada conjunto será um estado do parser proc itemsg ) C = fechamento{s S}) do foreach I C do foreach X N T) do C = C SucessorI, X) while C é modificado Construção Tabela LR0). Construir = {I 0, I, I n } I 0 é o estado inicial. a) Se {S S } I i então ação[i,$] = aceitar b) Se {A α } I i e A!= S então ação[i,_] = reduzir A α c) Se {A α aβ} I i e SucessorI i,a)=i j então ação[i,a] = shift j 3. Se SucessorI i,a) == I j então goto[i,a] = j. Todas as entradas não definas são erros 3 Productions T T T* T) 0: S T T T T * T ) T Reduz : T 7: T ) ) Reduz $ Aceitar : S T T T * * 3: T T * T ) * 6: T ) T T * Reduz : T T * T 8: Reduz 3 5: T ) T T T * T ) Observações LR0) sempre reduz se {A α } I i, sem lookahead Ítens Shift e Reduce podem estar no mesmo conjunto de configurações Conflito Shift/Reduce Pode haver mais de um ítem reduce por conjunto Conflito Reduce/Reduce Problema com A Є

3 Exemplo de conflitos S T T T * T ) = T T 5: = T Conflito Shift/reduce! : T Conflito Reduce/Reduce! Uma solução simples para resolver as ambigüades Em casos de gramáticas de operadores, pode-se usar uma tabela de precedências: GLC sem produção Є Não há dois não-terminais adjacentes nos lados direitos Exemplo: E E+E E-E E*E E) Basta definir a precedência relativa entre os terminais * > + leia-se * é prioritário sobre + < * leia-se é menos prioritário do que * > + Etc Obtém-se uma tabela de comparação Percorre-se o texto de entrada até achar um símbolo com maior precedência Outra solução para resolver o problema Limitar as decisões de redução aos casos que o terminal que segue na entrada é compatível com a redução. Look-ahead Isso pode tirar alguns) conflitos shift/reduce. Não vai mudar o tamanho da tabela... Para saber quais terminais seguem um símbolo na entrada, usa-se É o método SLR) Usa-se token de look-ahead. Outra solução para resolver o problema Limitar as decisões de redução aos casos que o terminal que segue na entrada é compatível com a redução. Look-ahead Isso pode tirar alguns) conflitos shift/reduce. Não vai mudar o tamanho da tabela... Para saber quais terminais seguem um símbolo na entrada, usa-se ollow)! É o método SLR) Usa-se token de look-ahead. Simple LR Parser Construção Tabela SLR). Construir = {I 0, I, I n } conjuntos de ítens LR0)) I 0 é o estado inicial. a) Se {S S } I i então ação[i,$] = aceitar b) Se {A α } I i e A!= S então ação[i,b] = reduzir A αpara todos b ollowa) c) Se {A α aβ} I i e SucessorI i,a)=i j então ação[i,a] = shift j 3. Se SucessorI i,a) == I j então goto[i,a] = j. Todas as entradas não definas são erros SLR) : Simples LR) Parser 0: S T T T T * T C T) ++ T ) C : ++ C ação[,*]= ação[,)] = ação[,$] = ação[,] = ação[,+] = S T T T * C T ) ++ T ) C ollow) = { *, ), $ } ollowc) ={ } Reduz Reduz C Shift 3

4 Observações sobre SLR) Obs: SLR) somente reduz {A u } se o lookahead está em ollowa) Ítens empilha e reduz podem estar no mesmo conjunto de configuração desde que os seus lookaheads sejam disjuntos Uma gramática é SLR) se para cada conjunto de configuração: Para cada ítem {A α aβ: a T} : não existe nenhum {B γ : a ollowb)} IMPEDE conflito Reduz/shift Para cada dois ítens {A γ } e {B β } ollowa) ollowb) = IMPEDE conflito Reduz/Reduz Gramáticas LR0) Gramáticas SLR) Exercício SLR) Consere a seguinte gramática livre do contexto: S -> al) a L -> S,L S Construir os estados do parser SLR) Calcular os conjuntos first e follow da gramática Calcular a tabela SLR) Mostrar análise de aa,a) Sumário: análise sintática Top-Down - recursiva ou com tabela preditiva LL): ácil de implementar Necessita apenas o irst/ollow Incompatível com GLCs recursivas a esquerda. Bottom-up LR0), LR), SLR), LALR)... Mais poderosas = reconhecem mais GLCs) Implementações muito eficientes Mais difíceis de implementar à mão. Yet Another Compiler Compiler Produz um parser bottom-up para uma dada gramática Usado para produzir compiladores para Pascal, C, C++ entre outras Além disso, foi usado no desenvolvimento de: bc - calculadora eqn & pic verificador de sintaxe SQL Lex bison: substituto do yacc da GNU Seqüência básica operacional Exemplo gram.y yacc Arquivo contendo gramática desejada no formato yacc programa yacc expr expr + term + 3 LEX num [0-9]+ y.tab.c programa fonte C criado pelo yacc term factor NUM PLUS NUM factor num cc or gcc Compilador C num expr ::= expr + term term term ::= term * factor factor factor ::= '' expr ')' num a.out Programa executável que faz a análise sintática da gramática descrita em parse.y Válo!

5 ormato do arquivo Definições Regras Código Suplementar Seções de Regras Normalmente escritas como segue: expr : expr '+' term term term : term '*' factor factor factor : '' expr ')' ID NUM Seção de Definições %{ #include <stdio.h> #include <stdlib.h> %} %token ID NUM %start expr Obs: lex produz uma função yylex) yacc produz uma função yyparse) yyparse espera chamar uma yylex Como conseguir yylex? Escrever sua própria! Usar Lex Construindo yylex lex & yacc int yylex) { ifit's a num) return NUM else ifit's an ) return ID else ifparsing is done) return 0 else ifit's an error) return - } lex.yy.c y.tab.c cc a.out 5

6 Exemplo Suponha um arquivo lex scanner.l e um arquivo yacc chamado decl.y. Passos a serem feitos... yacc -d decl.y lex scanner.l gcc -c lex.yy.c y.tab.c gcc -o parser lex.yy.o y.tab.o -ll Nota: scanner deve incluir na seção de definições: #include "y.tab.h" As regras podem ser recursivas As regras não podem ser ambíguas* Usa um parser bottom up Shift/Reduce -LALR) Solicita um token Empilha Redução? Sim: reduz usando a regras correspondente Não: pega outro token Yacc não pode olhar mais que um token de lookahead yacc -v gram.y gera a tabela de estados, em y.output Exemplo: Lex %{ #include <stdio.h> #include "y.tab.h" %} [_a-za-z][_a-za-z0-9]* wspc [ \t\n]+ semi [] comma [,] int { return INT } char { return CHAR } float { return LOAT } {comma} { return COMMA } {semi} { return SEMI } {} { return ID} {wspc} {} scanner.l Exemplo: Definições %{ #include <stdio.h> #include <stdlib.h> %} %start line %token CHAR, COMMA, LOAT, ID, INT, SEMI decl.y Exemplo: Regras decl : type ID list { printf"success!\n") } list : COMMA ID list SEMI type : INT CHAR LOAT decl.y yacc -d decl.y Produced y.tab.h # define CHAR 57 # define COMMA 58 # define LOAT 59 # define ID 60 # define INT 6 # define SEMI 6 Testando 6