Programa fonte token padrões lexema Tokens

Transcrição

1 Análise Léxica Analisador Léxico Primeira fase de um compilador. Objetivo: ler os caracteres de entrada e produzir como saída uma seqüência de tokens que o parser vai usar para análise sintática. Programa fonte analisador léxico token pede próximo token tabela de símbolos parser 1 2 Construindo um Analisador Léxico Outras Possíveis Tarefas do Analisador Léxico Especificar tokens e lexemas da linguagem. Implementar (ou gerar através de ferramenta) o analisador a partir da especificação. Tratamento de espaços em branco e comentários. Tratamento de mensagens de erro (localização / impressão). 3 4 Por que usar um Analisador Léxico? Tokens, Padrões e Lexemas Design mais simples misturar análise léxica com sintática torna o parser bem mais complicado. Eficiência separação possibilita construir processadores léxicos e sintáticos mais eficientes. Portabilidade variações de dispositivos podem ficar restritas ao analisador léxico. Existem conjuntos de strings na entrada que geram o mesmo token. Elas são descritas por padrões associados ao token. O padrão casa cada string do conjunto. Um lexema é uma seqüência de caracteres do programa fonte que casa com um padrão de um token. Tokens são símbolos terminais da linguagem

2 Tokens, Padrões e Lexemas Tokens normalmente são palavras-chave, operadores, identificadores, constantes, strings literais e símbolos de pontuação, como parenteses e vírgulas. Padrões normalmente são especificados por expressões regulares. Tokens, Padrões e Lexemas TOKEN LEXEMAS DESCRIÇÃO const const const if if if relação <, <=, =, < >, > < ou <= ou id pi, count, D2 Letra seguida de letras e/ou dígitos num , 0, 6.02E23 Constante numérica literal pequeno exemplo Quaisquer caracteres entre exceto aspa 7 8 Dificuldades na Implementação de um Analisador Léxico Linguagens que requerem determinados construtores em posições (colunas) específicas da linha de entrada (e.g. Fortran). Tratamento de espaços em branco. Ausência de palavras reservadas. Dificuldades - Exemplos Fortran: DO 5 I = 1.25 DO 5 I = 1,25 PL/I: IF THEN THEN THEN = ELSE; ELSE ELSE = THEN; 9 10 Atributos de um Token Ao reconhecer um token num é relevante saber se seu valor é zero ou um, por exemplo. Geralmente associado a um token existe um atributo. Uso da tabela de símbolos para guardar informações auxiliares sobre tokens. Atributos de um Token - Exemplo E = M * C ** 2 <id, apontador p/ posição de E na tabela de símbolos> <atrib_op,> <id, apontador p/ posição de M na tabela de símbolos> <mult_op,> <id, apontador p/ posição de C na tabela de símbolos> <exp_op,> <num, valor 2>

