Compiladores / YACC Professor Ariel da Silva Dias YACC. Adaptação da obra original de Tom Niemann

Transcrição

1 YACC YACC Adaptação da obra original de Tom Niemann As gramáticas para yacc são descritas usando uma variante da BNF. Esta técnica, foi usada por John Backus e Peter Naur foi para descrever ALGOL60. Em uma BNF a gramática pode ser usada para expressar gramáticas livres de contexto. A maioria das construções nas modernas linguagens de programação pode ser representada pela BNF. Por exemplo, a gramática de uma expressão que multiplica e adiciona números é: 1 E -> E + E 2 E -> E * E 3 E -> id Três produções foram especificadas. Termos que aparecem no left-hand side (lhs) de uma produção, como E, são não-terminais. Termos como id (identificador) são terminais (tokens retornados por lex) e só aparecem no right-hand side (rhs) de uma produção. Essa gramática especifica que uma expressão pode ser a soma de duas expressões, o produto de duas expressões ou um identificador. Podemos usar essa gramática para gerar expressões: E -> E * E (r2) -> E * z (r3) -> E + E * z (r1) -> E + y * z (r3) -> x + y * z (r3) Em cada passo, expandimos um termo e substituímos o lado esquerdo de uma produção com o correspondente lado direito. Os números à direita indicam qual regra aplicada. Para analisar uma expressão, precisamos fazer a operação inversa. Em vez de começar com um único não-terminal (símbolo inicial) e gerar uma expressão a partir de uma gramática, precisamos reduzir uma expressão a um único não-terminal. Isso é conhecido como análise bottom-up ou shift-reduce e usa uma pilha para armazenar termos. Aqui está a mesma derivação, mas na ordem inversa: 1. x + y * z shift 2 x. + y * z reduce(r3) 3 E. + y * z shift 4 E +. y * z shift 5 E + y. * z reduce(r3)

2 6 E + E. * z shift 7 E + E *. z shift 8 E + E * z. reduce(r3) 9 E + E * E. reduce(r2) emit multiply 10 E + E. reduce(r1) emit add 11 E. accept Os termos à esquerda do ponto estão na pilha, enquanto a entrada restante está à direita do ponto. Começamos trocando fichas para a pilha. Quando o topo da pilha corresponde ao lado esquerdo de uma produção, substituímos os tokens correspondentes na pilha com o lado esquerdo da produção. Em outras palavras, os tokens correspondentes do lado direito são retirados da pilha, e o lado esquerdo da produção é empurrada na pilha. Os tokens correspondentes são conhecidos como alça e estamos reduzindo a alça ao lado esquerdo da produção. Esse processo continua até que tenhamos deslocado toda a entrada para a pilha e apenas reste os não-terminais iniciados na pilha. No passo 1, nós mudamos x para a pilha. Passo 2 aplica a regra r3 para a pilha para mudar x para E. Continuamos mudando e reduzindo até que um único não-terminal, o símbolo inicial, permaneça na pilha. Na etapa 9, quando reduzimos a regra r2, emitimos a instrução de multiplicação. Da mesma forma, a instrução add é emitida na etapa 10. Consequentemente, a multiplicação tem uma precedência maior que a adição. Considere a mudança no passo 6. Em vez de mudar, poderíamos ter reduzido e aplicar a regra r1. Isso resultaria em adição, tendo uma precedência maior do que a multiplicação. Isso é conhecido como um conflito de redução de turno. Nossa gramática é ambígua porque há mais de uma derivação possível que produzirá a expressão. Nesse caso, a precedência do operador é afetada. Como outro exemplo, associatividade na regra E -> E + E é ambíguo, pois podemos recorrer à esquerda ou à direita. Para remediar a situação, poderíamos reescrever a gramática ou fornecer ao yacc diretivas que indicam qual operador tem precedência. O último método é mais simples e será demonstrado na seção de prática. A gramática a seguir tem um conflito reduzir-reduzir. Com um id na pilha, podemos reduzir para T ou E. E -> T E -> id T -> id

3 Yacc toma uma ação padrão quando há um conflito. Para conflitos de redução de turnos, o yacc mudará. Para conflitos com redução de redução, ele usará a primeira regra na listagem. Também emite uma mensagem de aviso sempre que houver um conflito. Os avisos podem ser suprimidos, tornando a gramática não ambígua.

