Simão Melo de Sousa. Computer Science Department University of Beira Interior, Portugal

Transcrição

1 Árvores de Sintaxe Abstracta Simão Melo de Sousa Computer Science Department University of Beira Interior, Portugal

2 Plano 1 Accções semânticas em Gramáticas Livres de Contexto Valores Semânticos em Gramáticas Descendentes Valores Semânticos em Gramáticas Ascendentes 2

3 Plano Valores Semânticos em Gramáticas Descendentes Valores Semânticos em Gramáticas Ascendentes 1 Accções semânticas em Gramáticas Livres de Contexto Valores Semânticos em Gramáticas Descendentes Valores Semânticos em Gramáticas Ascendentes 2

4 Princípios Gerais Valores Semânticos em Gramáticas Descendentes Valores Semânticos em Gramáticas Ascendentes Um compilador deve fazer mais do que simplesmente reconhecer se uma frase analisada pertence ou não a linguagem gerada pela gramática. pode/deve fazer algo com o texto reconhecido. As acções semânticas duma gramática possibilitadas por ferramentas como o yacc permitam a definição e a execução de tais operações em cada produção da gramática.

5 Princípios Gerais Valores Semânticos em Gramáticas Descendentes Valores Semânticos em Gramáticas Ascendentes Cada símbolo da gramática (terminal ou não terminal) pode ser associado a um determinado tipo de valor (semântico). Por exemplo numa gramática para a aritmética sobre inteiros, o não terminal especificando as expressões aritméticas, digamos exp, pode ser associado ao tipo inteiro. Uma expressão em particular (i.e. reconhecido por exp) terá como valor o inteiro que resulta do seu cálculo. Para uma regra A B C D, o valor semântico de A pode ser calculado a partir dos valores semânticos de B, C e D.

6 Valores Semânticos em Gramáticas Descendentes Valores Semânticos em Gramáticas Ascendentes Gramáticas LL(1) e valores semânticos em Ocaml Leitura e manipulaç~ao de express~oes lógicas simples com streams Este método de leitura implementa um lexer/parser descendente para a gramática LL(1) das express~oes lógicas seguinte (N -> {TRUE, FALSE}, V -> Variáveis): E ::= T E E ::= -> T E E ::= <-> T E E ::= \epsilon T ::= F T T ::= & F T T ::= F T T ::= \epsilon F ::= N F ::= V F ::=! E F ::= ( E )

7 Valores Semânticos em Gramáticas Descendentes Valores Semânticos em Gramáticas Ascendentes Gramáticas LL(1) e valores semânticos em Ocaml (*val parse_expr : Genlex.token stream -> formula *) let rec parse_expr = parser (* corresponde a entrada E da gramatica *) [< e1 = parse_conj; e = parse_more_imps e1 >] -> e and parse_more_imps e1 = parser (* corresponde a entrada E da gramatica *) [< Kwd "->"; e2 = parse_conj; e = parse_more_imps (Implica(e1, e2)) >] -> e [< Kwd "<->"; e2 = parse_conj; e = parse_more_imps (Equivale(e1, e2)) >] -> e [< >] -> e1 and parse_conj = parser (* corresponde a entrada T da gramatica *) [< e1 = parse_simple; e = parse_more_conjs e1 >] -> e and parse_more_conjs e1 = parser (* corresponde a entrada T da gramatica *) [< Kwd "&"; e2 = parse_simple; e = parse_more_conjs (E(e1, e2)) >] -> e [< Kwd " "; e2 = parse_simple; e = parse_more_conjs (Ou(e1, e2)) >] -> e [< >] -> e1 and parse_simple = parser (* corresponde a entrada F da gramatica *) [< Ident s >] -> Var s [< Kwd "TRUE" >] -> Verdade [< Kwd "FALSE" >] -> Falso [< Kwd "!"; e = parse_expr >] -> Nao e [< Kwd "("; e = parse_expr; Kwd ")" >] -> e let parse_expression = parser [< e = parse_expr; _ = Stream.empty >] -> e

8 Valores Semânticos em Yacc Valores Semânticos em Gramáticas Descendentes Valores Semânticos em Gramáticas Ascendentes %{ %} %token <int> INT %token PLUS MINUS TIMES DIV EOF %left PLUS MINUS %left TIMES DIV %left uminus %start expr %type <int> expr %% expr: INT {$1} expr PLUS expr {$1 + $3} expr MINUS expr {$1 - $3} expr TIMES expr {$1 * $3} expr DIV expr {$1 / $3} MINUS expr %prec uminus {-$2} ;