3 Erros de Análise Léxica Relativamente raros. fi(a == f(x)) Geralmente o analisador tenta se recuperar do erro, ignorando caracteres modalidade pânico. remover um caracter estranho inserir um caracter ausente substituir um caracter incorreto por um correto transpor dois caracteres adjacentes. Opções de Implementação de um Analisador Léxico Uso de um gerador de analisadores léxicos, como lex ou flex, que produzem um analisador léxico a partir de uma especificação em expressões regulares. Escrever o analisador em uma linguagem de programação convencional, usando as facilidades de E/S da linguagem para ler a entrada. Escrever o analisador léxico em assembly, gerenciando explicitamente a leitura. Obs: Uso de bufferização da entrada é importante para a eficiência de um analisador léxico Bufferização da Entrada Bufferização da Entrada Uso de sentinelas. Função: reduzir a sobrecarga imposta no processamento de um caractere. Uso de um buffer dividido em duas metades, com N caracteres cada uma. Leitura de N caracteres de entrada através de um único comando. : : : E : : = : M : * : eof C : * : * : 2 : eof : : : : eof apontador_adiante ++; início_de_lexema se apontador_adiante == eof se apontador_adiante == fim da 1 a metade recarregar 2 a metade; apontador_adiante ++; senão se apontador_adiante == fim da 2 a metade recarregar 1a metade; mover apontador_adiante p/ início 1 a metade; senão terminar a análise léxica; 15 apontador_adiante 16 Especificação dos Tokens Expressões regulares notação importante para especificar padrões. Baseado na Teoria das Linguagens: alfabetos, cadeias e linguagens Operações sobre linguagens: união, concatenação e fechamento Exemplo: seja L o conjunto (de letras) {A,B,,Z,a,b,,z e D o conjunto (de dígitos) {0,1,,9. Operadores sobre Linguagens OPERAÇÃO DEFINIÇÃO união de L e M, L M = {s s L escrita L M ou s M concatenação de L e M, LM = { st s L e escrita LM t M fechamento Kleene de L, L* = i = 0, L i escrito L* fechamento positivo de L, L + = i = 1, L i escrito L

4 Operações sobre Linguagens - Exemplo L D conjunto composto de letras e dígitos. LD conjunto de strings compostas de letras seguidas de dígitos. L 4 conjunto de todas as strings com 4 letras. L* conjunto de todas as strings de letras, inclusive a string vazia. D + conjunto de strings de um ou mais dígitos. L(L D)*? Propriedades Algébricas é comutativa e associativa concatenação é associativa concatenação se distribui sobre é o elemento identidade da concatenação * é idempotente Expressões Regulares Expressões Regulares O operador unário * possui a maior precedência e é associativo à esquerda. A concatenação tem a segunda maior precedência e é associativo à esquerda. possui a menor precedência e é associativo à esquerda. (a) ((b)*(c)) a b*c Permitem a definição de linguagens a partir de definições de expressões regulares mais simples. Exemplos: Identificadores em C: letra (letra dígito) * a b (a b) (a b) a* (a b)* a a*b Expressões Regulares Definição de Linguagem Regular Autômato Finito descreve uma linguagem. ER é uma formalização algébrica de um AF. Linguagem descrita por uma ER G Linguagem Regular: L(G). Comandos que pesquisam palavras (grep) padrão definido por uma ER A constante é uma expressão regular. L( )={ Qualquer símbolo a é uma ER. L(a)={a Uma variável L representa uma Linguagem Regular

5 Definição de Linguagem Regular Se E e F são ER s então E F é uma ER. L(E F) = L(E) L(F) Se E e F são ER s então EF é uma ER. L(EF)=L(E)L(F) Se E é uma ER então E* é uma ER. L(E*)=(L(E))* Se E é uma ER então (E) é uma ER. L((E))=L(E) Exemplos (0 1) * (0 1) * (0 11) 0 * (0 * 10 * 10 * 10 * ) * palavras que contêm 001. palavras com pelo menos um par de 0 s consecutivos. palavras de comprimento par, com 0 s nas posições ímpares ER s e Autômatos Finitos Os AF definem Linguagens. Equivalência entre AFND e AFD. ER definem Linguagens Regulares. Geradores de Analisadores Léxicos (Lex ou Flex) constroem AFD s a partir de definições regulares. ER s e Autômatos Finitos Equivalência entre ER s e AF s: ER s e Autômatos Finitos L( ) = { ER s e Autômatos Finitos L(R S) = L(R) L(S) L(a) = {a L(RS) = L(R)L(S)

6 ER s e Autômatos Finitos L(R * ) = (L(R)) * Exemplo: R = (1 01) * (0 ) E = (a b) * abb Definições Regulares Nomeia expressões regulares. Definição regular é uma seqüência de definições: d 1 r 1 d 2 r 2... d n r n d i é um nome distinto e r i, uma expressão de símbolos em Σ {d 1,d 2,...,d i Exemplo - Pascal letra A B Z a b z dígito0 1 9 idletra (letra dígito)* dígitosdígito dígito* fração_opc. dígitos expoente_opc(e (+ - ) dígitos) num dígitos fração_opc expoente_opc Simplificações Notacionais + uma ou mais instâncias. r+ rr*? zero ou uma instância. r? r [ ] classes de caracteres. Ex: [abc] a b c [a-z] a b z [A-Za-z][A-Za-z0-9]* Simplificações Notacionais Conjuntos Não-Regulares dígitos dígito dígito* fração_opc. dígitos expoente_opc (E (+ - ) dígitos) num dígitos fração_opc expoente_opc r+ rr* r? r dígitosdígito + fração_opc (. dígitos)? expoente_opc (E (+ -)? dígitos)? num dígitos fração_opc expoente_opc Impossibilidade de algumas linguagens serem descritas por qualquer expressão regular. Expressões regulares não podem ser usadas para descrever parênteses balanceados ou construções aninhadas

7 Reconhecimento de Tokens Gerar diagramas de transição e depois implementar uma máquina de estados. Implementar autômatos finitos determinísticos e nãodeterminísticos. Usar uma linguagem gerada pela seguinte gramática: cmd if expr then cmd if expr then cmd else cmd expr termo termo termo termo id num Reconhecimento de Tokens Definições regulares: if if then then else else < <= = < > > >= id letra(letra dígito)* num dígito + (.dígito + )?(E(+ -)?dígito + )? delim branco tabulação avanço de linha ws delim Reconhecimento de Tokens EXPRESSÃO REGULAR ws if then else id num < <= = < > > >= TOKEN if then else id num VALOR DE ATRIBUTO apontador para entrada da tabela apontador para entrada da tabela LT LE EQ NE GT GE Diagramas de Transições Passo intermediário na geração de um analisador léxico. Delineiam ações quando um analisador léxico é chamado pelo parser. Assumimos que os próximos diagramas de transições sejam determinísticos. estado de partida rótulo 1 rótulo Diagramas de Transições Para operadores relacionais: Diagramas de Transições Para identificadores e palavras-chave, e para espaços:

8 Diagramas de Transições Para números sem sinal em Pascal: Código C - Próximo Estado de Partida Código C do Analisador Léxico token próximo_token() { while(1) { switch(estado) { case 0: c = next_char(); if(c == c == \t c == \n ) { estado = 0; inicio_de_lexema++; else if(c == < ) estado = 1; else if(c == = ) estado = 5; else if(c == > ) estado = 6; else estado = falhar(); break;... /* inserir código para casos 1-8 aqui */ Código C do Analisador Léxico case 9: c = next_char(); if(isletter(c)) estado = 10; else estado = falhar(); break; case 10: c = next_char(); if(isletter(c)) estado = 10; else if(isdigit(c) estado = 10; else estado = 11; break; case 11: retrair(1); instalar_id(); return(obter_token());... /* inserir casos aqui */ Código C do Analisador Léxico Ferramenta Lex case 25: c = next_char(); if(isdigit(c)) estado = 26; else estado = falhar(); break; case 26: c = next_char(); if(isdigit(c)) estado = 26; else estado = falhar(); break; case 27: retrair(1); instalar_num(); return(num); Ferramenta Lex Compilador Lex. Especificação de entrada Linguagem Lex. Programa gerado representação tabular de um diagrama de transições. Ações associadas às expressões regulares trechos de códigos em C

9 Linguagem Lex Linguagem (e compilador) para especificar analisadores léxicos. Criando um analisador léxico com Lex: programa fonte Lex lex.l lexyy.c fluxo de caracteres de entrada Compilador Lex Compilador C a.out lexyy.c a.out seqüência de tokens Especificações Lex Formato: declarações variáveis, constantes, definições regulares regras de tradução expressões regulares e ações em C procedimentos auxiliares Funcionamento do Lex ativado leitura da entrada um caractere por vez encontra o mais longo prefixo reconhecido por uma das expressões regulares executa a ação correspondente retorna o token apropriado. Figurações Importantes do Lex Declaração de constantes e variáveis (1 a seção) são envolvidas por chaves especiais (%{ e %). Procedimentos auxiliares (3 a seção) também são copiados diretamente no analisador léxico lexyy.c. Metassímbolos em Lex: ( )? \ Expressões Regulares em Lex Um Programa Lex. a. [a-z$] [abj-oz] [^aa] [A-Z][A-Z0-9]* [+-]?[0-9]+ a{3,5 [^A-Z] %{ int num_lines = 0, num_chars = 0; % \n ++num_lines; ++num_chars;. ++num_chars; main() { yylex(); printf( linhas = %d,caracteres = %d\n, num_lines, num_chars); int yywrap() { return(1);

10 Um Outro Programa Lex Programa Lex - Analex {id printf( Identificador: %s\n, yytext); { [^\n]* /* nada */ %{ /* definição de constantes LT,LE,EQ,NE,. printf( Caractere desconhecido: %s\n, GT,GE,IF,THEN,ELSE,ID,NUMERO,RELOP */ yytext); % /* definições regulares */ void main(int argc, char *argv[]){ delim [ \t\n] ++argv, --argc; ws {delim+ if (argc > 0) letra [A-Za-z] yyin = fopen(argv[0],"r"); else digito [0-9] yyin = stdin; id {letra({letra {digito)* yylex(); numero {digito+(\.{digito+)? (E[+\-]?{digito+)? int yywrap(){ return(1); Programa Lex - Analex {ws {/* nenhuma ação, nenhum ret. */ if {return(if); then {return(then); else {return(else); {id {yylval = instalar_id(); return(id); {numero {yylval = instalar_num(); return(numero); "<" {yylval = LT; return(relop); "<=" {yylval = LE; return(relop); "=" {yylval = EQ; return(relop); "<>" {yylval = NE; return(relop); Programa Lex - Analex ">" {yylval = GT; return(relop); ">=" {yylval = GE; return(relop); int instalar_id(){ /* Copia lexema para a tabela de símbolos. Primeiro caracter do lexema é apontado pela variável yytext e o comprimento é definido pela variável yyleng. */ int instalar_num() {