Relatório da Árvore de Execução e Executor. Fabrício Vazole Lilian Lahas

Transcrição

1 Relatório da Árvore de Execução e Executor Fabrício Vazole Lilian Lahas Vitória, ES Setembro de 2003

2 Sumário 1. Introdução Projeto Arquitetura do Compilador Tabela de Variáveis Tabela de Funções Primitivas Tabela de Programas Analisador Léxico Ferramenta Estrutura do arquivo de descrição Código Analisador Sintático Ferramenta Estrutura do arquivo de descrição Código Analisador Contexto Gerador de Código Executor de Código Exemplos de Programas Ambiente de Execução Menu MakeFile... 37

3 1. Introdução O trabalho consiste em criar um tradutor e um interpretador para a linguagem µpascal. A função do tradutor é ler um programa escrito na linguagem escolhida e montar uma árvore de execução. Já função do interpretador é executar um programa, dada sua árvore de execução. Além disso, faz parte do trabalho criarmos um ambiente de compilação e execução de programas que permita que um usuário compile e execute programas. Nas próximas seções detalharemos a construção e o funcionamento do compilador e do ambiente de execução. 2. Projeto O projeto é dividido em duas partes: o compilador e o ambiente de execução de programas. Iremos detalhar a arquitetura de ambos nas próximas seções. Utilizamos como plataforma de implementação Linux e linguagem de programação C. Não esquecendo de informar que também foram utilizadas as ferramentas Flex e Bison na análise semântica e sintática, respectivamente Arquitetura do Compilador O compilador possui basicamente quatro módulos principais. Abaixo, estão listados os passos gerais do funcionamento do compilador e a relação entre cada módulo. Analisador Léxico: É responsável por ler o código fonte e, utilizando regras definidas previamente de acordo com a linguagem, analisa cada vocábulo (token) classificando-os de acordo. O termo e a sua classe são enviados para o analisador sintático; Analisador Sintático: Recebe os termo e, segundo uma gramática fornecida, analisa a combinação destes para verificar a validade das expressões. Logo seu propósito é verificar se a sintaxe do programa está de acordo com a linguagem de programação utilizada; Analisador de Contexto: Trabalha durante a análise sintática verificando a validade na utilização dos termos através da realização das ações semânticas; Gerador da Árvore de Execução: termina o processo de interpretação do código e grava em memória a árvore para ser, depois, executada.

4 Abaixo apresentamos o funcionamento do compilador.