9 Pilha de Valores Semânticos Valores Semânticos em Gramáticas Descendentes Valores Semânticos em Gramáticas Ascendentes Pilha de valores Input Acção ɛ $ shift 1 : INT $ reduce 1 : expr $ shift 1 : expr $ shift 1 : expr + 2 : INT 3 $ reduce 1 : expr + 2 : expr 3 $ shift 1 : expr + 2 : expr 3 $ shift 1 : expr + 2 : expr 3 : INT $ reduce 1 : expr + 2 : expr 3 : expr $ reduce 1 : expr + 6 : expr $ reduce 7 : expr $ accept

10 Valores Semânticos em Yacc Valores Semânticos em Gramáticas Descendentes Valores Semânticos em Gramáticas Ascendentes %{ type op = Soma Diff Mult Div type ast = Binop of ast*op*ast Neg of ast Val of int %} %token INT PLUS MINUS TIMES DIV EOF %left PLUS MINUS %left TIMES DIV %left uminus %start expr %type <ast> expr %% expr: INT {Val $1} expr PLUS expr {Binop ($1,Soma,$3)} expr MINUS expr {Binop ($1,Diff,$3)} expr TIMES expr {Binop ($1,Mult,$3)} expr DIV expr {Binop ($1,Div,$3)} MINUS expr %prec uminus {Neg $2} ;

11 Plano 1 Accções semânticas em Gramáticas Livres de Contexto 2

12 Princípios É possível escrever compiladores completos utilizando exclusivamente o mecanismo de acções semânticas associadas as produções. No entanto, tais compiladores são difíceis de ler e de manter. Outra ponto ao desfavor de tal arquitectura é o facto de o processo semântico ter de acompanhar a analise sintáctica (i.e. obrigação de seguir a ordem do parsing quando esta pode não ser a mais cómoda). por forma a melhorar a modularidade e a separação clara entre processo sintáctico e processo semântico é habitual deixar as acções semânticas produzirem uma estrutura de dados que codifica todo o programa analisado e que poderá ser explorada e utilizada conveniente pelas restantes fases da compilação: a árvore de sintaxe abstracta, AST.

13 Princípios Linguagens de programação modernos = programação estruturada = AST: representação estruturada de programas As AST facilitam: A verificação dos tipos; a geração de programas; a transformação, a manipulação e a optimização de programas

14 Princípios Fala-se assim de Sintaxe Concreta vs. Sintaxe Abstracta Sintaxe Concreta = Sintaxe oferecida ao programador sintaxe Abstracta = Sintaxe manipulada pelo computador

15 Princípios

16 Princípios Sintaxe concreta: 1 while b do begin i 1 ;i 2 end 2 while b do i 1 ;i 2 done 3 enquanto b fazer i 1 seguido de i 2 fim Este exemplos representam a mesma sequência de comandos, naturalmente serão traduzidos para a mesma sintaxe abstracta. Melhor ainda, as AST permitam um bom tratamento de construções sintácticas qualificadas de açúcar sintáctico. Por exemplo a estrutura cíclica repeat pode ser vista como um caso particular de while. Assim repeat i until b pode dar convenientemente a mesma AST de que i; while not b do i

17 Princípios Em Ocaml, os tipos indutivos fornecem uma forma cómoda de representar estas AST. T: sequência de X type T = X list T: Alternativamente A, B ou C type T = Ca of A Cb of B Cc of C

18 AST em Yacc %{ type op = Soma Diff Mult Div type e = Binop of e*op*e Neg of e Val of int type ast = e list %} %token INT PLUS MINUS TIMES DIV EOF DOT %left PLUS MINUS %left TIMES DIV %left uminus %start prog %type <ast> prog %% prog: /*empty*/ {[]} expr DOT prog {$1::$2} expr: INT {Val $1} expr PLUS expr {Binop ($1,Soma,$3)} expr MINUS expr {Binop ($1,Diff,$3)} expr TIMES expr {Binop ($1,Mult,$3)} expr DIV expr {Binop ($1,Div,$3)} MINUS expr %prec uminus {Neg $2} ;

19 Algumas Considerações A analise da AST pelas fases de compilação seguintes pode resultar na detecção de erros. Neste caso como assinalar esta ocorrência de forma conveniente, por exemplo indicando a localização precisa da localização. De facto o processamento da AST já não ocorre com o contacto directo do ficheiro fonte. Por isso é necessário juntar na AST toda a informação necessária a localização física das estruturas contidas na AST (ou seja do local concreto no ficheiro onde ocorrem as estruturas arquivadas na AST). O OcamlYacc disponibiliza vários mecanismos para tal processamento (ver os tipos de dados position e lexbuf do módulo Lexing).

20 Algumas Considerações (Do manual de referencia - Módulo Lexing): Note that the lexing engine will only manage the pos cnum field of lex curr p by updating it with the number of characters read since the start of the lexbuf. For the other fields to be accurate, they must be initialised before the first use of the lexbuf, and updated by the lexer actions. Da mesma forma, um dos aspectos importantes por considerar e o tipo da informação contida na AST. Esta informação irá ser calculada na fase seguinte e integrada na AST em si (decoração da AST). Como tal esta informação deve já ser contemplada na fase da definição da AST. Assim de forma geral, cada informação relevante às fases posteriores podem ser acrescentada a AST para um processamento adequado.