4 Praticando (Calculadora 1) A entrada para yacc é dividido em três seções. A seção de definições consiste em declarações de token e código C entre " %{" e " %". A gramática é colocada na seção de regras e as sub-rotinas de usuários são adicionadas na seção de sub-rotinas. Isso é melhor ilustrado pela construção de uma pequena calculadora que pode adicionar e subtrair números. Vamos começar examinando a ligação entre lex e yacc. Aqui está a seção de definições para o yacc Arquivo de entrada: %token INTEGER Esta definição declara um INTEGER token. O Yacc gera um analisador no arquivo y.tab.c e um arquivo de inclusão y.tab.h: #ifndef YYSTYPE #define YYSTYPE int #endif #define INTEGER 258 extern YYSTYPE yylval; Lex inclui este arquivo e utiliza as definições para valores de token. Para obter saída yacc chamadas yylex. A função yylex tem um tipo inteiro que retorna um token. Os valores associados ao token são retornados por lex na variável yylval. Por exemplo, [0-9]+ { yylval = atoi(yytext); return INTEGER; armazenaria o valor do inteiro yylval e retornaria o símbolo INTEGER para o yacc. O tipo de yylval é determinado por YYSTYPE. Como o tipo padrão é inteiro, isso funciona bem nesse caso. Valores de token são reservados para valores de caractere. Por exemplo, se você tivesse uma regra como [-+] return *yytext; /* return operator */ o valor do caractere para menos ou mais é retornado. Observe que colocamos o sinal de menos primeiro para que não seja confundido com um designador de intervalo. Os valores de token gerados geralmente começam em torno de 258 porque lex reserva vários valores para