5 3. Tabela de Variáveis Abaixo se encontra o código da nossa tabela de variáveis que está no arquivo TabVar.c e TabVar.h. É importante destacar que para melhoria da consulta, a inserção é feita com o auxílio de uma função chamada Hash apresentada abaixo: /********************************************************** Função:hash Descrição:Dado um símbolo encontra a posição na tabela hash **********************************************************/ int hash(char *item){ int i; int posic=0; for(i=0;item[i]!=0;i++){ posic=posic + item[i]; posic=posic%m; return posic; Abaixo temos as definições da estrutura tabela e declarações de funções. #ifndef TabVar_H #define TabVar_H #include "hash.h" typedef struct Termo{ int tipo; int valor; Termo; /*Estrutura da Lista de Variáveis*/ typedef struct Variavel{ char palavra[max_string]; int tipo; Termo termo; struct Variavel *next; Variavel;

6 /*Funções*/ Variavel *newvar(char *); void initstack(); Variavel **newtabvar(); void inittabvar(variavel**); void inserevariavel(variavel** TabVar, Variavel* var,int posic); int consulta(variavel** TabVar,char *item); Variavel *consulta_var(variavel** TabVar,char *item); Abaixo apresentamos a implementação das funções acima definidas. /*********************************************************** Implementação da Tabela de Variáveis ***********************************************************/ #include <stdlib.h> #include <string.h> #include <stdio.h> #include "TabVar.h" #include "TabProg.h" extern Programa *programa; /*********************************************************** Função:newVariavel Descrição:Cria uma nova variável ***********************************************************/ Variavel *newvar(char *item){ Variavel *var=(variavel*)malloc(sizeof(variavel)); strcpy(var->palavra,item); var->termo.valor=0; var->next=null; return var;

7 Variavel **newtabvar(){ Variavel **TabVar=(Variavel**) malloc(sizeof(variavel*)*m); return TabVar; void inittabvar(variavel **TabVar){ int i; for (i=0;i<m;i++) TabVar[i]=NULL; /*********************************************************** Função:insereVariavel Descrição:Insere um Variavel na Tabela HasH ***********************************************************/ void inserevariavel(variavel** TabVar, Variavel* var,int posic){ if(consulta(tabvar, var->palavra)==false){ Variavel *aux=tabvar[posic]; if (aux==null){ TabVar[posic]=var; else{ while (aux->next!= NULL) aux=aux->next; aux->next= var; /*********************************************************** Função:consulta Descrição: Consulta um elemento na lista ***********************************************************/ int consulta(variavel**tabvar,char *item){ int posic =hash(item); Variavel *aux=tabvar[posic]; while (aux!= NULL){ if (!strcmp(item,aux->palavra)) return TRUE; aux=aux->next; return FALSE;

8 4. Tabela de Funções Primitivas As funções primitivas são aquelas definidas pela linguagem, nela sabemos o nome da função que pertence à linguagem, quantidade de argumentos permitidos (aridade), o número do procedimento. Será utilizada pelo analisador léxico e de contexto. A implementação está no arquivo TabPrimitiva.c e TabPrimitiva.h. Abaixo estão as estruturas e declarações das funções primitivas. #ifndef TabPrimitiva_H #define TabPrimitiva_H #include "hash.h" /*Estrutura da Lista de Funções Primitivas*/ typedef struct FuncPrim{ char palavra[max_string]; int aridade; int procedimento; struct FuncPrim *next; FuncPrim; /*Tabela de Funções Primitivas*/ FuncPrim *TabFP[M]; /*Funções*/ void inittabfp(); FuncPrim *newfuncprim(char *,int,int); void inserefp(funcprim* TabFP[], FuncPrim* func,int posic); void iniciafp(funcprim* TabFP[],char *nome_arq); FuncPrim *busca_fp(funcprim*tabfp[],char *item); int consulta_fp(funcprim*tabfp[],char *item); int consultaaridade(funcprim* TabFP[],char *item); #endif Abaixo estão as implementações das funções.

9 /*********************************************************** Implementação da Tabela Funções Primitivas ***********************************************************/ #include <stdlib.h> #include <string.h> #include <stdio.h> #include "TabPrimitiva.h" /*********************************************************** Função:newFuncPrim Descrição:Cria um novo FuncPrim ***********************************************************/ void inittabfp(){ int i; for (i=0;i<m;i++) TabFP[i]=NULL; FuncPrim *newfuncprim(char *item, int aridade,int proc){ FuncPrim *funcprim=(funcprim*)malloc(sizeof(funcprim)); strcpy(funcprim->palavra,item); funcprim->aridade=aridade; funcprim->procedimento=proc; funcprim->next=null; return funcprim; /*********************************************************** Função:insereFuncPrim Descrição:Insere um FuncPrim na Tabela HasH ***********************************************************/ void inserefuncprim(funcprim* TabFP[], FuncPrim* funcprim,int posic){ FuncPrim *aux=tabfp[posic]; if (aux==null){ TabFP[posic]=funcPrim; else{ while (aux->next!= NULL) aux=aux->next; aux->next= funcprim;

10 /*********************************************************** Função:carregaTS Descrição:Carrega os FuncPrims de um arquivo para a tabela de símbolos ***********************************************************/ void iniciafp(funcprim* TabFP[],char *nome_arq){ FILE *fp; char palavra[max_string]; int proc,aridade; int posic; /*Abrir arquivo para leitura*/ if (( fp = fopen(nome_arq, "r")) == NULL) { printf("nao foi possivel abrir o arquivo para leitura.\n"); else{ while (!feof(fp)){ FuncPrim *funcprim; memset(palavra,0,max_string); fscanf(fp,"%s", palavra); fscanf(fp,"%d",&aridade); fscanf(fp,"%d",&proc); if (!consulta_fp(tabfp,palavra)){ funcprim=newfuncprim(palavra,aridade,proc); posic=hash(palavra); inserefuncprim(tabfp,funcprim,posic); else printf("função %s redefinada,portanto não foi inserida\n"); fclose(fp); /*********************************************************** Função:consulta Descrição: Consulta um elemento na lista ***********************************************************/ int consulta_fp(funcprim*tabfp[],char *item){ int posic =hash(item); FuncPrim *aux=tabfp[posic]; while (aux!= NULL){ if (!strcmp(item,aux->palavra)) return TRUE; aux=aux->next;

11 5. Tabela de Programas Os programas compilados são inseridos na tabela de programas que se encontra implementado no arquivo TabProg.c e TabProg.h. Abaixo estão as estruturas e declarações da tabela de programas. #ifndef TabProg_H #define TabProg_H #include "hash.h" #include "TabVar.h" /*Nó de uma árvore*/ typedef struct No{ char nome[max_string]; char tipo; int valor; struct No *esq, *dir, *prox; No; /*Estrutura da tabela de programas*/ typedef struct Program{ char nome[max_string]; Variavel** TabVarProg; struct No *fst, *lst; Programa; /*Variáveis Globais*/ No *noatual, *noaux, *noauxp, *nofunc, *noprec; Programa *programa; Programa *ListPrograma[100]; /*Funções*/ Programa* inittabprog(programa*); No *newno(char *, char, int); Programa* getprograma(char *); void insereprograma(programa *); Abaixo estão as implementações das funções.

12 /*********************************************************** Implementação da Tabela de Programas ***********************************************************/ #include <stdlib.h> #include <string.h> #include <stdio.h> #include "TabProg.h" /** Variáveis externas **/ extern int gnumero; extern int gtipotermo; extern char gultvariavel[max_string]; extern int flag; int poslastprog=0; Programa* getprograma(char *nome){ int i; for (i=0;i<poslastprog;i++){ if (strcmp(listprograma[i]->nome,nome) == 0 ) return ListPrograma[i]; return NULL; void insereprograma(programa *programa){ ListPrograma[posLastProg]=programa; poslastprog++; /*********************************************************** Função:initTabProg Descrição:Cria uma nova Tabela de Programas ***********************************************************/ Programa* inittabprog(programa* programa){ programa = (Programa *) malloc(sizeof(programa)); programa->tabvarprog=newtabvar(); inittabvar(programa->tabvarprog); return programa;

13 6. Analisador Léxico 6.1. Ferramenta A ferramenta utilizada foi o FLEX, do linux. FLEX é uma ferramenta construtora de analisadores léxicos. O flex transforma um arquivo de especificações léxicas em um analisador (um programa). Abaixo apresento uma figura que mostra o funcionamento desta ferramenta Estrutura do arquivo de descrição Todo arquivo de descrição do Flex possui três seções separadas por uma linha com apenas os caracteres %% colocados em seu início, como esquematicamente ilustrado a seguir: DEFINIÇÕES %% REGRAS %% CÓDIGO Seção DEFINIÇÕES Como esperado a seção DEFINIÇÔES possui definições léxicas. É possível, no entanto que esta seção permaneça vazia, isto é, sem definições. Toda definição léxica tem a forma: Nome definição

14 Como Nome devemos usar uma palavra, iniciada por letra ou underscore ('_') seguida de uma ou mais letras, dígitos, underscore ou traços ('-'). A definição segue o nome e se inicia no primeiro caractere não branco continuando até o final da linha. Usualmente as definições são conjuntos de caracteres ou expressões regulares contidas entre colchetes. A seção DEFINIÇÕES pode ainda conter a declaração e inicialização de variáveis globais que poderão ser utilizadas nas ações e no código fornecido pelo programador Seção REGRAS A seção REGRAS possui por sua vez as regras do analisador léxico a ser construído. Esta seção sempre possui regras, pois sem estas o analisador gerado apenas copia sua entrada para a saída. Uma regra tem sempre a forma: Padrão ação O Padrão deve começar na primeira coluna do texto e são definidos como expressões regulares. A ação deve sempre ser iniciada na mesma linha e usualmente corresponde a um trecho de código C que será executado toda vez que o padrão for reconhecido na entrada. Tanto na seção de DEFINIÇÕES como de REGRAS qualquer texto identado ou entre %{e % é copiado literalmente para a saída (sem os caracteres %{e %). Para o reconhecimento dos caracteres {, e % estes devem aparecer não identados como padrões em separado. Em adição, apenas na seção de DEFINIÇÕES, qualquer texto não identado é copiado literalmente para a saída. Sob certos aspectos os caracteres %% indicam o início e o fim da seção REGRAS Seção CÓDIGO A última seção, CÓDIGO, contém todo o código C definido e fornecido pelo programador. Nesta seção usualmente temos declarada uma função main(), que define o início do programa que pode efetuar uma chamada à função yylex() (o scanner gerado por Flex). Outras funções, utilizadas nas ações definidas pelas regras, podem ser colocadas aqui. Esta seção também pode permanecer vazia, ou seja, sem código definido pelo programador. Recomenda-se ainda a declaração de uma função yywrap() como abaixo:

15 int yywrap(){ return 1; 6.3. Código O analisador léxico em nosso trabalho está implementado no arquivo AL.l. %{ #include "TabVar.h" #include "TabPrimitiva.h" #include "TabProg.h" #include <string.h> #ifndef ITS #define ITS(x) fprintf(stdout, "\t[%d]%s\n", x, yytext); return((int)(x)) #include "bison.h" #endif #ifndef verificaid #define verificaid if (consulta_fp(tabfp,yytext)){\ strcpy(gultfuncao,yytext);\ return (Tok_Fp);\ else if (consulta(programa->tabvarprog,yytext)){\ strcpy(gultvariavel,yytext);\ return (Tok_Variavel);\ else return (Tok_Iden); #endif /** Variáveis Globais **/ //Guarda o valor do ultimo termo lido char gultimotermo[max_string]; //Guarda o ultimo número lido char gultnumero[max_string]; //Guarda o nome da ultima variavel lida. char gultvariavel[max_string]; char gultfuncao[max_string]; //Guarda o nome da ultima funcao lida char gultoper[max_string]; //Guarda o nome da ultima operacao lida // Guarda o valor do ultimo número lido. int gnumero; // Guarda o tipo do ultimo termo lido. char gtipotermo;

16 // Flag para passagem de parâmetro para função. int flag = 0; % ESPACO [ \t]+ DIGITO [0-9] OPER [*+-/] ID [a-za-z][a-za-z0-9]* DELIM_VIR (,) DELIM_DP (:) DELIM_AP \( DELIM_FP \) DELIM_PV (;) FIM [.] ATR := %% "and" "array" "case" "const" "div" "do" "downto" "else" "file" "for" "function" "goto" "if" "in" "label" "mod" "nil" "not" "of" "or" "packed" "procedure" {ITS(Tok_Pr); "record" "repeat" "set" "then" "to" "type" "until" "while" "with" "program" "integer" "begin" "end" "var" "read" "write" {FIM {DELIM_VIR {ITS(Tok_Dlv ); {DELIM_DP {ITS(Tok_Dlp ); {DELIM_AP {ITS(Tok_Dla ); {DELIM_FP {ITS(Tok_Dlf ); {ITS(Tok_Pr); {ITS(Tok_Pr); {ITS(Tok_Pr); {ITS(Tok_Pr); {ITS(Tok_Pr); {ITS(Tok_Prog); {ITS(Tok_Int); {ITS(Tok_Begin); {ITS(Tok_End); {ITS(Tok_Var); {ITS(Tok_Func); {ITS(Tok_Fim); {DELIM_PV {ITS(Tok_Dlpv); {ATR {ITS(Tok_Atr); [+ -]*{DIGITO+ {strcpy(gultnumero,yytext);its(tok_num); {ID {strcpy(gultimotermo,yytext);verificaid;/*its(tok_iden);*/ {OPER {strcpy(gultoper,yytext);its(tok_op); {ESPACO {/*Não faz nada*/ \n {linhas++;doreset=1;. {printf( "Caracter desconhecido: %s\n", yytext ); %%

17 7. Analisador Sintático 7.1. Ferramenta A ferramenta utilizada para gerar o analisador sintático foi o BISON. BISON é uma ferramenta construtora de analisadores sintáticos. O bison transforma um arquivo de especificações sintáticas em um analisador (um programa). Abaixo, segue a gramática do compilador em formato BNF (Backus-Naur Form), que é a utilizada pelo Bison Estrutura do arquivo de descrição Todo arquivo de descrição do Bison possui três seções separadas por uma linha com apenas os caracteres %% colocados em seu início, como esquematicamente ilustrado a seguir: DEFINIÇÕES %% REGRAS %% CÓDIGO Seção DEFINIÇÕES Como esperado a seção DEFINIÇÔES possui definições sintáticas. Toda definição sintática tem a forma: definição nome Como nome devemos usar uma palavra, iniciada por letra ou underscore ('_') seguida de uma ou mais letras, dígitos, underscore ou traços ('-'), essa palavra pode ser o início da recursão sintática ou um vocábulo identificado no analisador léxico. A definição pode ser %token ou %start. Devo realçar que os arquivos do Flex e bison precisam ser ligados. Na seção do código estará como fazer isso. A seção DEFINIÇÕES pode ainda conter a declaração e inicialização de variáveis globais que poderão ser utilizadas nas ações e no código fornecido pelo programador Seção REGRAS A seção REGRAS possui por sua vez as regras do analisador sintático a ser construído. Esta seção sempre possui regras. Uma regra tem sempre a forma:

18 programa : combinação /*Vazio*/ ; O programa deve começar na primeira coluna do texto e corresponde ao laço inicial ou um laço recursivo. A ação deve sempre ser iniciada na mesma linha e usualmente corresponde a um laço ou a um vocábulo reconhecido na seção DEFINIÇÕES. Tanto na seção de DEFINIÇÕES como de REGRAS qualquer texto identado ou entre %{e % é copiado literalmente para a saída (sem os caracteres %{e %). Para o reconhecimento dos caracteres {, e % estes devem aparecer não identados como padrões em separado. Em adição, apenas na seção de DEFINIÇÕES, qualquer texto não identado é copiado literalmente para a saída. Sob certos aspectos os caracteres %% indicam o início e o fim da seção REGRAS Seção CÓDIGO A última seção, CÓDIGO, contém todo o código C definido e fornecido pelo programador. Nesta seção usualmente temos declarada uma função main(), que define o início do programa. Outras funções, utilizadas nas ações definidas pelas regras, podem ser colocadas aqui, como yyparse() e yyerror() com destaque para a yyerror que está apresentada logo abaixo. Esta seção também pode permanecer vazia, ou seja, sem código definido pelo programador. int yyerror () { result++; if(result) printf ("\nerro na linha (%d): %s\n", linhas, linebuf); return 1; 7.2. Código O analisador sintático em nosso trabalho está implementado no arquivo AS.y.

19 #include <malloc.h> #include "hash.h" extern int poslastprog; int doreset = 1; char linebuf[1024]; int linhas = 1; int result = 0; int func=0; // Minhas Variaveis int passo=1, LC=0,ninst=0; #define ITS(x) if (doreset) { \ return (int)x; linebuf[0] = 0; \ doreset = 0; \ \ else { strcat(linebuf," "); \ strcat(linebuf, yytext); \ if ((x) == Tok_Fl) \ doreset = 1; \ #if 0 #define ITS(x) fprintf(listff, "[]%s", yytext); return((int)(x)) #define ITS(x) return((int)(x)) #endif #define INTEGER 1 #define STRING 2 #include "AL.c" #include "TabVar.h" #include "TabProg.h" #include "executor.h" #include "TabPrimitiva.h" #include "semantica.h" #include "menu.h" % %token Tok_Pr %token Tok_Prog %token Tok_Int %token Tok_Begin %token Tok_End %token Tok_Var %token Tok_Func %token Tok_Dlv %token Tok_Dlp %token Tok_Dla %token Tok_Dlf %token Tok_Dlpv %token Tok_Atr %token Tok_Fim

20 %token Tok_Num %token Tok_Iden %token Tok_Op %token Tok_Fl %token Tok_Fp %token Tok_Variavel %start programa %% programa : Tok_Prog Tok_Iden {a90(gultimotermo); Tok_Dlpv Defvar Corpo Tok_Fim /*Vazio*/ ; Defvar : Tok_Var DeclaracaoVariaveis /*vazio*/ ; DeclaracaoVariaveis: Tok_Iden{a10(gUltimoTermo); Tok_Dlv DeclaracaoVariaveis FimDeclaracao ; FimDeclaracao: Tok_Iden {a10(gultimotermo);tok_dlp Tok_Int{a20(INTEGER);gTipoTermo='i'; Tok_Dlpv ; Corpo: Tok_Begin Bloco Tok_End; Bloco: Atribuicao Bloco Funcao Bloco /*vazio*/ ; Atribuicao: Tok_Variavel{ Variavel *var; gtipotermo='v'; strcpy(gultimotermo,gultvariavel); var=consulta_var(programa->tabvarprog,gultimotermo); gnumero=var->termo.valor=0; Tok_Atr {a70(":=", gultvariavel, 'o'); Expr Tok_Dlpv {a80(); ; Funcao: Tok_Fp {Lctermos=a40(Lctermos,gUltimoTermo,TabFP); a71(gultfuncao, 'f'); noatual = nofunc; Tok_Dla Termos Tok_Dlf {if ((Lctermos->valor)== 0) {Lctermos=pop(Lctermos);else/*if (a60(lctermos))*/ {printf("nmero de parametros invalido:");yyerror();exit(0);tok_dlpv {a80();;

21 Funcao: Tok_Fp {Lctermos=a40(Lctermos,gUltimoTermo,TabFP); a71(gultfuncao, 'f'); noatual = nofunc; Tok_Dla Termos Tok_Dlf {if ((Lctermos->valor)== 0) {Lctermos=pop(Lctermos);else {printf("numero de parâmetros inválido:");yyerror();exit(0);tok_dlpv {a80(); ; Termos: Termo {a50(lctermos); if(gtipotermo!= 'f') a71(gultimotermo, gtipotermo);tok_dlv Termos Termo {a50(lctermos); if(gtipotermo!= 'f') a71(gultimotermo, gtipotermo); ; Termo : Tok_Fp{Lctermos=a40(Lctermos,gUltimoTermo,TabFP); gtipotermo='f'; a71(gultfuncao, gtipotermo); Tok_Dla Termos Tok_Dlf{if ((Lctermos->valor)== 0) {Lctermos=pop(Lctermos);else{printf("Numero de parametros invalido:");yyerror();exit(0); Tok_Variavel{ Variavel *var; gtipotermo='v'; strcpy(gultimotermo,gultvariavel); /*Obtem a variï ½el na Tab de Simbolos*/ var=consulta_var(programa->tabvarprog,gultimotermo); gnumero=var->termo.valor=0; Tok_Num {gtipotermo='i';strcpy(gultimotermo,gultnumero);gnumero=atoi(gultnumero) ; ; Expr : Termo Termo Tok_Op{a70(gUltOper, gultimotermo, 'o'); Expr ; %%

22 { int main() FILE *arq; char nomearq[256]; int opcao; Programa *progexecutar; inittabfp(); iniciafp(tabfp,"funcprim.txt"); do { menu(); scanf("%d",&opcao); switch (opcao){ case 1: system("ls *.pas"); printf("\n"); printf("digite o arquivo a ser compilado\n"); scanf("%s",nomearq); arq = fopen(nomearq,"r"); if (arq == NULL){ printf("o arquivo %s nao pode ser aberto para leitura\n",nomearq); else{ initstack(); programa=inittabprog(programa); noatual=nofunc=noaux=null; linhas=0; result=0; yyin=arq; yyrestart(yyin); yyparse(); if (!result){ if (programa!= NULL){ insereprograma(programa); printf("programa %s analisado com sucesso\n", programa->nome); fclose(yyin); break;

23 case 2: if (poslastprog!= 0){ imprimelistprograma(); printf("digite o programa a ser executado\n"); scanf("%s",nomearq); progexecutar = getprograma(nomearq); compilado\n",nomearq); if (progexecutar == NULL) { printf("programa %s nao else { printf("executando %s\n",progexecutar->nome); executa(progexecutar); else { break; printf("nenhum programa compilado\n"); while (opcao!= 0); return 0; #include <stdio.h> int yyerror () { result++; if(result) printf ("\nerro na linha (%d): %s\n", linhas, linebuf); return 1; 8. Analisador de Contexto O analisador de contexto realiza ações semântica, que não podem ser realizadas pelo analisador léxico, para verificar a validade do programa. Por exemplo, uma das tarefas do analisador de contexto é verificar se o número de argumentos de uma primitiva está correto. Para pode fazer esse tipo de verificação, ele precisa ter acesso à tabela de funções primitivas. Mas a principal tarefa do analisador de contexto nesse projeto é verificar se um identificador, que pode ser uma variável, uma função ou um identificador normal, está na posição correta. Abaixo estão os códigos e as ações associadas. Essas ações estão nos arquivos semantica.c, semantica.h, TabVar.c e TabVar.h.

24 /* Ações Semânticas*/ /* Nome Ação: a10 Ação:Armazena as variáveis que estão sendo declaradas em um Stack (Lista encadeada) */ void a10(char *nomevar){ Variavel* var; Variavel*aux=Stack_Var; var=newvar(nomevar); if (aux==null){ Stack_Var=var; else{ while (aux->next!= NULL) aux=aux->next; aux->next= var; /* Acao : a20 Funcao: Insere na Tabela de Variáveis definindo o seu tipo */ void a20(int tipo){ int posic; Variavel *aux; while (Stack_Var!=NULL){ aux=stack_var; Stack_Var=aux->next; posic=hash(aux->palavra); aux->tipo=tipo; aux->termo.tipo=tipo; inserevariavel(programa->tabvarprog,aux,posic); /* a30: Verifica a variável já foi declarada antes de uma atribuição */ int a30(char *item){ return consulta(programa->tabvarprog,item);

25 ctermo *newtermo(int aridade){ ctermo *ct=(ctermo*)malloc(sizeof(ctermo)); ct->valor=aridade; ct->prox=null; return ct; ctermo * push(ctermo *ct,ctermo* p){ if (p) ct->prox=p; p=ct; return p; ctermo* pop (ctermo *p){ ctermo *aux=null; if (p){ aux=p; p=p->prox; free(aux); return p; void dec (ctermo *p){ p->valor--; ctermo *a40 (ctermo *p,char *fprim,funcprim* TabFP[]){ ctermo *ct=newtermo(consultaaridade(tabfp,fprim)); return (push(ct,lctermos)); void a50 (ctermo *p){ return dec(p); int a60(ctermo *p){ if (p->valor == 0){ p=pop(p); return 0; else{ printf("numero de parametros invalido:"); return (p->valor);

26 9. Gerador de Código O gerador de código constrói a árvore de execução do programa lido. A árvore de execução é uma estrutura de nós alocados dinamicamente e ligados através de ponteiros. As ligações dos nós determinam em que ordem às instruções é executada. Ao gerar a árvore de execução, o gerador de código armazena-a em memória. Mais tarde, o ambiente de execução poderá executar aquele código compilado. Abaixo estarei apresentando um código aceito pela linguagem, e sua respectiva árvore de execução. program T1; var A,B,C,D,E: integer; begin end. C:=10 + max(12, 30); leia (B); leia (E); D:=max (B, E); imprima (D); Abaixo, árvore de execução do programa acima. Essa árvore é formada pelas regras a70() a90(). Essas regras também estão apresentadas logo abaixo. Essas ações estão no arquivo TabProg.c e TabProg.h.

27 Árvore de Execução Início do Programa Fim do programa = o 0 leia f 0... C v 0 + o 0 B v 0 10 n 10 max f 0 12 n n 12

28 /* Nome Acao: a70 Acao:Inicia uma folha da arvore de execução. */ void a70(char* nome, char* nometermo, char tipo){ if(noatual == NULL){ noatual = newno(nome, tipo, 0); noatual->esq = newno(nometermo, gtipotermo, gnumero); noaux = noatual; else{ No *aux; aux = newno(nome, tipo, 0); noaux->dir = aux; noaux = aux; if(nofunc == NULL) aux->esq = newno(nometermo, gtipotermo, gnumero); else aux->esq = nofunc; nofunc = NULL; /* Nome Acao: a71 Acao:Inicia uma folha da arvore de execução. */ void a71(char* nome, char tipo){ if(nofunc == NULL) nofunc = newno(nome, tipo, 0); else{ No *aux1; aux1 = nofunc; while(aux1->esq!= NULL) aux1 = aux1->esq; aux1->esq=newno(nome, tipo, gnumero);

29 /* Ação: a80 Funcao: Insere a ultima folha na arvore de execução. */ void a80(){ if(programa->fst == NULL) programa->fst = programa->lst = noatual; else{ programa->lst->prox = noatual; programa->lst = noatual; if(programa->lst->tipo == 'o'){ if(nofunc == NULL){ No *aux; if(gtipotermo == 'i') aux = newno("numero", 'n', gnumero); else aux = newno(gultvariavel, 'v', 0); noaux->dir = aux; noaux = aux; else { noaux->dir = nofunc; nofunc = NULL; // Reseta a declaração atual. noatual = NULL; nofunc = NULL; flag = 0; /* a90: Insere o nome do programa. */ void a90(char *nome){ strcpy(programa->nome, nome); programa->fst = programa->lst = NULL;

30 10. Executor de Código O executor de código é um interpretador de árvore de execução formada pelo gerador de código. Ele navega pela árvore e executa os comandos que foram compilados a partir do código do usuário. Abaixo estará sendo apresentado o código de execução utilizado. #ifndef executor_h #define executor_h #include "TabProg.h" #include "TabVar.h" #include "TabPrimitiva.h" void executa(programa *); int resolvevalor(no *,Programa *); int resolvefuncao(no *,Programa *); int max(int, int); int leia(int *); int imprime(int); int retornavalor(no *,Programa *); #endif #include <malloc.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include "executor.h" void executa(programa *programa){ No *executor, *folhaatual; executor = programa->fst; while (executor!= NULL){ Variavel *var; folhaatual = executor; var = consulta_var(programa->tabvarprog, folhaatual->esq- >nome); var->termo.valor = resolvevalor(folhaatual->dir,programa); imprime(var->termo.valor); executor = folhaatual->prox;

31 // Função que resolve o valor de uma atribuicao. int resolvevalor(no *no,programa *programa){ int v=0; if(no!= NULL){ switch(no->tipo){ case('o'):{ if(no->esq->tipo == 'v'){ Variavel *aux; aux = consulta_var(programa->tabvarprog, no->esq-nome); v = aux->termo.valor; else if(no->esq->tipo == 'f') resolvefuncao(no->esq,programa); else v = no->esq->valor; if(strcmp(no->nome,"+") == 0) v += resolvevalor(no->dir,programa); else if (strcmp(no->nome,"-") == 0) v -= resolvevalor(no->dir,programa); else if (strcmp(no->nome,"*") == 0) v *= resolvevalor(no->dir,programa); else v /= resolvevalor(no->dir,programa); return v; case('n'):{ return no->valor; break; case('v'):{ Variavel *aux; case('f'):{ case('p'):{ else return 0; aux = consulta_var(programa->tabvarprog, no->nome); return aux->termo.valor; break; return resolvefuncao(no,programa); return resolveprec(no->dir,programa); break; break;

32 int resolvefuncao(no *no,programa *programa){ No *aux = no; int aridade = consultaaridade(tabfp, no->nome); if(strcmp(no->nome, "max") == 0){ return max(retornavalor(no->esq,programa), retornavalor(no->esq->esq,programa)); if (strcmp(no->nome, "leia") == 0) { Variavel *var = consulta_var(programa->tabvarprog, no->esq->nome); return leia(&var->termo.valor); if (strcmp(no->nome, "imprima") == 0){ return imprime(retornavalor((no->esq),programa));

33 case('n'):{ return no->valor; break; case('v'):{ Variavel *aux; aux = consulta_var(programa->tabvarprog, no->nome); return aux->termo.valor; break; case('f'):{ return resolvefuncao(no,programa); break; else return 0; int max(int a, int b){ if(a>b) return a; else return b; int leia(int *a){ scanf("%d", a); return 1; int imprime(int a){ printf("%d\n", a); return 1; int retornavalor(no *no,programa *programa){ if(no->tipo == 'v'){ Variavel *aux; aux = consulta_var(programa->tabvarprog, no->nome); return aux->termo.valor; else return no->valor;

34 11. Exemplos de programas Abaixo estaremos apresentando exemplos que são permitidos na linguagem. abaixo: program T2; var A,B,C,D,E: integer; begin C:=10; D:= C* 20; imprima (D); end. program T3; var A,B,C,D,E: integer; begin leia(a); leia(b); C:= 10 * A + B; D:= C* 20; imprima (D); end. 12. Ambiente de Execução Menu Estaremos apresentado o código responsável pelo Menu. Neste menu você pode compilar e executar programas do diretório em que o executável está inserido. Para facilitar, ao escolher a opção de compilar ou executar, ele apresenta a lista de possíveis candidatos.

35 #ifndef menu_h #define menu_h #include "TabProg.h" void menu(); void imprimelistprograma(); #endif #include <stdio.h> #include "menu.h" extern int poslastprog; void menu() { printf("menu:\n"); printf("1- Compilar\n"); printf("2- Executar\n"); printf("\n"); printf("0- Sair\n"); void imprimelistprograma() { int i; printf("programas que podem ser executados:\n"); for (i=0;i<poslastprog;i++) printf("%s\t",&listprograma[i]->nome); printf("\n");

36 Abaixo, apresentamos os Layouts do menu: Menu

37 Compilando prog02.pas

38 Executando prog01.pas

39 Executando prog02.pas

40 13. MakeFile Abaixo está o código do Makefile, para executar basta abrir um terminal e compilar: [...] # make Para executar: [...] #./AS all: AL.c AS AL.c: AL.l flex -i -oal.c AL.l AS: AS.c hash.c TabVar.c TabPrimitiva.c semantica.c TabProg.c executor.c menu.c gcc -o AS AS.c hash.c TabVar.c TabPrimitiva.c semantica.c TabProg.c executor.c menu.c -lfl -lm AS.c: AS.y bison -t -d -v -oas.c AS.y clean: rm -f AL.c *.o AL rm -f AS.c *.o AS.h *.output AS