Análises léxica e sintática

1. Análises léxica e sintática Teoria e Implementação de Linguagens Computacionais - IF688 Mauro La-Salette C. L. de Araújo Centro de Informática – CIn Universidade Federal de Pernambuco – UFPE mscla@cin.ufpe.br

2. Roteiro • Visão geral • Análise léxica • Definição • Especificação • Implementação • Correspondência • Análise sintática • Definição • Especificação • Implementação • Algoritmos de parsing e gramáticas • Gramáticas ambíguas • Sintaxe abstrata

3. Análiseléxica Análise semântica Geração de código AST decorada AST Visão Geral Código fonte Análise sintática executável Tokens

4. Análise Léxica

5. "n" id intLit intLit "1" "0" Definição • Fase da compilação responsável por extrair os tokens do código fonte de um programa. if (n == 0) { return 1; } else { ... } if LPAR assign RPAR LCUR return comm RCUR else ...

6. Especificação • Os tokens de uma linguagem comumente são especificados através de Expressões Regulares • [a-z][a-z0-9]* identifier • [0-9]+ intLiteral

7. IF i f 1 2 ID a-z a-z 2 3 1 0-9 Implementação • Autômatos finitos

8. Análise Sintática

9. Definição • Fase da compilação responsável por determinar se uma dada cadeia de entrada pertence ou não à linguagem definida por uma gramática • Tem como entrada os tokens processados pela análise léxica • Produz uma estrutura comumente denominada AST – abstract syntax tree

10. Especificação S ::= A | B A ::= C | D B ::= bba C ::= ab D ::= dab Produções • BNF - Backus-Naur form • S, A, B, C, D : não-terminais • a,b,d: terminais

11. Implementação • Algoritmos de parsing e gramáticas • Classificação • Top-down • Recursive-descent / LL(1) • Bottom-up • LR, SLR, LALR, LR(k)

12. Recursive descent • Algoritmo baseado em previsões • Funções mutuamente recursivas • Uma função para cada não-terminal

13. Recursive descent • Desenvolvendo um recursive descentparser • Cada não terminal 'X' dará origem a um método/função parseX(); • Produções do tipo 'A | B' darão origem a cláusulas cases

14. Recursive descent parseA() { accept(‘a’); parseB(); accept(‘c’); parseC(); } parseB() { case (d): parseC(); parseB(); case (c): accept(‘c’); parseC(); } A ::= aBcC B ::= CB | cC C ::= da parseC() { accept(‘d’); accept(‘a’); }

15. Recursive descent parseA() { accept(‘a’); parseB(); accept(‘c’); parseC(); } parseB() { case (d): parseC(); parseB(); case (d): parseC(); parseA(); } A ::= aBcC B ::= CB | CA C ::= da parseC() { accept(‘d’); accept(‘a’); }

16. Recursive descent • Vantagens • Fácil de implementar • Desvantagens • Performance • Gramática reconhecida possui restrições • Sem recursão à esquerda • Deve estar fatorada • ...

17. Recursive descent A ::= aBC B ::= CB | CA C ::= da A ::= aBC B ::= CX X ::= B | A C ::= da Gramática LL(1)

18. Gramáticas LL(1) Leftmost-derivation 1-symbol-lookahead Left-to-right parse

19. Gramáticas Ambíguas • Uma gramática é ambígua se a partir dela uma sentença pode dar origem a duas arvores de parsing • Problemáticas para a compilação • Eliminação de ambigüidade é quase sempre possível • Transformações na gramática

20. Gramáticas Ambíguas • Caso clássico: gramática para expressões aritméticas E ::= intLiteral | E '*' E | E '/' E | E '+' E | E '-' E |'(' E ')'

21. Gramáticas Ambíguas 1 + 2 * 3 E E + * E E E E 3 1 + * E E E E 1 2 2 3

22. Gramáticas Ambíguas • Solução: • Transformar a gramática • * e / com maior precedência que + ou - • Operadores associativos a esquerda E ::= intLiteral | E '*' E | E '/' E | E '+' E | E '-' E |'(' E ')' E ::= E '+' T | E '–' T | T T ::= T '*' F | T '/' F | F F ::= intLiteral |'(' E ')'

23. Sintaxe abstrata • Apenas reconhecer se uma sentença pertence ou não a linguagem especificada por uma gramática não é o suficiente • É necessário produzir uma estrutura que sirva de base para a próxima fase do processo de compilação • Parse trees nunca são montadas na prática

24. AST – Abstract Syntax Tree • Capturam a essência da estrutura de uma gramática abstraindo não-terminais • Representação possível • Java: Classes que possam se relacionar a fim de montar uma árvore • Pode ser produzida através da inserção de ações semânticas no parser

25. AST – Abstract Syntax Tree IfThenElse ::= 'if' expr 'then' comm1 'else' comm2 return new IfThenElse(expr, comm1, comm2);

26. Análises léxica e sintática Teoria e Implementação de Linguagens Computacionais - IF688 Mauro La-Salette C. L. de Araújo Centro de Informática – CIn Universidade Federal de Pernambuco – UFPE mscla@cin.ufpe.br