5 processamento de fim de arquivo e erro. Aqui está o arquivo lex completo com especificação de entrada para nossa calculadora (calc1.l): %{ % #include "y.tab.h" #include <stdlib.h> void yyerror(char *); [0-9]+ { yylval = atoi(yytext); return INTEGER; [-+\n] return *yytext; [ \t] ; /* espaço em branco */. yyerror("caracter invalido"); int yywrap(void) { return 1; Internamente yacc mantém duas pilhas na memória; uma pilha de análise e uma pilha de valores. A pilha de análise contém terminais e nãoterminais que representam o estado de análise atual. A pilha de valores é uma matriz de elementos do tipo YYSTYPE e associa um valor a cada elemento na pilha de análise. Por exemplo quando o lex retorna um token INTEGER, o yacc desloca este token para a pilha de análise. Ao mesmo tempo, o correspondente yylval é deslocado para a pilha de valores. As pilhas de análise e valor são sempre sincronizadas, portanto, é fácil de encontrar um valor relacionado a um token na pilha. Aqui está o yacc especificação de entrada para nossa calculadora (calc1.y): %{ % #include <stdio.h> int yylex(void); void yyerror(char *); %token INTEIRO

6 program: program expr '\n' $2); ; { printf("%d\n", expr: INTEIRO { $$ = $1; expr '+' expr { $$ = $1 + $3; expr '-' expr { $$ = $1 - $3; ; void yyerror(char *s) { fprintf(stderr, "%s\n", s); int main(void) { yyparse(); return 0; A seção de regras é semelhante à gramática BNF discutida anteriormente. O lado esquerdo de uma produção, ou não-terminal, é inserido à esquerda e seguido por dois pontos. Isto é seguido pelo lado direito da produção. Ações associadas a uma regra são inseridas entre chaves. Com a recursão à esquerda, especificamos que um programa consiste em zero ou mais expressões. Cada expressão termina com uma nova linha. Quando uma nova linha é detectada, imprimimos o valor da expressão. Quando aplicamos a regra expr: expr '+' expr { $$ = $1 + $3; Nós substituímos o lado direito da produção na pilha de análise com o lado esquerdo da mesma produção. Podemos referenciar posições na pilha de valores em nosso código C especificando " $1" para o primeiro termo no lado direito da produção, " $2" para o segundo e assim por diante. " $$" designa o topo da pilha após a redução ter ocorrido. A ação acima adiciona o valor associado a duas expressões, mostra três termos da pilha de valores e retorna uma única

7 soma. Como consequência, as pilhas de análise e valor permanecem sincronizadas. Os valores numéricos são inicialmente inseridos na pilha quando reduzimos de INTEGER para expr. Depois que o INTEGER é deslocado para a pilha, aplicamos a regra expr: INTEIRO { $$ = $1; O token INTEGER é retirado da pilha de análise seguido de um deslocamento de expr. Para a pilha de valores, removemos o valor inteiro da pilha e depois o colocamos novamente. Em outras palavras, não fazemos nada. Na verdade, esta é a ação padrão e não precisa ser especificada. Finalmente, quando uma nova linha é encontrada, o valor associado expr é impresso. No caso de erros de sintaxe yacc chama a função fornecida pelo usuário yyerror. Em seguida, compile da seguinte forma para testarmos: yacc -y -d calc1.y lex calc1.l gcc -c y.tab.c lex.yy.c gcc y.tab.o lex.yy.o -o calc1.exe

8 Praticando (Calculadora 2) Nesta seção, ampliaremos a calculadora da seção anterior para incorporar algumas novas funcionalidades. Novos recursos incluem: operadores aritméticos de multiplicação e divisão. Os parênteses podem ser usados para sobrepor a precedência do operador e variáveis de caractere único podem ser especificadas em instruções de atribuição. Abaixo ilustramos a entrada de amostra e a saída da calculadora: usuario: 3 * (4 + 5) calculadora: 27 usuario: x = 3 * (4 + 5) usuario: y = 5 usuario: x calculadora: 27 usuario: y calculadora: 5 usuario: x + 2*y calculadora: 37 O analisador léxico retorna os tokens VARIABLE e INTEGER. Para variáveis, yylval especifica um índice para a tabela de símbolos sym. Para este programa, sym apenas contém o valor da variável associada. Quando osinteger tokens são retornados, yylvalcontém o número digitalizado. Aqui está a especificação de entrada para lex (calc2.l): %{ % #include <stdlib.h> #include "y.tab.h" void yyerror(char *); /* variaveis */ [a-z] { yylval = *yytext - 'a'; return VARIAVEL; /* inteiros */ [0-9]+ { yylval = atoi(yytext); return INTEIRO;

9 /* operadores */ [-+()=/*\n] { return *yytext; /* espaço */ [ \t] ; /* qualquer outro caracter será um erro */. yyerror("caracter Inválido"); int yywrap(void) { return 1; A especificação de entrada para yacc segue. Os tokens para INTEGER e VARIABLE são utilizados por yacc para criar #defines em y.tab.h para uso em lex. Isto é seguido por definições para os operadores aritméticos. Podemos especificar %left, para associativo à esquerda ou %right para associativa à direita. A última definição listada tem a maior precedência. Consequentemente, multiplicação e divisão têm maior precedência do que adição e subtração. Todos os quatro operadores são associativos à esquerda. Usando esta técnica simples, podemos desambiguar nossa gramática (calc2.y). %token INTEIRO VARIAVEL %left '+' '-' %left '*' '/' %{ % void yyerror(char *); int yylex(void); int sym[26]; program: program statement '\n' ; statement: expr { printf("%d\n", $1); VARIAVEL '=' expr { sym[$1] = $3;

10 ; expr: INTEIRO VARIAVEL { $$ = sym[$1]; expr '+' expr { $$ = $1 + $3; expr '-' expr { $$ = $1 - $3; expr '*' expr { $$ = $1 * $3; expr '/' expr { $$ = $1 / $3; '(' expr ')' { $$ = $2; ; void yyerror(char *s) { fprintf(stderr, "%s\n", s); int main(void) { yyparse(); return 0; Agora vamos criar a nossa calculadora: yacc -y -d calc2.y lex calc2.l gcc -c y.tab.c lex.yy.c gcc y.tab.o lex.yy.o -o calc2.exe

11 Praticando (Calculadora 3) Esta versão da calculadora é substancialmente mais complexa que as versões anteriores. As principais alterações incluem: instruções de controle, como if-else e while. Além disso, uma árvore de sintaxe é construída durante a análise. Após a análise, percorremos a árvore sintática para produzir a saída. Três versões da rotina de caminhada na árvore são fornecidas: um intérprete que executa declarações durante a caminhada na árvore um compilador que gera código para uma máquina baseada em pilha hipotética uma versão que gera uma árvore de sintaxe do programa original. Para tornar as coisas mais concretas, aqui está um exemplo de programa que pode ser reconhecido pela nossa calculadora, x = 0; while (x < 3) { print x; x = x + 1; com saída para uma versão interpretativa, uma versão do compilador, push 0 pop x L000: push x push 3 complt jz L001 push x print push x push 1 add pop x jmp L000

12 L001: e uma versão que gera uma árvore de sintaxe. Graph 0: [=] ---- id(x) c(0) Graph 1: while [<] [;] id(x) c(3) print [=] id(x) id(x) [+] ---- id(x) c(1) O arquivo de inclusão contém declarações para a árvore de sintaxe e a tabela de símbolos. A tabela de símbolos (sym) permite nomes de variáveis de um único caractere. Um nó na árvore de sintaxe pode conter uma constante (connodetype), um identificador (idnodetype) ou um nó interno com um operador (oprnodetype). Uma união encapsula todas as três variantes. O nodetype.type é usada para determinar qual estrutura nós temos. O arquivo de entrada lex contém padrões para os tokens VARIAVEL e INTEIRO. Além disso, os tokens são definidos para operadores de 2 caracteres, como EQ e NE. Operadores de caractere único são simplesmente retornados como eles mesmos. O arquivo de entrada do YACC define YYSTYPE, o tipo de yylval, como

13 %union { int ivalue; /* valor inteiro */ char sindex; /* índice da tabela de simbolo */ nodetype *nptr; /* nó ponteiro */ ; Isso faz com que o seguinte seja gerado em y.tab.h: typedef union { int ivalue; /* valor inteiro */ char sindex; /* índice da tabela de simbolo */ nodetype *nptr; /* nó ponteiro */ YYSTYPE; extern YYSTYPE yylval; Constantes, variáveis e nós podem ser representados por yylval na pilha de valores do analisador. Uma representação mais precisa de inteiros decimais é dada abaixo. Isso é semelhante a C/C++ onde inteiros que começam com 0 são classificados como octal. 0 { yylval.ivalue = atoi(yytext); return INTEIRO; [1-9][0-9]* { yylval.ivalue = atoi(yytext); return INTEIRO; Observe as definições de tipo %token <ivalue> INTEIRO %type <nptr> expr Isso liga expr a nptr, e a união com INTEIRO e ivalue na YYSTYPE. Isso é necessário para que yacc possa gerar o código corretamente. Por exemplo, a regra expr: INTEGER { $$ = con($1); deve gerar o código a seguir. Observe que yyvsp[0] corresponde ao topo da pilha de valores ou o valor associado ainteger.

14 yylval.nptr = con(yyvsp[0].ivalue); O operador menos unário recebe maior prioridade que os operadores binários da seguinte maneira: %left GE LE EQ NE '>' '<' %left '+' '-' %left '*' '/' %nonassoc UMINUS O %nonassoc indica que não há associatividade implícita. É frequentemente usado em conjunto com %prec para especificar a precedência de uma regra. Assim, nós temos expr: '-' expr %prec UMINUS { $$ = node(uminus, 1, $2); indicando que a precedência da regra é a mesma que a precedência do token UMINUS. E UMINUS (conforme definido acima) tem precedência mais alta que os outros operadores. Uma técnica semelhante é usada para remover a ambiguidade associada à instrução if-else. A árvore de sintaxe é construída de baixo para cima, alocando os nós folha quando variáveis e números inteiros são reduzidos. Quando os operadores são encontrados, um nó é alocado e os ponteiros para estes nós são inseridos como operandos. Depois que a árvore é construída, a função ex é chamada para fazer uma caminhada em profundidade da árvore de sintaxe. Isso resulta em operadores sendo aplicados na ordem em que foram encontrados durante a análise. Temos três versões para o ex: uma versão interpretativa uma versão do compilador uma versão que gera uma árvore de sintaxe Os arquivos deste projeto (Calculadora 1, Calculadora 2 e Calculadora 3) estão anexos no site na disciplina de Compiladores.

15 Referência Niemann, Tom. Lex & YACC. Disponível em: epaperpress.com.