21 Arith - Um exemplo completo open Lexing type type_expr = Undef INT FLOAT type binop = Sum Diff Prod Quot type expr = F of float * position * position I of int * position * position Var of string * type_expr * position * position Op of binop * expr * expr * type_expr * position * position Neg of expr * type_expr * position * position Letin of string * expr * expr * type_expr * position * position type instr = Set of string * expr * position * position Print of expr * position * position Dummy type prg = instr list

22 Arith - Um exemplo completo { open Lexing (...) (* funç~ao para a visualizaç~ao de mensagens de erros léxicos *) let print_lexing_error st pos = prerr_string ("Erro Léxico em "^pp_position pos^"\n\ta sequ^encia \""^ st^"\" n~ao é autorizada\n") let kwd_tbl = ["let",let ;"in",in ;"set",set;"print",print] let id_or_kwd s = try List.assoc s kwd_tbl with _ -> IDENT(s) (* A posiç~ao exacta no ficheiro é algo da responsabilidade do utilizador.. Esta funç~ao, chamada quando é detectada um fim de linha incrementa o número de linha e actualiza o campo pos_bol. Relembramos que o único campo da responsabilidade do ocamllex é o campo pos_cnum que arquiva o número de caracteres entre o início do ficheiro e a posiç~ao actual. Assim, para calcular a posiç~ao na linha corrrente basta calcular pos_cnum - pos_bol *) let incr_pos lx = let pos = lx.lex_curr_p in lx.lex_curr_p <- {pos with pos_bol = pos.pos_cnum ; pos_lnum = pos.pos_lnum +1} } let letter = [ a - z A - Z ] let digit = [ 0-9 ] let ident = letter (letter digit _ )* let integer = digit+ let floatn = integer. integer? let space = [ \r \t ]

23 Arith - Um exemplo completo rule nexttoken = parse space+ { nexttoken lexbuf } \n { incr_pos lexbuf ; nexttoken lexbuf} ident { id_or_kwd (lexeme lexbuf) } + { PLUS } - { MINUS } * { TIMES } / { DIV } = { EQ } ( { LP } ) { RP } ; { DOT } floatn { Fl (float_of_string (lexeme lexbuf)) } integer { In (int_of_string (lexeme lexbuf)) } eof { EOF } "//" [^ \n ] { nexttoken lexbuf} "(*" { comment lexbuf ; nexttoken lexbuf } "*)" {(print_lexing_error "unbalanced comments");nexttoken lexbuf) _ {(print_lexing_error (lexeme lexbuf) lexbuf.lex_curr_p); nexttoken lexbuf} and comment = parse "(*" { comment lexbuf; comment lexbuf } "*)" { () } \n { incr_pos lexbuf ; comment lexbuf} _ { comment lexbuf } eof { print_lexing_error "unbalanced comments");nexttoken lexbuf }

24 Arith - Um exemplo completo %{ open Ast (...) let parse_error msg = prerr_string msg %} %token <int> In %token <float> Fl %token <string> IDENT %token SET LET IN PRINT EOF LP RP PLUS MINUS TIMES DIV EQ DOT %nonassoc IN %left MINUS PLUS %left TIMES DIV %nonassoc uminus %start prog %type < Ast.prg > prog

25 Arith - Um exemplo completo %% prog: instrs EOF {List.rev $1)}; instrs: instr {[$1]} instrs instr {$2::$1} instrs error {pp_syntax_error (rhs_start_pos 2) (rhs_end_pos 2);$1}; instr: SET IDENT EQ expr DOT {Set($2,$4,symbol_start_pos (), symbol_end_pos ())} PRINT expr DOT {Print($2,symbol_start_pos (), symbol_end_pos ())}; expr: Fl {F($1,symbol_start_pos (), symbol_end_pos ())} In {I($1,symbol_start_pos (), symbol_end_pos ())} IDENT {Var ($1, undef_type,symbol_start_pos (), symbol_end_pos ())} expr PLUS expr {Op(Sum,$1,$3, Undef,symbol_start_pos (), symbol_end_pos ())} expr MINUS expr {Op(Diff,$1,$3, Undef,symbol_start_pos (), symbol_end_pos ())} expr TIMES expr {Op(Prod,$1,$3, Undef,symbol_start_pos (), symbol_end_pos ())} expr DIV expr {Op(Quot,$1,$3, Undef,symbol_start_pos (), symbol_end_pos ())} MINUS expr %prec uminus {Neg ($2, Undef,symbol_start_pos (), symbol_end_pos ())} LET IDENT EQ expr IN expr {Letin($2,$4,$6, Undef,symbol_start_pos (), symbol_end_pos ())} LP expr RP {$2};