Sumário Prefácio XI 1 INTRODUÇÃO 1 1.1 Por que compiladores? Um breve histórico 2 1.2 Programas relacionados a compiladores 4 1.3 O processo de tradução 6 1.4 Principais estruturas de dados em um compilador 13 1.5 Outros aspectos da estrutura de um compilador 15 1.6 Partida rápida e transposição 18 1.7 A linguagem TINY e seu compilador 22 1.8 C : uma linguagem para um projeto de compilador 26 Exercícios 27 Notas e referências 29 2 VARREDURA 31 2.1 O processo de varredura 32 2.2 Expressões regulares 34 2.3 Autômatos finitos 47 2.4 Das expressões regulares para os autômatos finitos determinísticos 64 2.5 Implementação de um sistema de varredura TINY 75 2.6 Uso de Lex para gerar automaticamente um sistema de varredura 81 Exercícios 90 Exercícios de programação 93 Notas e referências 94 3 GRAMÁTICAS LIVRES DE CONTEXTO E ANÁLISE SINTÁTICA 95 3.1 O processo de análise sintática 96 3.2 Gramáticas livres de contexto 97 3.3 Árvores de análise sintática e árvores sintáticas abstratas 106 3.4 Ambigüidade 114 3.5 Notações estendidas: EBNF e diagramas sintáticos 122 3.6 Propriedades formais de linguagens livres de contexto 128 3.7 Sintaxe da linguagem TINY 133 Exercícios 138 Notas e referências 142 4 ANÁLISE SINTÁTICA DESCENDENTE 143 4.1 Análise sintática descendente recursiva 144 4.2 Análise sintática LL(1) 152 VII
VIII COMPILADORES: PRINCÍPIOS E PRÁTICAS 4.3 Conjuntos primeiros e de seqüência 168 4.4 Um analisador sintático para a linguagem TINY 181 4.5 Recuperação de erros em analisadores sintáticos descendentes 183 Exercícios 190 Exercícios de programação 194 Notas e referências 197 5 ANÁLISE SINTÁTICA ASCENDENTE 199 5.1 Visão geral da análise sintática ascendente 200 5.2 Autômatos finitos dos itens LR(0) e análise sintática LR(0) 203 5.3 Análise sintática SLR(1) 212 5.4 Análise sintática geral LR(1) e LALR(1) 219 5.5 Yacc: um gerador de analisadores sintáticos LALR(1) 228 5.6 Geração de um analisador sintático TINY usando o Yacc 245 5.7 Recuperação de erros em analisadores sintáticos ascendentes 247 Exercícios 252 Exercícios de programação 256 Notas e referências 258 6 ANÁLISE SEMÂNTICA 259 6.1 Atributos e gramáticas de atributos 261 6.2 Algoritmos para computação de atributos 272 6.3 A tabela de símbolos 297 6.4 Tipos de dados e verificação de tipos 316 6.5 Analisador semântico para a linguagem TINY 337 Exercícios 342 Exercícios de programação 345 Notas e referências 346 7 AMBIENTES DE EXECUÇÃO 349 7.1 Organização de memória durante a execução de programas 350 7.2 Ambientes de execução totalmente estáticos 353 7.3 Ambientes de execução baseados em pilhas 356 7.4 Memória dinâmica 377 7.5 Mecanismos para passagem de parâmetros 385 7.6 Ambiente de execução para a linguagem TINY 390 Exercícios 392 Exercícios de programação 399 Notas e referências 400 8 GERAÇÃO DE CÓDIGO 401 8.1 Código intermediário e estruturas de dados para geração de código 402 8.2 Técnicas básicas para geração de código 410 8.3 Geração de código para referências a estruturas de dados 419 8.4 Geração de código para declarações de controle e expressões lógicas 431 8.5 Geração de código para chamadas de procedimentos e funções 438 8.6 Geração de código em compiladores comerciais: dois estudos de casos 444 8.7 TM: uma máquina-alvo simples 454
SUMÁRIO IX 8.8 Gerador de código para a linguagem TINY 460 8.9 Revisão das técnicas de otimização de código 468 8.10 Otimizações simples para o gerador de código TINY 482 Exercícios 485 Exercícios de programação 489 Notas e referências 490 APÊNDICE A PROJETO DE COMPILADOR 493 A.1 Convenções léxicas de C 493 A.2 Sintaxe e semântica de C 494 A.3 Programas de exemplo em C 497 A.4 Ambiente de execução TINY para a linguagem C 499 A.5 Projetos de programação utilizando C e TM 502 APÊNDICE B LISTAGEM DO COMPILADOR TINY 503 APÊNDICE C LISTAGEM DO SIMULADOR DE MÁQUINA TINY 535 BIBLIOGRAFIA 545 ÍNDICE 549
Prefácio Este livro é uma introdução ao campo de construção de compiladores. Ele combina um estudo detalhado da teoria subjacente à abordagem moderna de projeto de compiladores, acompanhado de diversos exemplos práticos e uma descrição completa, com código-fonte, de um compilador para uma pequena linguagem. Ele é projetado especificamente para uso em um curso introdutório sobre projeto de compiladores ou sobre construção de compiladores para alunos em final de graduação. Ele pode também ser útil para profissionais que estejam participando de um projeto de compilador, já que tem por objetivo proporcionar ao leitor as ferramentas necessárias e a experiência prática para projetar e programar efetivamente um compilador. Já existem muitos textos para esse campo. Por que escrever mais um? Porque virtualmente todos os textos existentes se restringem ao estudo de somente um dos dois aspectos importantes da construção de compiladores. A primeira variedade de textos se concentra no estudo da teoria e dos princípios do projeto de compiladores, com apenas breves exemplos de aplicação da teoria. A segunda variedade de textos se concentra no objetivo prático de produzir um compilador, seja para uma linguagem de programação real ou para uma versão simplificada de alguma linguagem, com apenas breves incursões na teoria subjacente ao código para explicar sua origem e comportamento. Considero essas duas abordagens insuficientes. Para compreender realmente os aspectos práticos do projeto de compiladores, é preciso entender a teoria; para apreciar realmente a teoria, é preciso vê-la em ação em condições reais ou bem próximas de reais. Este texto se propõe a promover o equilíbrio entre teoria e prática, e a fornecer detalhes de implementação suficientes para que se sinta um sabor real das técnicas, sem entretanto sobrecarregar o leitor. Nele, apresento um compilador completo para uma pequena linguagem, escrito em C e desenvolvido utilizando as diferentes técnicas estudadas em cada capítulo. Adicionalmente, descrições detalhadas das técnicas de codificação para exemplos adicionais de linguagens são fornecidas à medida que os tópicos associados são estudados. Finalmente, cada capítulo termina com um amplo conjunto de exercícios, divididos em duas seções. A primeira contém exercícios para solução com lápis e papel e que envolvem pouca programação. A segunda contém exercícios que requerem programação. Ao escrever um texto assim, é preciso levar em conta as diferentes posições que um curso de compiladores ocupa em diferentes currículos de ciência da computação. Em alguns programas, um curso sobre teoria de autômatos é pré-requisito; em outros, um curso sobre linguagens de programação é um pré-requisito; em outros, ainda, não existem pré-requisitos (além de estruturas de dados). Este texto não assume pré-requisitos além do curso usual de estruturas de dados e familiaridade com a linguagem C. Ele está organizado, entretanto, para que um pré-requisito como um curso de teoria de autômatos possa ser levado em conta. Ele deveria portanto ser útil para uma ampla variedade de programas. Um último problema para escrever um texto sobre compiladores é que os professores usam muitas abordagens diferentes de aula para a aplicação prática da teoria. Alguns preferem XI
XII COMPILADORES: PRINCÍPIOS E PRÁTICAS estudar as técnicas usando apenas uma série de exemplos pequenos e independentes, cada um direcionado a um conceito específico. Outros apresentam um grande projeto de compilador, que se torna factível com o uso de ferramentas como Lex e Yacc. Outros, ainda, pedem que os estudantes escrevam todo o código manualmente (utilizando, por exemplo, análise sintática recursiva descendente), mas aliviam a tarefa fornecendo as estruturas de dados básicas e algum código de exemplo. Este livro deve ser útil para todos esses cenários. Visão geral e organização Na maioria dos casos, cada capítulo é independente dos demais, sem restringir artificialmente o material em cada um. Referências cruzadas no texto permitem ao leitor ou ao professor completar eventuais lacunas, mesmo se algum capítulo ou seção não tiver sido coberto. O Capítulo 1 é uma visão geral da estrutura básica de um compilador e das técnicas estudadas nos capítulos seguintes. Ele também inclui uma seção sobre transposição e partida rápida. O Capítulo 2 estuda a teoria de autômatos finitos e expressões regulares, e, em seguida, aplica essa teoria na construção de um sistema de varredura codificado manualmente e utilizando a ferramenta de geração de sistemas de varredura Lex. O Capítulo 3 trata da teoria de gramáticas livres de contexto no que se refere à análise sintática, com ênfase especial à resolução de ambigüidade. Ele dá uma descrição detalhada de três notações comuns para essas gramáticas, que são BNF, EBNF e diagramas sintáticos. Ele também discute a hierarquia de Chomsky e os limites de poder das gramáticas livres de contexto, e menciona alguns dos resultados teóricos importantes relacionados a essas gramáticas. Uma gramática para a linguagem de exemplo usada neste texto também é fornecida. O Capítulo 4 estuda os algoritmos de análise sintática descendente, em particular os métodos de análise sintática recursiva descendente e LL(1). Um analisador sintático recursivo descendente para a linguagem de exemplo também é apresentado. O Capítulo 5 dá continuidade ao estudo dos algoritmos para análise sintática, com a análise sintática ascendente, culminando nas tabelas de análise sintática LALR(1) e no uso da ferramenta de geração de analisadores sintáticos Yacc. Uma especificação Yacc para a linguagem de exemplo é apresentada. O Capítulo 6 é uma revisão ampla da análise semântica estática, com foco em gramáticas de atributos e percursos em árvores sintáticas. Ele cobre extensivamente a construção de tabelas de símbolos e a verificação estática de tipos, os dois exemplos fundamentais da análise semântica. Uma implementação baseada em tabelas de hashing para uma tabela de símbolos também é dada e usada para implementar um analisador semântico para a linguagem de exemplo. O Capítulo 7 aborda as diferentes formas de ambientes de execução, desde o ambiente totalmente estático da linguagem Fortran até os ambientes totalmente dinâmicos das linguagens baseadas em Lisp, passando pelas variedades de ambientes baseados em pilhas. Ele fornece também uma implementação para heap de armazenamento alocado dinamicamente. O Capítulo 8 discute a geração de código tanto para código intermediário, como código de três endereços e P-código, quanto para código objeto executável para uma arquitetura de von Neumann simples, para a qual é fornecido um simulador. É fornecido um
Capítulo 1 Introdução 1.1 Por que compiladores? Um breve histórico 1.2 Programas relacionados a compiladores 1.3 O processo de tradução 1.4 Principais estruturas de dados em um compilador 1.5 Outros aspectos da estrutura de um compilador 1.6 Partida rápida e transposição 1.7 A linguagem TINY e seu compilador 1.8 C : uma linguagem para um projeto de compilador Compiladores são programas de computador que traduzem de uma linguagem para outra. Um compilador recebe como entrada um programa escrito na linguagem-fonte e produz um programa equivalente na linguagem-alvo. Geralmente, a linguagem-fonte é uma linguagem de alto nível, como C ou C++, e a linguagem-alvo é um código-objeto (algumas vezes também chamado de código de máquina) para a máquina-alvo, ou seja, um código escrito usando as instruções de máquina do computador no qual ele será executado. Podemos ver esse processo esquematicamente assim: Programa- Fonte Compilador Programa- Alvo Um compilador é um programa bastante complexo, que pode ter de 10.000 a 1.000.000 de linhas de código. Escrever um programa desses, ou mesmo entendê-lo, não é tarefa simples, e a maioria dos cientistas e profissionais de computação jamais escreverão um compilador completo. Compiladores, entretanto, são usados em quase todas as formas de computação, e qualquer pessoa envolvida profissionalmente com computadores deveria conhecer a organização e as operações básicas de um compilador. Além disso, uma tarefa freqüente em aplicações de computador é o desenvolvimento de interpretadores de comandos e programas de interface, menores que os compiladores, mas que utilizam as mesmas técnicas. Conhecer essas técnicas tem, portanto, uso prático significativo. Este texto tem por objetivo não apenas proporcionar esse conhecimento básico, mas também dar ao leitor todas as ferramentas necessárias e a experiência prática para projetar e programar um compilador. Para isso, é necessário estudar as técnicas teóricas, principalmente da teoria de autômatos, que tornam a construção de compiladores uma tarefa factível. Ao apresentar essa teoria, não assumimos que o leitor tenha conhecimento prévio da teoria de autômatos. O ponto de vista adotado aqui é diferente daquele de um texto padrão sobre teoria de autômatos, pois tem por objetivo específico o processo de compilação. Um leitor que tenha estudado teoria 1
2 COMPILADORES: PRINCÍPIOS E PRÁTICAS de autômatos terá maior familiaridade com esse material teórico e poderá prosseguir mais rapidamente por essas seções. Em particular, as seções 2.2, 2.3, 2.4 e 3.2 podem ser ignoradas ou lidas superficialmente por quem tenha conhecimento prévio sobre a teoria de autômatos. Em qualquer caso, o leitor deve ter familiaridade com estruturas básicas de dados e matemática discreta. Algum conhecimento de arquitetura de máquinas e linguagens de montagem também é essencial, particularmente para o capítulo sobre geração de código. O estudo das técnicas práticas de codificação requer planejamento cuidadoso, pois, mesmo com boa fundamentação teórica, os detalhes de código podem ser complexos e desafiadores. Este texto contém uma série de exemplos simples de construções em linguagens de programação, usados na elaboração da discussão das técnicas. A linguagem que usamos para essa discussão se chama TINY. Fornecemos também (no Apêndice A) um exemplo mais completo, composto por um pequeno mas suficientemente complexo subconjunto da linguagem C, que denominamos C, o qual é também apropriado para um projeto de curso. Há também diversos exercícios, incluindo exercícios simples para resolver com lápis e papel, extensões do código no texto e exercícios que envolvem mais programação. De maneira geral, existe interação significativa entre a estrutura de um compilador e o projeto da linguagem de programação a ser compilada. Neste texto, vamos tratar de questões de projeto de linguagens apenas em alguns pontos. Existem outros textos que se concentram mais diretamente em conceitos de linguagem de programação e questões de projeto. (Ver a seção de notas e referências no final deste capítulo.) Iniciamos com uma breve revisão do histórico e dos motivos de existência dos compiladores, juntamente com uma descrição de programas relacionados a compiladores. Examinamos, em seguida, a estrutura de um compilador e os diversos processos de tradução e estruturas de dados associadas, para a seguir percorrer essa estrutura usando um exemplo concreto simples. Finalmente, apresentamos uma visão geral de outros aspectos da estrutura do compilador, incluindo partida rápida e transportabilidade, concluindo com uma descrição dos principais exemplos de linguagem usados no restante do livro. 1.1 POR QUE COMPILADORES? UM BREVE HISTÓRICO Com o advento do computador de programa armazenado de John von Neumann no final da década de 1940, tornou-se necessário escrever seqüências de código, ou programas, para que esses computadores efetuassem as computações desejadas. Inicialmente, esses programas foram escritos em linguagem de máquina código numérico representando as operações de máquina a serem efetivamente executadas. Por exemplo, C7 06 0000 0002 representa a instrução para mover o número 2 do endereço 0000 (hexadecimal) em processadores Intel 8x86 utilizados em computadores IBM PC. Evidentemente, escrever códigos como esse consome muito tempo e é entediante. Assim, essa forma de codificação foi rapidamente substituída pela linguagem de montagem, em que instruções e endereços de memória adotam uma forma simbólica. Por exemplo, a instrução em linguagem de montagem MOV X, 2 é equivalente à instrução de máquina vista anteriormente (assumindo que o endereço de memória X seja 0000). Um montador traduz os códigos simbólicos e endereços de memória da linguagem de montagem para os códigos correspondentes da linguagem de máquina. As linguagens de montagem aumentaram muito a velocidade e a precisão com que os programas podem ser escritos, e são usadas ainda hoje, especialmente quando muita velocidade
Capítulo 1 INTRODUÇÃO 3 ou concisão de código são necessárias. Entretanto, a linguagem de montagem tem alguns defeitos: não é fácil escrever e é difícil ler e entender o que é escrito nela. Além disso, a linguagem de montagem é extremamente dependente da máquina em particular para a qual ela seja escrita; portanto, o código escrito para um computador precisa ser completamente reescrito para outro. Evidentemente, o grande passo seguinte na tecnologia de programação foi escrever as operações de um programa em uma forma concisa, mais semelhante a uma notação matemática ou linguagem natural, independentemente de qualquer máquina em particular e ainda assim passível de tradução por um programa em código executável. Por exemplo, o código anteriormente apresentado em linguagem de montagem pode ser escrito de forma concisa e independente de máquina como X = 2 Houve um temor inicial de que isso poderia ser impossível, ou, se fosse possível, que o código objeto fosse tão ineficiente que seria inútil. O desenvolvimento da linguagem Fortran e de seu compilador por um grupo na IBM dirigido por John Backus, entre 1954 e 1957, mostrou que esse temor não tinha fundamento. Ainda assim, o sucesso desse projeto resultou de muito esforço, pois a maioria dos processos de tradução de linguagens de programação era pouco entendida naquele momento. Na mesma época do desenvolvimento do primeiro compilador, Noam Chomsky iniciou seus estudos da estrutura da linguagem natural. Seus resultados tornaram a construção de compiladores mais simples e parcialmente automatizável. Os estudos de Chomsky levaram à classificação de linguagens segundo a complexidade de suas gramáticas (as regras que especificam sua estrutura) e o poder dos algoritmos necessários para reconhecê-las. A hierarquia de Chomsky, como é conhecida hoje, consiste de quatro níveis de gramática, denominadas tipo 0, tipo 1, tipo 2 e tipo 3, cada uma sendo uma especialização da anterior. As gramáticas de tipo 2, ou gramáticas livres de contexto, são as mais úteis para as linguagens de programação, e são hoje a forma padrão para representar a estrutura de linguagens de programação. O problema da análise sintática (a determinação de algoritmos eficientes para reconhecer linguagens livres de contexto) foi estudado nos anos 1960 e 1970, levando a uma solução bastante completa que hoje faz parte da teoria de compiladores. As linguagens livres de contexto e os algoritmos para análise sintática são estudados nos Capítulos 3, 4 e 5. Assuntos fortemente relacionados com as gramáticas livres de contexto são autômatos finitos e expressões regulares, que correspondem às gramáticas de Chomsky de tipo 3. Inicialmente desenvolvido pelo próprio Chomsky, o estudo desses temas levou a métodos simbólicos para expressar a estrutura de palavras, ou marcas, de uma linguagem de programação. No Capítulo 2 são discutidos autômatos finitos e expressões regulares. Um assunto muito mais complexo tem sido o desenvolvimento de métodos para gerar códigos objeto eficientes, que têm sido estudados desde o primeiro compilador até hoje. Essas técnicas geralmente recebem o nome inadequado de técnicas de otimização, mas deveriam ser denominadas técnicas de melhoria de código, pois quase nunca levam a um código-objeto efetivamente ótimo, embora melhorem sua eficiência. No Capítulo 8, os fundamentos dessas técnicas são apresentados. À medida que crescia a compreensão do problema da análise sintática, um grande número de trabalhos foi devotado à criação de programas para automatizar essa parte do desenvolvimento de compiladores. Esses programas foram originalmente denominados compiladores de compiladores, mas são mais bem identificados como geradores de analisadores sintáticos, pois automatizam somente uma parte do processo de compilação. O mais conhecido desses programas é o Yacc (yet another compiler compiler outro compilador
4 COMPILADORES: PRINCÍPIOS E PRÁTICAS de compiladores), escrito por Steve Johnson, em 1975, para o sistema Unix. O Yacc é estudado no Capítulo 5. De maneira similar, o estudo de autômatos finitos levou ao desenvolvimento de outra ferramenta, denominada gerador de sistemas de varredura, da qual a Lex (desenvolvida para o sistema Unix por Mike Lesk na mesma época do Yacc) é a mais conhecida. A Lex é estudada no Capítulo 2. No final dos anos 1970 e 1980, diversos projetos visavam automatizar a geração de outras partes de um compilador, como a geração de código. Esses empreendimentos foram menos bem-sucedidos, possivelmente em razão da natureza complexa das operações e ao nosso entendimento limitado dessas operações. Eles não são estudados em detalhe neste texto. Avanços mais recentes em projetos de compiladores têm gerado resultados interessantes. Primeiro, os compiladores têm incorporado algoritmos mais sofisticados para inferência e/ou simplificação da informação contida em um programa, o que tem ocorrido em paralelo ao desenvolvimento de linguagens de programação mais sofisticadas para as quais essa análise é relevante. Um exemplo típico é o algoritmo de Hindley-Milner para verificação de tipos, utilizado na compilação de linguagens funcionais. Em segundo lugar, os compiladores estão se tornando cada vez mais parte de ambientes de desenvolvimento interativo baseados em janelas (IDE), contendo editores, organizadores, depuradores e gerenciadores de projetos. Pouca padronização desses ambientes tem ocorrido até o momento, mas o desenvolvimento de ambientes padrão baseados em janelas tem apontado para essa direção. O estudo desses tópicos está além do escopo deste livro (mas veja na próxima seção uma breve descrição de alguns componentes de um IDE). Para referências bibliográficas, veja a seção de notas e bibliografia no final do capítulo. Apesar das atividades de pesquisa em anos recentes, entretanto, os fundamentos do projeto de compiladores não mudaram muito nos últimos 20 anos, e têm sido incorporados cada vez mais ao currículo básico de ciência da computação. 1.2 PROGRAMAS RELACIONADOS A COMPILADORES Nesta seção, descrevemos brevemente outros programas relacionados a ou utilizados juntamente com compiladores, os quais freqüentemente acompanham compiladores em um ambiente de desenvolvimento de linguagens completo. (Alguns deles já foram mencionados.) INTERPRETADORES Um interpretador é um tradutor de linguagens, assim como um compilador. A diferença é que o interpretador executa o programa-fonte de imediato, em vez de gerar um código-objeto que seja executado após o término da tradução. Em princípio, qualquer linguagem de programação pode ser interpretada ou compilada, mas dependendo da linguagem e da situação em que ocorre a tradução, um interpretador pode ser preferível. Por exemplo, a linguagem Basic é mais comumente interpretada que compilada. De maneira similar, linguagens funcionais como Lisp tendem a ser interpretadas. Interpretadores são usados freqüentemente também em situações educacionais e de desenvolvimento de software, quando os programas são traduzidos e retraduzidos muitas vezes. Um compilador, no entanto, é preferível se a velocidade de execução for importante, pois o código-objeto compilado é invariavelmente mais rápido que o código-fonte, interpretado dez ou mais vezes mais rápido. Entretanto, os interpretadores compartilham muitas de suas operações com os compiladores, podendo inclusive existir tradutores híbridos, que ficam entre os interpretadores e os compiladores. Discutiremos os interpretadores de forma intermitente, mas nosso foco principal, neste texto, serão os compiladores.
Capítulo 1 INTRODUÇÃO 5 MONTADORES Um montador é um tradutor para a linguagem de montagem de um computador em particular. Como já foi dito, a linguagem de montagem é uma forma simbólica da linguagem de máquina do computador, e é particularmente fácil de traduzir. Por vezes, um compilador irá gerar a linguagem de montagem como sua linguagem-alvo e, em seguida, contar com um montador para concluir a tradução para o código-objeto. ORGANIZADORES Tanto compiladores como montadores freqüentemente dependem de um programa denominado organizador, que coleta o código compilado separadamente, ou montado como arquivos-objeto distintos, e coloca tudo em um arquivo diretamente executável. Nesse sentido, uma distinção pode ser feita entre código-objeto código de máquina que ainda não foi organizado e código de máquina executável. Um organizador pode também conectar um programa-objeto ao código para funções padrão de biblioteca e para recursos fornecidos pelo sistema operacional do computador, como alocadores de memória e dispositivos de entrada e saída. É interessante notar que os organizadores efetuam hoje em dia a tarefa que era originalmente uma das principais atividades de um compilador (daí o uso da palavra compilar construir pela coleta a partir de diferentes fontes). Não estudaremos o processo de organização neste texto, pois ele depende de detalhes de sistema operacional e de processador. Também não faremos uma distinção clara entre código-objeto não organizado e código executável, pois essa distinção não será importante para nosso estudo das técnicas de compilação. CARREGADORES Freqüentemente, um compilador, montador ou organizador produz um código que não está completamente determinado e pronto para execução, mas cujas referências de memória principais são relativas a uma localização inicial não determinada, que pode estar em qualquer ponto da memória. Códigos desse tipo são denominados realocáveis, e um carregador resolve os endereços realocáveis relativos a um dado endereço de base ou inicial. O uso de um carregador torna o código executável mais flexível, mas o processo de carga normalmente ocorre nos bastidores (como parte do ambiente operacional) ou juntamente com a organização. Raramente um carregador é um programa em separado. PRÉ-PROCESSADORES Um pré-processador é um programa separado, ativado pelo compilador antes do início da tradução. Ele pode apagar comentários, incluir outros arquivos e executar substituições de macros (uma macro é uma descrição resumida de uma seqüência repetida de texto). Pré-processadores podem ser requeridos pela linguagem (como em C) ou podem ser acréscimos para conseguir recursos adicionais (como no pré-processador Ratfor para Fortran). EDITORES Geralmente, os compiladores aceitam programas-fonte escritos com qualquer editor que gere um arquivo padrão, por exemplo um arquivo ASCII. Mais recentemente, compiladores têm sido apresentados juntamente com editores e outros programas, na forma de um ambiente interativo para desenvolvimento (IDE). Nesse caso, um editor gera arquivos padrão, que também são orientados pela estrutura ou formato da linguagem de programação em questão. Esses editores são denominados baseados em estrutura e incluem parte das operações de um compilador, para que, por exemplo, o
6 COMPILADORES: PRINCÍPIOS E PRÁTICAS programador seja informado sobre erros enquanto o programa é escrito, e não quando ele está sendo compilado. O compilador e os programas que o acompanham podem também ser ativados pelo editor, e assim o programador pode executar o programa sem encerrar a execução do editor. DEPURADORES Um depurador é um programa que pode ser utilizado para determinar erros de execução em um programa compilado. Ele costuma ser apresentado juntamente com um compilador em um IDE. A execução de um programa com um depurador difere da execução padrão, pois o depurador registra muita ou toda a informação do código-fonte, como, por exemplo, números de linhas e nomes de variáveis e procedimentos. Ele pode também interromper a execução em pontos pré-especificados, denominados pontos de interrupção, bem como fornecer informações sobre que funções foram ativadas e quais os valores das variáveis. Para efetuar essas funções, o depurador precisa receber a informação simbólica apropriada do compilador, o que pode, por vezes, ser difícil, especialmente para compiladores que tentam otimizar o código-objeto. Assim, a depuração é um assunto ligado ao compilador, o qual, entretanto, está além do escopo deste livro. GERADORES DE PERFIL Um gerador de perfil é um programa que coleta estatísticas sobre o comportamento de um programa-objeto durante sua execução. Estatísticas que normalmente interessam a um programador são o número de ativações de um procedimento e a relação entre os tempos de execução dos procedimentos. Essas estatísticas podem ser extremamente úteis para ajudar o programador a melhorar a velocidade de execução do programa. Por vezes, o compilador pode utilizar a saída do gerador de perfil para melhorar automaticamente o código-objeto, sem a intervenção do programador. GERENCIADORES DE PROJETOS Projetos de software modernos são, em geral, tão grandes que precisam ser feitos por grupos de programadores, em vez de um único programador individualmente. Nesses casos, é importante que os arquivos trabalhados por essas várias pessoas sejam coordenados, e é isso que um programa gerenciador de projetos faz. Por exemplo, um gerenciador de projetos deve coordenar a junção de versões de um mesmo arquivo produzidas por diferentes programadores. Ele deve também manter um histórico de alterações em cada grupo de arquivos, para que versões coerentes de um programa em desenvolvimento possam ser mantidas (isso também pode ser útil para os projetos com um único programador). Um gerenciador de projetos pode ser escrito de forma independente da linguagem, mas quando acompanha um compilador, ele pode manter informações específicas e úteis do compilador e do organizador. Dois gerenciadores de projetos populares em sistemas Unix são sccs (source code control system sistema de controle de código-fonte) e rcs (revision control system sistema de controle de revisões). 1.3 O PROCESSO DE TRADUÇÃO Um compilador é constituído internamente por passos, ou fases, para operações lógicas distintas. Essas fases podem ser entendidas como peças separadas dentro do compilador, que podem efetivamente ser escritas como operações codificadas separadamente, embora na prática elas sejam freqüentemente agrupadas. As fases de um compilador estão mostradas na Figura 1.1, juntamente com os componentes auxiliares que interagem com algumas ou com todas as fases: a tabela de literais, a tabela de símbolos e o manipulador de erros. Cada uma
Capítulo 1 INTRODUÇÃO 7 Código-fonte Sistema de varredura Marcas Analisador sintático Árvore sintática Analisador semântico Tabela de literais Árvore anotada Tabela de símbolos Otimizador de código-fonte Manipulador de erros Código intermediário Gerador de código Código-alvo Otimizador de código-alvo Código-alvo Figura 1.1 As fases de um compilador. das fases será descrita brevemente: elas serão estudadas com mais detalhes nos próximos capítulos. (As tabelas de literais e de símbolos serão discutidas com mais detalhes na próxima seção, e o manipulador de erros, na Seção 1.5.)
8 COMPILADORES: PRINCÍPIOS E PRÁTICAS O SISTEMA DE VARREDURA Nessa fase do compilador o programa-fonte é lido. Geralmente, o programa-fonte é fornecido como uma seqüência de caracteres. Durante a varredura, ocorre a análise léxica: seqüências de caracteres são organizadas como unidades significativas denominadas marcas, que são como as palavras em uma linguagem natural como o inglês, por exemplo. Um sistema de varredura tem função similar à de um sistema para soletrar. Por exemplo, considere a linha de código a seguir, que poderia pertencer a um programa em C: a [index] = 4 + 2 Esse código contém 12 caracteres diferentes de espaço, mas somente 8 marcas: a identificador [ colchete à esquerda index identificador ] colchete à direita = atribuição 4 número + sinal de adição 2 número Cada marca é composta por um ou mais caracteres, que são agrupados como uma unidade antes de o processamento prosseguir. Um sistema de varredura efetua outras operações além de reconhecer marcas. Por exemplo, ele pode inserir identificadores na tabela de símbolos e literais na tabela de literais (os literais incluem constantes numéricas, como 3.1415926535, e cadeias de caracteres entre aspas, como Hello, world! ). O ANALISADOR SINTÁTICO O analisador sintático recebe do sistema de varredura o código-fonte na forma de marcas e efetua a análise sintática, que determina a estrutura do programa. Isso é similar à análise gramatical de uma sentença em linguagem natural. A análise sintática determina os elementos estruturais do programa e seus relacionamentos. Os resultados da análise sintática são geralmente representados como uma árvore de análise sintática ou uma árvore sintática. Como exemplo, considere novamente a linha de código em C vista anteriormente. Ela representa um elemento estrutural denominado expressão, no caso uma expressão de atribuição composta por uma expressão indexada à esquerda e uma expressão de aritmética de inteiros à direita. Essa estrutura pode ser representada em uma árvore de análise sintática da seguinte forma:
Capítulo 1 INTRODUÇÃO 9 expressão expressão de atribuição expressão = expressão expressão indexada expressão de adição expressão [ expressão ] expressão + expressão identificador a identificador index número 4 número 2 Observe que os nós internos da árvore de análise sintática são rotulados pelos nomes das estruturas que elas representam, e as folhas da árvore de análise sintática representam a seqüência recebida de marcas. (Os nomes das estruturas estão escritos com fonte diferente para diferenciar das marcas.) Uma árvore de análise sintática é um recurso útil para visualizar a sintaxe de um programa ou elemento de programa, mas é ineficiente para representar sua estrutura. Analisadores sintáticos tendem a gerar uma árvore sintática, que condensa a informação contida na árvore de análise sintática. (Por vezes, as árvores sintáticas são denominadas árvores sintáticas abstratas, porque representam uma abstração adicional sobre árvores de análise sintática.) Uma árvore sintática abstrata para nosso exemplo de expressão de atribuição em C fica assim: expressão de atribuição expressão indexada expressão de adição identificador a identificador index número 4 número 2 Observe que, na árvore sintática, muitos dos nós desaparecem (incluindo os nós de marcas). Por exemplo, se soubermos que uma expressão é uma operação de indexação, não é mais necessário preservar os colchetes [ e ] que representam essa operação na entrada original. ANALISADOR SEMÂNTICO A semântica de um programa é o seu significado, contrastando com sua sintaxe ou estrutura. A semântica de um programa determina o seu comportamento durante a
10 COMPILADORES: PRINCÍPIOS E PRÁTICAS execução, mas as linguagens de programação, em sua maioria, têm atributos que podem ser determinados antes da execução, mas que não podem ser expressos de forma conveniente como sintaxe para serem analisados pelo analisador sintático. Esses atributos são denominados semântica estática, e a análise dessa semântica é tarefa para o analisador semântico. (A semântica dinâmica de um programa as propriedades de um programa que podem ser determinadas somente por meio de sua execução não pode ser determinada por um compilador, pois ele não executa o programa.) Atributos típicos de semântica estática de linguagens de programação comuns incluem verificação de tipos e declarações. As informações adicionais (por exemplo, tipos de dados) computadas pelo analisador semântico são denominadas atributos, e são freqüentemente adicionadas à árvore como anotações. (Atributos podem também ser inseridos na tabela de símbolos.) Em nosso exemplo da expressão em C, a[index] = 4 + 2 as informações de tipos típicas que poderiam ser obtidas antes de analisar essa linha seriam que a é um vetor de valores inteiros com índices de um intervalo de inteiros e que index é uma variável de inteiros. O analisador semântico anotaria a árvore sintática com os tipos de todas as subexpressões e verificaria se as atribuições fazem sentido para esses tipos, declarando um erro de divergência entre tipos em caso contrário. Em nosso exemplo, todos os tipos fazem sentido, e o resultado da análise semântica na árvore sintática poderia ser representado pela árvore a seguir: expressão de atribuição expressão indexada inteiro expressão de adição inteiro identificador a vetor de inteiros identificador index inteiro número 4 inteiro número 2 inteiro OTIMIZADOR DE CÓDIGO-FONTE Freqüentemente, os compiladores incluem uma série de passos de melhoria de código, também denominados otimizações. O primeiro ponto passível de aplicação de passos de otimização é logo após a análise semântica, e certas possibilidades de melhoria de código dependem apenas do código-fonte. Essa possibilidade é indicada pela apresentação dessa operação como uma fase separada no processo de compilação. Compiladores individuais apresentam grande variedade de tipos de otimização e posicionamento das fases de otimização. Em nosso exemplo, incluímos uma oportunidade de otimização de fonte: a expressão 4 + 2 pode ser pré-computada pelo compilador para obter o resultado 6. (Essa otimização, em particular, é conhecida como empacotamento constante.)
Capítulo 1 INTRODUÇÃO 11 Evidentemente, existem possibilidades muito mais complexas (algumas delas são mencionadas no Capítulo 8). Em nosso exemplo, essa otimização pode ser efetuada diretamente sobre a árvore sintática (anotada) pela fusão da subárvore à direita do nó-raiz em seu valor constante: expressão de atribuição expressão indexada inteiro número 6 inteiro identificador a vetor de inteiros identificador index inteiro Diversas otimizações podem ser efetuadas diretamente na árvore, mas em muitos casos é mais fácil otimizar uma forma linearizada da árvore, mais próxima do código de montagem. Existem muitas variedades de código de montagem, mas uma escolha padrão é o código de três endereços, que recebe esse nome porque contém (até) três endereços na memória. Outra escolha popular é o P-código, usado em muitos compiladores Pascal. Em nosso exemplo, um código de três endereços para a expressão original em C poderia ficar assim: t = 4 + 2 a[index] = t (Observe o uso de uma variável temporária adicional t para armazenar o resultado intermediário da adição.) O otimizador melhoraria esse código em dois passos, inicialmente computando o resultado da adição t = 6 a[index] = t e depois substituindo t por seu valor, para obter a declaração de três endereços a[index] = 6 Na Figura 1.1, indicamos a possibilidade de o otimizador de código-fonte utilizar um código de três endereços referindo-se à sua saída como código intermediário. Historicamente, esse nome era usado para uma forma de representação de código intermediária entre fonte e objeto, como o código de três endereços ou uma representação linear semelhante. Entretanto, ele pode se referir de maneira mais geral a qualquer representação interna para o código-fonte usada pelo compilador. Nesse sentido, a árvore sintática pode também ser identificada como código intermediário, e o otimizador de código-fonte pode continuar a usar essa representação em sua saída.