Your SlideShare is downloading. ×
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente GNU/Linux - G-Portugol

3,086

Published on

Monografia apresentada à Universidade do Estado do Rio Grande do Norte como um dos pré-requisitos para obtenção do grau de bacharel em Ciência da Computação.

Monografia apresentada à Universidade do Estado do Rio Grande do Norte como um dos pré-requisitos para obtenção do grau de bacharel em Ciência da Computação.

Published in: Education, Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
3,086
On Slideshare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
64
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. UNIVERSIDADE DO ESTADO DO RIO GRANDE DO NORTE ADORILSON BEZERRA DE ARAÚJOINVESTIGAÇÃO E EXTENSÃO DE UMA FERRAMENTA PARA AUXÍLIO AO ENSINO DE ALGORITMOS EM AMBIENTES GNU/LINUX - G-PORTUGOL NATAL 2009
  • 2. ADORILSON BEZERRA DE ARAÚJOINVESTIGAÇÃO E EXTENSÃO DE UMA FERRAMENTA PARA AUXÍLIO AO ENSINO DE ALGORITMOS EM AMBIENTES GNU/LINUX - G-PORTUGOL Monografia apresentada à Universidade do Estado do Rio Grande do Norte como um dos pré-requisitos para obtenção do grau de bacharel em Ciência da Computação Orientadora ROSIERY DA SILVA MAIA NATAL 2009
  • 3. Copyright (C) 2009 by Adorilson Bezerra de Araújo (adorilson.bezerra@ifrn.edu.br) Este trabalho está licenciado sob um licença Creative Commons Atribuição 3.0 Brasil. Para ver uma cópia desta licença, visite http://creativecommons.org/licenses/by/3.0/br/ ou envie uma carta para Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.Você tem a liberdade de: • Compartilhar — copiar, distribuir e transmitir a obra. • Remixar — criar obras derivadas.Sob as seguintes condições: • Atribuição — Você deve creditar a obra da forma especificada pelo autor ou licenciante (mas não de maneira que sugira que estes concedem qualquer aval a você ou ao seu uso da obra).Ficando claro que: • Renúncia — Qualquer das condições acima pode ser renunciada se você obtiver permissão do titular dos direitos autorais. • Domínio Público — Onde a obra ou qualquer de seus elementos estiver em domínio público sob o direito aplicável, esta condição não é, de maneira alguma, afetada pela licença. • Outros Direitos — Os seguintes direitos não são, de maneira alguma, afetados pela licença: • Limitações e exceções aos direitos autorais ou quaisquer usos livres aplicáveis; • Os direitos morais do autor; • Direitos que outras pessoas podem ter sobre a obra ou sobre a utilização da obra, tais como direitos de imagem ou privacidade. • Aviso — Para qualquer reutilização ou distribuição, você deve deixar claro a terceiros os termos da licença a que se encontra submetida esta obra. A melhor maneira de fazer isso é com um link para a página http://creativecommons.org/licenses/by/3.0/br/. Este é um resumo amigável da Licença Jurídica (a licença integral), disponível em http://creativecommons.org/licenses/by/3.0/br/legalcode Catalogação da Publicação na Fonte. Araújo, Adorilson Bezerra de. Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambientes GNU/Linux – G-Portugol / Adorilson Bezerra de Araújo. - Natal, RN, 2009. 62 f. Orientador(a): Prof . Rosiery da Silva Maia. Monografia (Bacharel) . Universidade do Estado do Rio Grande do Norte. Curso de Ciência da Computação. 1. Programação - Monografia. 2. Algoritmos - Monografia. 3. Compiladores - Monografia. 4. G-PORTUGOL - Monografia. I. Maia, Rosiery da Silva. II.Universidade do Estado do Rio Grande do Norte. III.Título. UERN/BC CDD 005.1 Bibliotecária: Valéria Maria Lima da Silva CRB 15 / 451
  • 4. ADORILSON BEZERRA DE ARAÚJOINVESTIGAÇÃO E EXTENSÃO DE UMA FERRAMENTA PARA AUXÍLIO AO ENSINO DE ALGORITMOS EM AMBIENTES GNU/LINUX - G-PORTUGOL Monografia apresentada à Universidade do Estado do Rio Grande do Norte como um dos pré-requisitos para obtenção do grau de bacharel em Ciência da Computação. Aprovado em ___/___/___ . Banca Examinadora ___________________________________ Ms. Rosiery da Silva Maia Universidade do Estado do Rio Grande do Norte ___________________________________ Dra. Cláudia Maria Fernandes Araújo Ribeiro Universidade do Estado do Rio Grande do Norte ___________________________________ Dr. Aquiles Medeiros Filgueira Burlamaqui Universidade Federal do Rio Grande do Norte
  • 5. Dedicado a todos que abandonaram cursosde informática em função das dificuldadesimpostas nas aulas de algoritmos e/oudecorrentes desta.
  • 6. AGRADECIMENTOS O caminhar durante esse curso de Ciência da Computação, que encerra-se comesta monografia só foi possível graças a pessoas que merecem o nosso agradecimento. À minha mãe, pela educação dada a mim e pela liberdade para fazer minhasescolhas na vida e seguir meus próprios caminhos. À Aldiene, minha querida esposa, pelos momentos de lazer trocados por estudo,pelo companheirismo e por estar sempre lembrando-me de que precisava estudar,quando alguma coisa nos distraía. A todos os colegas do curso pela companhia e colaboração durante esses anos deestudo e diversão. Ao Thiago Silva, que criou o projeto G-Portugol e o distribuiu sob a forma desoftware livre, sem o qual este presente trabalho não teria sido possível. E também peladisponibilidade para esclarecimentos de dúvidas acerca do mesmo. Aos professores do curso pela dedicação desprendida para a preparação dasaulas e orientação, mostrando os caminhos e atalhos dessa longa jornada. E emparticular aos que foram mais que professores de uma disciplina, mas que tornaram-seexemplos a serem seguidos. Citar nomes seria injusto, mas gostaria de agradecer àprofessora Rosiery Maia pela preciosa orientação durante essa monografia, e para oprofessor Aquiles Burlamaqui, que iniciou a orientação mas desligou-se da UERN. Por fim, agradeço aos funcionários do Campus Avançado de Natal e todos outrosque contribuíram de forma direta e indireta. Meu muito obrigado.
  • 7. Programas devem ser escritos parapessoas lerem e, apenas incidentalmente,máquinas executarem. Abelson e Sussman
  • 8. RESUMONo início dos cursos de computação no Brasil é oferecida uma disciplina de introdução aprogramação, em que comumente é utilizado um pseudo-código, conhecido comoportugol, para a escrita dos algoritmos. A utilização de uma linguagem de programaçãodificultaria o aprendizado, já que as instruções das linguagens de programação são eminglês, sobretudo por quem tem deficiências nesse idioma. Porém, devido a ausência deum compilador para o portugol, esses algoritmos não são convertidos em um programaexecutável, causando dúvida sobre a corretude dos mesmos e até desinteresse nadisciplina por parte dos alunos, entre outros problemas. Por outro lado, a adoção e usode softwares livres tem crescido por todo o mundo. Contudo, em alguns cursos, o alunosó tem contato com esses softwares em disciplinas mais avançadas, o que pode causaratraso no andamento, uma vez que alguns alunos tem dificuldades devido a falta deconhecimento até mesmo dos conceitos básicos. Dessa forma, em um cenário idealteríamos uma ferramenta de auxílio ao ensino de algoritmos sendo largamente utilizadasob uma plataforma livre. Na Internet, estão disponíves algumas ferrramentas com essepropósito. Em estudos comparatívos, o projeto G-Portugol foi apontado como sendo omais adequado. Esse projeto especifica um dialeto de portugol e disponibiliza umcompilador para o mesmo, tornando possível a execução do algoritmo pelo computador.No entanto, ele possui algumas limitações, principalmente no que diz respeito àsinstruções suportadas. Como também é um software livre, este trabalho propõe a adiçãode algumas novas instruções que estão ausentes mas são utilizadas nos cursos dealgoritmos. Além de propor as instruções, também fazemos a implementação de algumasdelas e a correção de algumas falhas no projeto.Palavras-chaves: Algoritmos. Compiladores. Programação. G-Portugol.
  • 9. ABSTRACTAt the beginning of the computing courses in Brazil is offered an discipline ofintroduction to programming, which is commonly used a pseudo-code, known asportugol, for the writing of algorithms. The use of a programming language difficult tolearn because the instructions programming languages are in English, especially bythose who have deficiencies in that language. However, due to lack of a compiler forportugol, these algorithms are not converted into an executable program, causingdoubt about the accuracy the same and disinterest in the discipline by students,among other problems. Moreover, the adoption and use of free software has grownaround the world. However, in some courses, the student only has contact withthese software in more advanced subjects, which can cause delay in progress, sincesome students have difficulties due to lack of knowledge of even basic concepts.Thus, in an ideal scenario we would have a tool to aid the teaching of algorithms iswidely used on a free platform. On the Internet, some tools are available for thispurpose. In comparative studies, the project G-Portugol was identified as the mostappropriate. This project specifies a dialect of portugol and provides a compiler for it,making possible the computer to run the algorithm. However, it has some limitations,especially as regards instructions supported. It is also a free software, this paperproposes the addition of some new instructions that are missing but are used inalgorithms courses. In addition to proposing the instructions, also make theimplementation of some of them and correction of some bugs in the project.Keywords: Algorithms. Compilers. Programming. G-Portugol.
  • 10. LISTA DE FIGURASFigura 1: Esquema de um compilador........................................................................20Figura 2: Visão detalhada de um tradutor..................................................................21Figura 3: Expressão regular que define um identificador válido em G-Portugol........23Figura 4: Exemplo de uso do metacaractere ? na gramática de G-Portugol.............25Figura 5: Expressão regular que define números inteiros decimais em G-Portugol..25Figura 6: Expressão regular que define os números inteiros em G-Portugol............25Figura 7: Expressão regular que define os números inteiros em G-Portugol............25Figura 8: Exemplo de declaração de variáveis em G-Portugol..................................31Figura 9: Sintaxe da declaração de algoritmos em G-Portugol..................................32Figura 10: Sintaxe da declaração de variáveis em G-Portugol..................................32Figura 11: Sintaxe da declaração do bloco principal em G-Portugol.........................33Figura 12: Sintaxe da instrução enquanto em G-Portugol.........................................33Figura 13: Sintaxe da instrução para em G-Portugol.................................................33Figura 14: Sintaxe da instrução se/senão/então em G-Portugol................................34Figura 15: Sintaxe da declaração de função em G-Portugol.....................................35Figura 16: GPTEditor: o editor da linguagem G-Portugol...........................................36Figura 17: Sintaxe do controle de repetição com teste lógico no fim.........................37Figura 18: Sintaxe do controle de decisão com múltipla escolha..............................37Figura 19: Sintaxe da definição de tipos de dados heterogêneo ..............................37Figura 20: Organização geral do código-fonte do GPT..............................................40Figura 21: Representação da geração da árvore de análise sintática.......................42Figura 22: Alterações na gramática de G-Portugol para controle de repetição comlaço no fim e controle de decisão com múltipla escolha............................................44Figura 23: Sintaxe da definição para parâmetros por referencia ..............................44Figura 24: Alterações na gramática de G-Portugol para suporte a tipos de dadosheterogêneos...............................................................................................................45Figura 25: Sintaxe nova instrução repita no G-Portugol.............................................45Figura 26: Inclusão da instrução repita no analisador sintático.................................46Figura 27: Regra ANTLR no analisador semântico para a instrução repita...............46Figura 28: Inclusão da instrução repita no analisador semântico..............................47Figura 29: Trecho do arquivo modules/parser/semantic.g com a definição da regrastm_repita....................................................................................................................47Figura 30: Mensagem que será exibida se o comando repita estiver com erro desintaxe.........................................................................................................................47Figura 31: Inclusão da instrução repita no módulo x86..............................................48Figura 32: Definição do stm_repita no módulo x86....................................................48Figura 33: Definição do stm_repita no módulo c_translator.......................................49Figura 34: Definição do stm_repita no módulo interpreter.........................................50Figura 35: Algoritmo com comando retorne no bloco principal..................................50Figura 36: Execução de um algoritmo sem suporte ao retorne no bloco principal....50Figura 37: Execução de um algoritmo com suporte ao retorne no bloco principal....51
  • 11. LISTA DE TABELASTabela 1: Metacaracteres para expressões regulares...............................................23Tabela 2: Exemplo de uso do metacaractere ............................................................24Tabela 3: Exemplo de uso do metacaractere []..........................................................24Tabela 4: Exemplo do metacaractere [] com e sem intervalo....................................24Tabela 5: Comparação entre ferramentas de auxílio ao ensino de algoritmos.........29Tabela 6: Tipos de dados primitivos...........................................................................32
  • 12. LISTA DE ABREVIATURAS E SIGLASANTLR ANother Tool for Language RecognitionASCII American Standard Code for Information InterchangeAST Abstract Syntax TreeENIAC Eletronic Numerical Integrator and ComputerGCC GNU C CompilerGPL General Public LicenseGPT É a principal ferramenta do projeto G-Portugol, responsável por fazer a compilação dos algoritmosIDC International Data CorporationIFRN Instituto Federal de Educação, Ciência e Tecnologia do Rio Grande do NorteNASM Netwide AssemblerSQL Structured Query LanguageUERN Universidade do Estado do Rio Grande do NorteUFRN Universidade Federal do Rio Grande do Norte
  • 13. SUMÁRIO1. INTRODUÇÃO ......................................................................................................141.1. OBJETIVOS.........................................................................................................161.1.1. Objetivo Geral..................................................................................................161.1.2. Objetivos Específicos.....................................................................................161.2. ESTRUTURA DO TRABALHO............................................................................162. CONSTRUÇÃO DE COMPILADORES..................................................................182.1. UM BREVE HISTÓRICO.....................................................................................182.2. VISÃO GERAL DE UM COMPILADOR ..............................................................202.3. VISÃO DETALHADA DE UM COMPILADOR.....................................................202.3.1. Análise Léxica.................................................................................................202.3.2. Análise Sintática.............................................................................................202.3.3. Análise Semântica..........................................................................................212.3.4. Geração de Código.........................................................................................212.3.5. Manipulador de Erros.....................................................................................212.4. TRADUTORES DE LINGUAGENS DE PROGRAMAÇÃO.................................222.5. EXPRESSÃO REGULAR PARA A DEFINIÇÃO DA GRAMÁTICA DE UMALINGUAGEM...............................................................................................................232.5.1. O metacaractere . (ponto)...............................................................................242.5.2. O metacaractere [] (lista)................................................................................242.5.3. O metacaractere ? (opcional)........................................................................242.5.4. O metacaractere * (asterisco)........................................................................252.5.5. O metacaractere + (mais)...............................................................................252.5.6. O metacaractere () (grupo).............................................................................252.5.7. O metacaractere | (ou)....................................................................................253. O PROJETO G-PORTUGOL..................................................................................263.1. FERRAMENTAS DE AUXÍLIO AO ENSINO DE ALGORITMOS EM SISTEMASGNU/LINUX.................................................................................................................273.2. DEFINIÇÃO DE UMA FERRAMENTA PARA O ENSINO DE ALGORITMOS....283.3. DECISÕES DE PROJETO ADOTADAS PARA A LINGUAGEM........................293.4. CARACTERÍSTICAS GERAIS DA LINGUAGEM................................................31
  • 14. 3.4.1. Declaração do Algoritmo ...............................................................................313.4.2. Declaração de Variáveis Globais..................................................................323.4.3. Bloco Principal................................................................................................323.4.4. Declaração de Funções..................................................................................343.5. O PROGRAMA GPT............................................................................................353.6. O PROGRAMA GPTEDITOR..............................................................................363.7. LIMITAÇÕES DA LINGUAGEM G-PORTUGOL.................................................364. ESTENDENDO A LINGUAGEM G-PORTUGOL...................................................394.1. ORGANIZAÇÃO GERAL DO CÓDIGO-FONTE DO GPT...................................404.2. FUNCIONAMENTO INTERNO DO COMPILADOR GPT....................................414.3. GRAMÁTICA DAS NOVAS INSTRUÇÕES DE G-PORTUGOL.........................434.3.1. Instruções de controle....................................................................................434.3.2. Passagem de Parâmetros por Referência....................................................444.3.3. Tipos de Dados Heterogêneos......................................................................444.4. ADIÇÃO DE UMA NOVA INSTRUÇÃO: O CASO DO REPITA... ATÉ...............454.4.1. Extensão do Analisador Sintático.................................................................454.4.2. Extensão do Módulo x86................................................................................474.4.3. Extensão do Módulo Tradutor para C...........................................................484.4.4. Extensão do Módulo Interpretador...............................................................494.5. SUPORTE PARA RETORNE NO BLOCO PRINCIPAL......................................505. CONCLUSÕES FINAIS..........................................................................................525.1. RESULTADOS.....................................................................................................525.2. SUGESTÕES PARA TRABALHOS FUTUROS..................................................53APENDICE A – PÁGINA MOSTRANDO TODAS AS CONTRIBUIÇÕES FEITASPARA O PROJETO G-PORTUGOL DURANTE ESTE TRABALHO........................57ANEXO A – PARTE DA MATRIZ DO CURSO DE CIÊNCIA DA COMPUTAÇÃO DAUERN ..........................................................................................................................58ANEXO B – MATRIZ DO CURSO DE CIÊNCIA DA COMPUTAÇÃO DA UFRN....59ANEXO C – MATRIZ DO CURSO TÉCNICO EM INFORMÁTICA DO IFRN...........60ANEXO D – GRAMÁTICA DA LINGUAGEM G-PORTUGOL..................................61
  • 15. 14 1. INTRODUÇÃO Geralmente no primeiro ou segundo semestre dos cursos da área deComputação, seja de nível técnico ou superior, é oferecida uma disciplina deconstrução de algoritmos ou de introdução à programação. Conforme mostram osanexos A, B e C. (MANZANO, 2001) destaca que normalmente são utilizadas nessasdisciplinas, para a definição dos algoritmos, uma técnica narrativa denominadapseudocódigo, também conhecida como “português estruturado” ou ainda chamadade “Portugol”. E ainda, que a diferença entre uma linguagem de programação e oPortugol é que este não pode ser convertido em um programa executável nocomputador. Sendo necessário que o professor leia a solução para que o aluno saibase sua implementação está correto. Como o professor também pode cometerequívocos, além da possibilidade da existência de mais uma solução para um dadoproblema, em alguns casos não haverá certeza absoluta de que a solução propostaestá completamente correta. O que acaba tornando desestimulante e cansativo oestudo para a iniciação da programação. Depois de algum tempo aprendendo algoritmos dessa forma, os alunospassam a utilizar uma linguagem de programação. (PINHEIRO, 2003) aponta queuma das linguagens mais utilizada em disciplinas de introdução à programação é alinguagem Pascal, uma vez que ela é praticamente uma transcrição do Portugol. A linguagem Pascal (JENSEN et al., 1991) foi criada pelo suíço Niklaus Wirthno início da década de 70, e batizada com esse nome em homenagem aomatemático Blaise Pascal (BROOKSHEAR, 1999). Um dos objetivos de NiklausWirth com a criação dessa linguagem era o ensino de programação estruturada, quepreconiza que todos os programas possíveis podem ser reduzidos a apenas trêsestruturas: sequência, decisão e iteração, como proposto por (DIJKSTRA, 1970). Por ser praticamente uma transcrição do Portugol, em primeiro momento osalunos transcrevem seus algoritmos para Pascal. Portanto, os alunos aprendemlógica de programação, escrevem os algoritmos em uma pseudo-linguagem etranscrevem para outra, no caso, Pascal. Em caso de erro no resultado da execução,como saber se tal equívoco foi no algoritmo inicial, em Portugol, ou foi somente
  • 16. 15inserido na fase de transcrição para Pascal? A disciplina perde seu principal objetivo,que é desenvolver no aluno raciocínio lógico para a resolução de problemas com oauxílio de um computador, forçando que o aluno torne-se versado em uma linguagemem particular. Considerando que essa disciplina é o alicerce para toda vidaacadêmica e profissional dos estudantes de computação, esse panorama torna-sebastante preocupante. Por outro lado, a adoção e uso de softwares livres, que são caraterizadospelas liberdades de uso, cópia, modificações e redistribuição (SILVEIRA, 2004), temcrescido em todo mundo, sendo o Brasil um dos maiores utilizadores edesenvolvedores desses softwares. Segundo (IDC, 2009), o mercado de softwarelivre mundial deverá ter um crescimento de 22,4% ao ano até 2013. Contudo, noscursos de Computação, os alunos só terão contado com esses softwares emdisciplinas mais avançadas, causando atraso no andamento normal das aulas, umavez que alguns alunos têm dificuldades devido à falta de conhecimento até mesmodos conceitos básicos inerentes a esses softwares. Em um cenário ideal, seria conveniente uma ferramenta de auxílio ao ensinode programação largamente utilizada sob uma plataforma livre, em particular umsistema GNU/Linux. Um dos softwares que poderia ser essa ferramenta é o KTurtle 1,um ambiente de programação educativo que usa a linguagem de programaçãoLogo2, e tenta manter a programação tão acessível quanto possível, tornando-seadequado para ensinar às crianças disciplinas como matemática, geometria eprogramação (BREIJS, 2004). Outras ferramentas também se propõem a suprir essa necessidade.(ARAÚJO, 2006) conclui que o projeto G-Portugol 3 é o projeto com maior potencialpara ser utilizado em cursos de computação no ensino de algoritmos sob ambientesGNU/Linux. O projeto G-Portugol especifica um dialeto do Portugol, de mesmo nome,e fornece um compilador para essa linguagem (SILVA, 2006). Porém, apesar de fácilinstalação e simples utilização, a ausência de alguns recursos impede que disciplinasintrodutórias de algoritmos sejam inteiramente ofertadas com esta ferramenta. Com1 Disponível em http://edu.kdeedu.org/kturtle e também nos repositórios da maioria das distribuições GNU/Linux2 Informações disponíveis em http://el.media.mit.edu/logo-foundation/. Acesso em 20 de agosto de 2009.3 Sítio na Internet do projeto G-Portugol: http://gpt.berlios.de
  • 17. 16isso, este trabalho determina pontos ainda limitadores do G-Portugol e demonstra aimplementação de uma extensão. 1.1. OBJETIVOS 1.1.1. Objetivo Geral O objetivo geral deste trabalho é estender a linguagem G-Portugol e suasferramentas correlatas, em particular o compilador GPT 4, de forma que possa sercompletamente utilizada em cursos de computação, em disciplinas introdutórias deprogramação, sob ambiente GNU/Linux. 1.1.2. Objetivos Específicos Os objetivos específicos são: • Estender a linguagem G-Portugol com os seguintes recursos: ◦ instrução para controle de interação com teste lógico no fim; ◦ instrução para controle de fluxo com múltipla escolha; ◦ suporte para tipos de dados heterogêneos, semelhante ao “Registro” apresentado por (MANZANO, 2001); ◦ passagem de parâmetros por referência. • Implementar no compilador da linguagem G-Portugol os recursos acima; • Interagir com o desenvolvimento de um software livre; • Documentar o desenvolvimento do trabalho e seus resultados. 1.2. ESTRUTURA DO TRABALHO Essa monografia está organizada em cinco capítulos, da seguinte forma: noprimeiro capítulo consta a introdução do trabalho e seus objetivos.4 GPT não é uma sigla, propriamente dita. Ë apenas o nome do compilador fornecido pelo projeto G- Portugol.
  • 18. 17 O segundo capítulo apresenta uma breve revisão acerca da teoria decompiladores. A linguagem G-Portugol e suas ferramentas correlatas são apresentadas noterceiro capítulo. O capítulo seguinte, informa a extensão da linguagem G-Portugol, e propõe asnovas instruções, com implementação de algumas delas no compilador. E por fim, o capítulo cinco apresenta os resultados obtidos, conclusão eindicações para trabalhos futuros.
  • 19. 18 2. CONSTRUÇÃO DE COMPILADORES 2.1. UM BREVE HISTÓRICO Para (PRICE, 2001), “o meio mais eficaz de comunicação entre pessoas é alinguagem (língua ou idioma)”. A mesma autora ainda afirma que para acomunicação entre homem e máquina, é utilizada uma linguagem de programação,que faz a tradução de pensamento humano e a precisão requerida para oprocessamento da máquina. Quando o primeiro computador eletrônico, chamado de Eletronic NumericalIntegrator and Computer (ENIAC), foi criado, na década de 40, a linguagem utilizadapara o desenvolvimento dos programas era a linguagem de máquina, definida por(LOUDEN, 2004) como “código numérico representando as operações de máquina aserem efetivamente executadas”, aceitando somente informações expressas emnotação de código binário, mas que podiam ser representados em notaçãohexadecimal (MANZANO, 2004). Foi a época das linguagens de primeira geração. Para facilitar o trabalho de codificação, no fim da década de 40 e início dadécada de 50, foram criadas as linguagens de montagem. Assembly (HYDE, 2003) éa mais conhecida. As instruções em Assembly, chamadas de mnemônicos, são muitomais fáceis de lembrar que seu código equivalente em binário ou mesmohexadecimal (MANZANO, 2004). Essas linguagens são a segunda geração daslinguagens de programação. Ainda na década de 50, surgiram as linguagens de programação de terceirageração. Fortran (BACKUS, 1957) é considerada por muitos, embora algunsdiscordem5, como a primeira linguagem compilada largamente aceita e utilizada. Noentanto, a linguagem foi projetada para a comunidade científica, e ainda eraespecífica para a máquina em que seria executada (SEBESTA, 2003). A primeira emque pode ser compilada para múltiplas arquiteturas foi a COBOL 6 (ROY, 1989), em1960.5 Alick E.Glennie escreveu um compilador para Autocode (http://en.wikipedia.org/wiki/Autocode) no Mark I em setembro de 1952, mas seu compilador é muito baixo-nível e orientado a máquina. Em maio de 1953, Laning and Zierler escreveram um sistema de tradução algébrica para o MIT Whirlwind, que é considerada por alguns como a primeira linguagem realmente compilada.6 Informações disponíveis em http://www.cobolstandards.com/. Acesso em 20 de agosto de 2009.
  • 20. 19 (PRICE, 2001) alerta para o fato de que as linguagens de terceira geraçãoforam projetadas para profissionais da área de processamentos de dados e não parausuários finais e, ainda, que a “depuração de programas escritos nessas linguagensconsome tempo, e a modificação de sistemas complexos é relativamente difícil”. Emresposta a esses problemas surgiram as linguagens de quarta geração. As linguagens de quarta geração foram projetadas com objetivos específicos,como o desenvolvimento de aplicações comerciais, diferentemente das linguagensde terceira geração, que são ditas linguagens de propósito geral. Para atingir essesobjetivos, as linguagens dessa geração utilizam mecanismos não presentes naslinguagens da geração anterior, como preenchimento de formulários, interação viavídeo, e auxílio para a construção de gráficos, como bem aponta (PRICE, 2001).Exemplos dessas linguagens são as planilhas eletrônicas, como o Calc doBrOffice.org7. Uma linguagem dessa geração bastante popular é o SQL (StructuredQuery Language), que fornece um padrão para a manipulação e consulta de bancode dados, sendo hoje em dia muito usada em conjunto com as linguagens de terceirageração (COSTA, 1999). Depois, surgiram as linguagens de quinta geração, que são usadasprincipalmente na área de Inteligência Artificial, facilitando a representação doconhecimento essencial para a simulação de comportamentos inteligentes (PRICE,2001). Prolog8 (CLOCKSIN, 2003), OPS59 (BROWNSTON, 1985) e Mercury10 sãolinguagens dessa geração. Como falamos acima, os primeiros compiladores surgiram na década de 50.Porém foi somente na década seguinte, com Algol 60 11 (WIRTH, 2005), que foramfundamentadas as técnicas para projetos de compiladores que são válidas até hoje.Serão essas técnicas que discutiremos a seguir.7 Disponível em http://broffice.org. Acesso em 21 de agosto de 2009.8 Informações disponíveis em: http://pauillac.inria.fr/~deransar/prolog/docs.html. Acesso em 21 de agosto de 2009.9 Informações disponíveis em: http://www.cs.gordon.edu/local/courses/cs323/OPS5/ops5.html. Acesso em 21 de agosto de 2009.10 Informações disponíveis em: http://www.mercury.csse.unimelb.edu.au/. Acesso em 21 de agosto de 2009.11 Informações disponíveis em: http://en.wikipedia.org/wiki/ALGOL_60. Acesso em 21 de agosto de 2009.
  • 21. 20 2.2. VISÃO GERAL DE UM COMPILADOR Para (WIRTH, 2005), compilador é um programa que traduz um programaescrito em uma linguagem de programação em instruções que serão executadas porum computador, o que pode ser graficamente representado pela Figura 1. Programa fonte Compilador Programa objeto Figura 1: Esquema de um compilador Fonte: Adaptado de PRICE, 2001 (PRICE, 2001) afirma que os compiladores “aceitam (como entrada) umarepresentação textual de um problema expresso em uma linguagem fonte, eproduzem uma representação do mesmo algoritmo expresso em uma outralinguagem, dita linguagem objeto”. 2.3. VISÃO DETALHADA DE UM COMPILADOR Os compiladores, por sua vez, são compostos por uma série de operações, asquais serão descritas a seguir e representados na Figura 2. 2.3.1. Análise Léxica A função do analisador léxico é fazer a leitura do código-fonte, caractere-a-caractere, e traduzi-lo para uma sequência de símbolos léxicos, também chamadosde tokens, que constituem a linguagem. O analisador léxico despreza comentários ebrancos desnecessários. Durante a análise léxica, é feita o preenchimento da tabela de símbolos. Essaestrutura de dados conterá um registro para cada token, com os campos contendo osatributos do identificador. Durante as demais fases, a tabela de símbolos seráatualizada e utilizada para consulta. 2.3.2. Análise Sintática A função da análise sintática é verificar se a cadeia de tokens produzida peloanalisador léxico pode ser gerada pela gramática da linguagem-fonte (AHO, 1995).
  • 22. 21 Figura 2: Visão detalhada de um tradutor Fonte: Adaptado de (PRICE, 2001) e (AHO, 1995) 2.3.3. Análise Semântica Após a confirmação da análise sintática que todas as cadeias de tokens foramcorretamente gerada pela gramática da linguagem-fonte, é necessário verificar seesses elementos estão corretamente combinados. A análise semântica éresponsável por fazer essa verificação. (AHO, 1995) aponta que um importantecomponente dessa fase é a verificação de tipos. 2.3.4. Geração de Código Esta é a fase onde de fato ocorre a tradução da linguagem-fonte nalinguagem-objeto. O resultado dessa fase é quase sempre código em linguagem demontagem, como o Assembly. 2.3.5. Manipulador de Erros Durante as fases de análise o compilador poderá encontrar erros noprograma-fonte. Se o compilador tiver a capacidade de identificar esse erro e a linhaem que ele ocorreu, além de recuperar-se do erro, e continuar o processo decompilação será de grande utilidade para quem escreveu o programa.
  • 23. 22 2.4. TRADUTORES DE LINGUAGENS DE PROGRAMAÇÃO Existem alguns tipos de ferramentas com funções semelhantes aoscompiladores, no sentido de converter programas de uma linguagem para outra, noentanto se diferem pelos tipos de entrada que aceitam e pela saída que produzem.Esses programas são coletivamente chamados de tradutores, e segundo (PRICE,2001) podem ser classificados em: • Montadores (assemblers): mapeiam instruções em linguagem simbólica (Assembly) para instruções de linguagem de máquina, em uma relação de uma-para-uma, isto é, uma instrução de linguagem simbólica para uma instrução de linguagem de máquina; • Macro-assemblers: traduzem instruções em linguagem simbólica para instruções em linguagem de máquina, como os montadores. No entanto, geralmente o fazem em uma relação de uma-para-muitas; • Compiladores: são programas que traduzem código escrito em linguagem de alto nível para códigos equivalentes em linguagem simbólica ou linguagem de máquina; • Pré-compiladores, pré-processadores ou filtros: são tradutores que realizam conversões entre duas linguagens de alto nível; • Interpretadores: são processadores que aceitam como entrada o código intermediário de um programa anteriormente traduzido e produzem o “efeito de execução” do algoritmo original sem, porém, mapeá-lo para uma linguagem de máquina. Alguns interpretadores trabalham diretamente sobre o código-fonte, analisando um comando fonte a cada vez que esse deve ser executado. (SEBESTA, 2003) ressalta que “o implementador pode oferecer tantoimplementações compiladas como interpretadas para uma linguagem”. Dessa formao interpretador poderá ser utilizado para desenvolver e para depurar programas.Quando o código estiver em um estado livre de erros, os programas poderão sercompilados para aumentar sua velocidade de execução. As implementações
  • 24. 23interpretadas serão particularmente úteis em laboratórios para ensino deprogramação. Além dos tradutores, existem outros diversos programas relacionados acompiladores, tais como carregadores, montadores, editores entre outros. Umarápida relação e discussões desses e outros programas está presente em (LOUDEN,2004). 2.5. EXPRESSÃO REGULAR PARA A DEFINIÇÃO DA GRAMÁTICA DE UMA LINGUAGEM Para a definição da gramática de uma linguagem é utilizada a notação deexpressões regulares, que são utilizadas para a especificação de padrões (AHO,1995). Como exemplo desse reconhecimento de padrões, podemos citar a definiçãode identificadores válidos em G-Portugol, que devem começar com uma letra ou ocaractere “_” e serem seguidos de letras, números ou novamente o caractere “_”, emqualquer quantidade e ordem. A Figura 3 apresenta a expressão regular que defineesse padrão. [a-zA-Z_][a-zA-Z0-9_]* Figura 3: Expressão regular que define um identificador válido em G-Portugol Os caracteres [, ] e * são chamados de metacaracteres, símbolos com funçõesespeciais, e que associados aos símbolos normais formam as expressões regulares. (JARGAS, 2006) é uma obra completa sobre expressões regulares. A Tabela1 apresenta alguns metacaracteres. Tabela 1: Metacaracteres para expressões regulares Metacaractere Mnemônico Função . Ponto Um caractere qualquer [] Lista Lista de caracteres permitidos ? Opcional Zero ou um * Asterisco Zero, um ou mais + Mais Um ou mais () Grupo Delimita um grupo | Ou Ou um ou outro Fonte: Adaptado de (JARGAS, 2006)
  • 25. 24 2.5.1. O metacaractere . (ponto) O metacaractere . é um curinga que substitui qualquer outro caractere, sendoque é um e somente um caractere. Como exemplo do uso do ., temos a Tabela 2. Tabela 2: Exemplo de uso do metacaractere . Expressão Casa com n.o não, nao, ... .eclado teclado, Teclado, ... e.tendido estendido, extendido, .. Fonte: Adaptado de (JARGAS, 2006) 2.5.2. O metacaractere [] (lista) Diferentemente do metacaratere ., no [] definimos exatamente quais serão oscaracteres que irão casar, como no caso do exemplo da Tabela 3. Tabela 3: Exemplo de uso do metacaractere [] Expressão Casa com n[aã]o não, nao [Tt]eclado teclado, Teclado e[sx]tendido estendido, extendido Fonte: Adaptado de (JARGAS, 2006) Este metacaractere foi utilizado na Figura 3, sendo que ali os caracteresaceitos foram reduzidos graças a possibilidade do uso de intervalos, através docaractere -, como mostra a Tabela 4. Tabela 4: Exemplo do metacaractere [] com e sem intervalo Expressão sem intervalo Expressão com intervalo [0123456789] [0-9] Fonte: Adaptado de (JARGAS, 2006) Esses intervalos são definidos pela ordem numérica da tabela AmericanStandard Code for Information Interchange (ASCII) 12. 2.5.3. O metacaractere ? (opcional) O metacaractere ? torna o(s) caractere(s) a qual ele se refere opcional,podendo ou não fazer parte do padrão em análise, e se fizer parte só será permitidouma ocorrência. No caso de G-Portugol, teremos o bloco de declaração de variáveis12 Disponível em http://www.tabelaascii.com/. Acesso em 08 de setembro de 2009.
  • 26. 25como opcional, representado por (var_decl_block), portanto a expressão regularterá a forma apresentada na Figura 4. algoritmo : declaracao_algoritmo (var_decl_block)? stm_block (func_decls)* EOF ; Figura 4: Exemplo de uso do metacaractere ? na gramática de G-Portugol 2.5.4. O metacaractere * (asterisco) Enquanto o metacaractere ? permite zero ou uma ocorrência, o metacaractere* permite qualquer quantidade. Este metacaractere é aplicável para a declaração defunções em G-Portugol, representado por (func_decls), como na Figura 4. 2.5.5. O metacaractere + (mais) O metacaractere + obriga ao menos uma ocorrência do padrão, como nadefinição do inteiros decimais em G-Portugol, apresentado na Figura 5. [0-9]+ Figura 5: Expressão regular que define números inteiros decimais em G-Portugol 2.5.6. O metacaractere () (grupo) O metacaractere () é utilizada para agruparmos caracteres e metacaracteres,e aplicamos outros metacaracteres sobre o grupo, como na definição dos númerosbinários em G-Portugol, que podem ter um “b” ou um “B”, conforme Figura 6. 0 (b|B) [01]+ Figura 6: Expressão regular que define os números inteiros em G-Portugol 2.5.7. O metacaractere | (ou) O metacaractere | significa “ou”, permitindo a ocorrência de uma coisa ououtra, como na regra para a definição de números inteiros em G-Portugol,apresentada na Figura 7. T_OCTAL_LIT | T_HEX_LIT | T_BIN_LIT | T_DEC_LIT Figura 7: Expressão regular que define os números inteiros em G-Portugol
  • 27. 26 3. O PROJETO G-PORTUGOL Em 1953, Grace Hopper sugeriu que “(...) programas de processamentos dedados deveriam ser escritos em inglês” (WEXELBLAT, 1981 citado por SEBESTA,2003). Para conseguir o financiamento para o desenvolvimento desse projeto, queseria a principal progenitora do COBOL, foi necessária a implementação de umprotótipo, que envolveu compilar e executar um pequeno programa, inicialmenteusando palavras-chaves em inglês, depois palavras-chaves francesas e por fim compalavras-chaves alemãs. Hoje em dia, as linguagens mais comuns possuem essacaracterística de utilizar a língua inglesa como referência, facilitando o aprendizadopara quem dominar o idioma inglês. Geralmente para ensinos introdutórios de programação de computadores e deconcepção de algoritmos, usa-se uma linguagem/pseudo-código conhecido comoPortugol ou Português Estruturado, com palavras-chaves em português. No entanto,essa linguagem não é única, possuindo algumas variações, os chamados dialetos.Cada autor, e professor, utiliza o dialeto que melhor lhe convém. O dialeto de(MANZANO, 2001) é diferente do utilizado por (GUIMARÃES, 1994). Gerar um programa executável pelo computador a partir de um algoritmoescrito em Portugol é fundamental para o alcance do objetivo de uma disciplina dealgoritmos e introdução a programação ser alcançado, que é possibilitar ao alunodesenvolver o raciocínio lógico necessário para a resolução de problema com oauxílio de um computador, e não que ele seja versado em uma linguagem emparticular. Quando lança-se mão de uma linguagem para essas disciplinas, osestudantes e professores acabam por atendo-se mais com o estudo dessalinguagem, fugindo do objetivo da disciplina (SILVA, 2006). Além disso, raramente oslivros fornecem ferramentas para converter o algoritmo escrito em Portugol em umprograma executável. Dessa forma, os aprendizes não podem executar osprogramas escritos por eles. Dependendo da conferência de um tutor – humano,portanto, passível a erros – para verificar se o programa está correto. Sendo assim,caso se queira executar um programa em Portugol será necessário recorrer a algumprojeto que disponibilize um compilador, e provavelmente o dialeto implementadoserá diferente do livro-texto.
  • 28. 27 O projeto mais conhecido e utilizado para o ensino de algoritmos que faça usode palavras-chaves em português é o VisuAlg 13. Porém ele só está disponível parasistemas Windows e, por não ser software livre, não é possível que ele seja adaptadopara outros sistemas ou mesmo estendido com novos recursos. 3.1. FERRAMENTAS DE AUXÍLIO AO ENSINO DE ALGORITMOS EM SISTEMAS GNU/LINUX Na pesquisa realizada por (ARAÚJO, 2006) acerca de ferramentas de auxílioao ensino de algoritmos foram identificados e analisados três projetos que poderiamsuprir essa necessidade em ambientes GNU/Linux: • Quila14: a característica mais vantajosa dessa ferramenta é a sintaxe semelhante ao Pascal, mas com as palavras-chaves em português. Porém, esse interpretador só está disponível em formato de código-fonte, sendo necessário sua compilação para uso, que pode não ser trivial para quem está começando no mundo da computação. Além disso, o Quila foi escrito com instruções que o deixaram dependentes do compilador GCC (GNU Compiler Compiler)15, sendo incompatível com as versões mais recentes, dificultando a compilação e instalação. Atualmente o projeto está abandonado pelo seu autor original. • AlgoMais16: é um interpretador de algoritmos que embora feita na linguagem Java17 (GOSLING, 2005), conhecida pela sua portabilidade, para ser executado em ambiente GNU/Linux é necessário uma série de ajustes manuais, o que o deixa inviável para iniciantes. • Por fim, o G-Portugol 18 é um projeto que envolve a definição de uma linguagem, também chamada de G-Portugol. Sua principal ferramenta é o GPT, que faz a compilação para linguagem de máquina, tradução para C 19 (KERNIGHAN, 2005) e Assembly, e interpretação dos algoritmos. A outra13 Disponível em http://www.apoioinformatica.inf.br/visualg. Acesso em 22 de agosto de 2009.14 Disponível em http://codigolivre.org.br/projects/quila/. Acesso em 22 de agosto de 2009.15 Disponível em http://gcc.gnu.org. Acesso em 22 de agosto de 2009.16 Disponível em http://ccet.ucs.br/dein/napro/algoritmo/algoritmo_htm. Acesso em 22 de agosto de 2009.17 Disponível em http://java.sun.com/. Acesso em 22 de agosto de 2009.18 Disponível em http://gpt.berlios.de. Acesso em 22 de agosto de 2009.19 Disponível em http://www.open-std.org/jtc1/sc22/wg14/. Acesso 22 de agosto em 2009.
  • 29. 28 ferramenta é o GPTEditor, editor para a linguagem com recursos de destaque de sintaxe e depuração. Esse foi o projeto mais bem acabado, incluindo a documentação. No entanto, a linguagem G-Portugol não é totalmente compatível com o Português Estruturado comumente apresentado nos cursos de algoritmos, não podendo ser completamente utilizado em um curso que envolvesse programação e não eram disponibilizados pacotes prontos para a instalação nas distribuições GNU/Linux, sendo necessário a compilação dos arquivos fontes, além de outros problemas citados na próxima seção desse documento. 3.2. DEFINIÇÃO DE UMA FERRAMENTA PARA O ENSINO DE ALGORITMOS Com o objetivo de definirmos o projeto mais adequado para o ensino dealgoritmos em sistema GNU/Linux, levando-se em consideração a provávelinexperiência dos alunos com esse sistema e até mesmo com computação de formageral, foi feita uma comparação entre esses três projetos, que é apresentado naTabela 5. Os critérios utilizados para essa definição foram: • Linguagem em que foi desenvolvido; • Licença em que o software é distribuído; • Modos de execução oferecido pela ferramenta: ◦ Compilação; ◦ Interpretação; ◦ Tradução; • Editor para a linguagem; • Execução de forma nativa em ambientes GNU/Linux; • Documentação disponível;
  • 30. 29 • Atividade atual de desenvolvimento do projeto; • Facilidade de uso; • Facilidade de instalação. Tabela 5: Comparação entre ferramentas de auxílio ao ensino de algoritmos Quila AlgoMais G-Portugol Linguagem em que foi C++ Java C++ desenvolvido Licença GPL ??? GPL Compilador x x Interpretador x x Editor x x Nativo x x Documentação Razoável Excelente Ativo x Usabilidade Boa Razoável Boa/Excelente Instalação Difícil Muito difícil Difícil Fonte: (ARAÚJO, 2006) Apesar dos problemas apresentados pelo G-Portugol, este projeto foi indicadocomo mais promissor para ser utilizado em cursos de algoritmos sob ambienteGNU/Linux. Outra boa vantagem desse projeto era o fato de também ser possível asua execução em ambiente Windows, pois embora não fosse uma característicafundamental, ter uma ferramenta multiplataforma é sempre desejável. Além disso, oprocedimento de instalação está facilitado, uma vez que não existem mais as falhasde incompatibilidade de codificação de caracteres citadas por (ARAÚJO, 2006) eestão disponibilizado os pacotes de instalação no repositório da distribuição Debian 20GNU/Linux e nos repositórios de distribuições derivadas desta. 3.3. DECISÕES DE PROJETO ADOTADAS PARA A LINGUAGEM Antes que as características e recursos oferecidos pela linguagem G-Portugolsejam detalhados, é importante conhecermos quais foram os parâmetros queinfluenciaram nas decisões de projeto.20 Disponível em: http://debian.org/. Acesso em 22 de agosto de 2009.
  • 31. 30 O ponto fundamental que guiou as diretrizes da linguagem é seu propósitoeducacional. Ela deveria expressar o raciocínio lógico para a solução dos problemasde forma que um aluno iniciante os compreenda sem ater-se a detalhes dalinguagem, estimulando a capacidade de abstração do estudante. Também é interessante que a linguagem mantenha compatibilidade com osdialetos de Portugol apresentadas pela literatura, como o utilizado por (MANZANO,2001). Portanto, embora o desenvolvimento da linguagem fosse direcionado poralgumas diretrizes, em alguns momentos elas foram sacrificadas em prol dessacompatibilidade. As diretrizes que guiaram o desenvolvimento foram: • Diretriz 1: a linguagem deve ser totalmente em português e respeitar acentuações. As linguagens com palavras-chave em inglês, naturalmente não possuem instruções com acentos, mas também a maioria delas não aceita que se defina variáveis, por exemplo com caracteres especiais (acentos, cedilhas, e outros que não pertençam ao alfabeto inglês). Essa decisão foi tomada para, aproximar a linguagem do português o máximo possível, deixando o código mais legível e de leitura mais agradável, do ponto de vista da semelhança com a linguagem natural já conhecida pelo aluno. As palavras-chave devem aparecer completas ou por extenso, não permitindo abreviações (ex.: “proc”, “var”, “func” etc.), facilitando, dessa forma, a leitura dos algoritmos, o que não ocorre com o VisuAlg. No entanto, o G-Portugol não estendeu essa característica para identificadores definidos pelo usuário, seja nome de variáveis ou funções. Algumas linguagens utilizam “comandos” no imperativo ou o infinito pode ser utilizado. G-Portugol optou por usar o imperativo. • Diretriz 2: a linguagem deve ser simples, uniforme e coerente. Essa diretriz evita exceções entre as formas gramaticais e comportamentos semânticos da linguagem. Ou seja, além de serem simples, claros e óbvios, as estruturas e comandos devem ter um princípio em comum, evidenciando um formato uniforme. Como exemplo, o padrão de delimitação de blocos de comandos é termos o bloco iniciado pela <instrução> e finalizado com fim- <instrução>, como na declaração de variáveis, que é semelhante à adotada por (GUIMARÃES, 1994), representada na Figura 8. Além disso, somente recursos essenciais deveriam fazer parte de seu núcleo. Portanto, em um
  • 32. 31 primeiro momento, não é interessante equipar a linguagem com recursos como alocação dinâmica de memória, paralelismo, acesso a recursos do sistema operacional etc. variáveis idade: inteiro; fim-variáveis Figura 8: Exemplo de declaração de variáveis em G-Portugol • Diretriz 3: deve ser configurável para diferentes abordagens de ensino e estilo do professor. Essa é uma diretriz bastante inovadora, pois permite que a linguagem mude em certos aspectos de acordo com a preferência do professor, ou como modo de adaptar-se à forma de Portugol de uma determinada literatura. Por exemplo, pode ser interessante que, para a delimitação de bloco, sejam utilizadas chaves (“{” e “}”), como na linguagem de programação C, ou a abordagem utilizada por Python 21 (ROSSUM, 2003), que utiliza recuos para limitações de blocos. No entanto, essa característica não está implementada em G-Portugol, necessitando de modificações do código-fonte para ter um comportamento diferente do atual. 3.4. CARACTERÍSTICAS GERAIS DA LINGUAGEM Segundo (SILVA, 2006), “a linguagem em si não difere fundamentalmente ouapresenta novidades em relação ao uso popular de portugol”. É uma linguagemimperativa, com comandos de controle de fluxo, manipulação de dados e recursosbásicos de entrada e saída. Além disso é uma linguagem case-sensitive, ou seja, elafaz distinção entre letras maiúsculas e minúsculas. Uma função “leia” é diferente deuma função “Leia”. Os algoritmos em G-Portugol têm uma forma estrutural semelhante a Pascal,relatada nas subseções seguintes. 3.4.1. Declaração do Algoritmo Essa seção não influencia na execução do algoritmo. No entanto, o nome doalgoritmo será utilizado para o arquivo gerado pelo processo de compilação, caso21 Disponível em: http://python.org/. Acesso em 22 de agosto de 2009.
  • 33. 32não seja informado outro nome. No projeto do compilador, ele poderia ter sidoomitido, no entanto foi mantido por questões de compatibilidade com a literatura. A declaração do algoritmo possui a sintaxe apresentada na Figura 9. algoritmo <nome do algoritmo>; Figura 9: Sintaxe da declaração de algoritmos em G-Portugol 3.4.2. Declaração de Variáveis Globais Essa seção é opcional. É semanticamente similar ao Pascal, que define umbloco exclusivamente para esse fim e fora do bloco principal, mas sua sintaxe éligeiramente diferente, necessitando de delimitadores para abrir e fechar o bloco,como mostra a Figura 10. variáveis <nome da variável>: <tipo de variável>; fim-variáveis Figura 10: Sintaxe da declaração de variáveis em G-Portugol Entre a abertura e o fechamento do bloco podem ser declaradas diversasvariáveis, de acordo com os tipos suportados, explicitados na Tabela 6. Com essestipos é possível criar conjuntos como vetores e matrizes de qualquer dimensão. Tabela 6: Tipos de dados primitivos Tipos Exemplos inteiro 12 real 3.4 caractere a literal “uma frase” lógico VERDADEIRO Fonte: Adaptado de (SILVA, 2006) 3.4.3. Bloco Principal O bloco principal é o trecho onde a execução propriamente dita do algoritmocomeça. É o que, segundo (SILVA, 2006) , chama-se de ponto de entrada. Nele estátoda a lógica de resolução do problema, com as estruturas de controle e chamadaspara sub-rotinas. É semelhante a Pascal e a forma é bastante comum (MANZANO,2001) e (GUIMARÃES, 1994). A sintaxe do bloco principal em G-Portugol é exibida na Figura 11.
  • 34. 33 início <comandos> fim Figura 11: Sintaxe da declaração do bloco principal em G-Portugol 3.4.3.1. Estruturas de Controle As estruturas de controle do G-Portugol são as seguintes: • Repetição com teste no início. A instrução enquanto é responsável por controlar uma repetição com teste no início. Seu funcionamento é o mesmo que em outras linguagens de programação. O bloco de comandos será executado enquanto uma determinada condição possuir valor lógico verdadeiro. Se já da primeira vez o resultado da expressão for falso, o bloco de comando não será executado nenhuma vez. Possui a sintaxe exibida na Figura 12. enquanto <teste lógico> faça <comandos a serem executados> fim-enquanto Figura 12: Sintaxe da instrução enquanto em G-Portugol • Repetição com variável de controle. Este é o comando para, que é uma especialização do comando enquanto utilizando uma variável de controle, escrito numa notação compactada. A sintaxe do para é apresentada na Figura 13.para <variável> de <expressão> até <expressão> [passo <inteiro>] faça <comandos a serem executados>fim-para Figura 13: Sintaxe da instrução para em G-Portugol Onde: ◦ <variável> deve ser variável numérica; ◦ <expressão> deve ser uma expressão que tem valor avaliado como numérico; ◦ [passo], se existir, deve ser seguido por um inteiro constante. Tanto no enquanto quanto no para é possível que a variável de controle tenha seu valor alterado nos comandos internos. Isso é particularmente útil para encerrar a execução de um laço prematuramente, já que o G-Portugol
  • 35. 34 não dispõe de mecanismos para isso, como o comando abandone utilizado por (GUIMARÃES, 1994). • Controle com decisão simples. O G-Portugol oferece apenas uma estrutura de decisão simples, o se/senão/então, que também não difere muito de outras linguagens e da literatura sobre algoritmos. A sintaxe dessa estrutura é apresentada na Figura 14. O senão é opcional, já o fim-se é obrigatório, diferente de algumas linguagens de programação. se <expressão> então <comandos que serão executados caso expressão seja verdadeiro> senão <comandos que serão executados caso expressão seja falso> fim-se Figura 14: Sintaxe da instrução se/senão/então em G-Portugol Embora não possua todas as estruturas comumente apresentadas naliteratura, com as instruções oferecidas pelo G-Portugol é possível resolver qualquertipo de problema. 3.4.4. Declaração de Funções Enquanto (GUIMARÃES, 1994) utiliza o conceito de procedimentos e funçõespara sub-programas, o G-Portugol disponibiliza funções com ou sem retorno. Asdefinições de funções deverão ser feitas após o bloco principal, contrastando comPascal, que exige a declaração das funções antes de sua chamada. O retorno dasfunções é feito através da instrução retorne, e o valor de retorno deve sercompatível com o tipo da função. A declaração das variáveis locais é feita entre a assinatura da função e apalavra chave início, portanto, não é uniforme em relação a declaração global,onde se usa as palavras-chaves variáveis e fim-variáveis. A declaração deparâmetros da função também não segue estritamente o formato de declaração devariáveis. Veja a sintaxe da declaração de funções na Figura 15.
  • 36. 35 função <nome da função>(<declaração de parâmetros>)[: <tipo>] <declaração de variáveis locais da função> início <corpo da função> fim Figura 15: Sintaxe da declaração de função em G-Portugol Onde : ◦<nome da função> é o nome da função; ◦<declaração de parâmetros> é a lista de parâmetros da função e tem a forma: <variável>:<tipo> separados por vírgula ◦<tipo>, se existir, é o tipo de retorno da função e não pode ser do tipo agregado, como matrizes ou vetores. 3.5. O PROGRAMA GPT O programa GPT é a principal ferramenta associada à linguagem G-Portugol.Entre suas funções estão: • Compilar algoritmos. O GPT é capaz de gerar executáveis tanto para sistemas GNU/Linux quanto para sistemas Windows. No entanto, ele não gera o programa binário diretamente, sendo dependente do NASM 22 (Netwide Assembler), um compilador para linguagem Assembly. A partir do código em G-Portugol, o GPT gera código em Assembly e executa o NASM para gerar o código binário, mas isso acontece sem que o usuário perceba; • Traduzir algoritmos para outras linguagens. É possível também converter o programa escrito em G-Portugol nas linguagens Assembly e C, que poderão ser compilados com o NASM e o GCC, respectivamente; • Executar algoritmos. Por fim, existe a possibilidade de executar o algoritmo sem a geração de código binário, atuando como um interpretador.22 Disponível em http://www.nasm.us/. Acesso em 22 de agosto de 2009.
  • 37. 36 3.6. O PROGRAMA GPTEDITOR Além do compilador GPT, outra ferramenta disponibilizada pelo projeto G-Portugol é o GPTEditor. O GPTEditor é um editor simples e amigável para escrever,depurar e executar algoritmos escritos em G-Portugol. Além dos recursos padrões deeditores de arquivo (abrir, fechar, salvar), ele possui o recurso de destaque desintaxe, evidenciando para o usuário as palavras-chaves da linguagem, facilitando oaprendizado e fixação dos termos de G-Portugol, conforme mostra a Figura 16. Figura 16: GPTEditor: o editor da linguagem G-Portugol Fonte: http://gpt.berlios.de/demos/gpteditor/debug/debug.html No que diz respeito a depuração dos algoritmos, é possível adicionar pontosde parada, ou seja, quando o algoritmo está em execução e chega em uma linhamarcada como ponto de parada, sua execução é interrompida e o usuário poderá,por exemplo, inspecionar os valores das variáveis, e executar passo-a-passo orestante do algoritmo em busca de erros cometidos. 3.7. LIMITAÇÕES DA LINGUAGEM G-PORTUGOL A linguagem G-Portugol apresenta algumas limitações, não disponibilizandotodas as instruções e recursos costumeiramente utilizados em cursos introdutórios deprogramação. Fazendo um comparativo com (MANZANO, 2001), estão ausentes emG-Portugol os seguintes elementos:
  • 38. 371. Controle de repetição com teste lógico no fim, que possui a estrutura mostrada na Figura 17. repita <instruções que serão executadas pelo menos uma vez> até <condição>; Figura 17: Sintaxe do controle de repetição com teste lógico no fim2. Controle de decisão com múltipla escolha, substituindo uma sequência de instruções se/então/senão encadeadas, com sintaxe exibida na Figura 18. caso <variável> seja <valor1> faça <instruções que serão executadas se variável for igual a valor1> seja <valor2> faça <instruções que serão executadas se variável for igual a valor2> ... senão <instruções que serão executadas se variável não for igual a nenhum dos casos definidos anteriormente> fim-caso Figura 18: Sintaxe do controle de decisão com múltipla escolha3. Estrutura de dados heterogênea: conhecido como registro, possibilitando que vários dados de tipos diferentes – os campos – em uma única variável. Sendo definido da forma apresentada na Figura 19. tipo <identificador> = registro <campo1>: <tipo do campo1>; <campo2>: <tipo do campo2>; ... fim-registro Figura 19: Sintaxe da definição de tipos de dados heterogêneo4. Passagem de parâmetros por referência: caraterizada pela alteração do valor da variável passada como parâmetro para uma sub-rotina, quando este parâmetro é modificado dentro dela.
  • 39. 38 A ausência desses recursos impede o uso de G-Portugol e o seu compiladorGPT durante todo um curso de algoritmos com programação estruturada. Alémdesses também podemos apontar outros itens a serem melhorados: 1. Possibilidade de retorno de funções com tipos agregados, como matrizes e vetores; 2. Adição da instrução abandone, conforme apresentado por (GUIMARÃES, 1994), que causa o interrompimento precoce de um laço de repetição; 3. Correção de algumas inconformidades, como: ◦ Impossibilidade do uso de acentos em identificadores; ◦ Restrição ao usar identificadores com termos que são palavras-chaves ou funções da biblioteca de C, pois poderá interferir na tradução para essa linguagem.
  • 40. 39 4. ESTENDENDO A LINGUAGEM G-PORTUGOL Para que a linguagem G-Portugol possa ser inteiramente utilizada e bemsucedida em disciplinas de construção de algoritmos, é necessário que ela venha adar suporte para os itens apresentados na seção anterior. Que são: • Controle de repetição com teste lógico no fim; • Controle de decisão com múltipla escolha; • Estrutura de dados heterogênea; • Passagem de parâmetros por referência. Os conhecimentos necessários para a realização dessa extensão são: 1. Linguagem de programação de alto nível C++; 2. Linguagem de programação de baixo nível Assembly; 3. Conhecimento das fases de um compilador; 4. Compreensão acerca dos analisadores sintáticos preditivos recursivos dos compiladores; 5. Conhecimento do ANTLR v2 23 (ANother Tool for Language Recognition) e suas gramáticas léxicas, sintáticas e de árvores; 6. Perícia para analisar e compreender códigos escritos por outro desenvolvedor; 7. Preferencialmente, conhecimento de como se dá o desenvolvimento de software livre e as ferramentas utilizadas como suporte para esse fim. Em particular, o sistema de controle de versão Subversion 24.23 Disponível em http://antlr2.org/. Acesso em 23 de agosto de 2009.24 Disponível em http://subversion.tigris.org/. Acesso em 23 de agosto de 2009.
  • 41. 40 4.1. ORGANIZAÇÃO GERAL DO CÓDIGO-FONTE DO GPT A Figura 20 exibe a estrutura geral de diretórios e arquivos do código-fonte doGPT. Os arquivos GPT.*25 contém a definição da classe principal do compilador, queé a classe GPT, a qual possui a seguinte interface: • void showHelp(); • void showVersion(); • bool compile(); • bool translate2c(); • bool interpret(); Figura 20: Organização geral do código-fonte do GPT Os dois primeiros métodos exibem, respectivamente, uma ajuda e a versão docompilador no terminal. Os outros métodos são os responsáveis por fazer a25 Usaremos arquivo.* para representar o arquivo cabeçalho C++ (.hpp) e sua implementação (.cpp)
  • 42. 41compilação, a tradução para a linguagem C e a interpretação de um programa escritoem G-Portugol, que será a entrada para o GPT. Esses métodos usarão as classes e funções definidas nos subdiretóriosabaixo do diretório modules: • c_translator: contém o tradutor para C; • interpreter: contém o interpretador; • x86: contém o gerador para o equivalente binário do programa em G-Portugol; • parser: neste diretório estão partes dos analisadores léxico, sintático e semântico que são comuns a todos os outros três módulos do compilador GPT. Nos arquivos GPTDisplay.* está definido a classe GPTDisplay, que éresponsável por enviar todas as mensagens do compilador para o usuário. Os arquivos SymbolTable.*, Symbol.* e PortugolAST.* possuem classes queabstraem os símbolos da linguagem, a tabela de símbolos e a árvore sintáticaabstrata, respectivamente. 4.2. FUNCIONAMENTO INTERNO DO COMPILADOR GPT Para qualquer operação relevante do GPT (compilar, traduzir, interpretar), oarquivo fonte em G-Portugol deverá passar, pelo menos, pela análise léxica, sintáticae semântica. Os arquivos referentes a estas fases estão em src/modules/parser,como já falamos. Por conveniência, o parser PortugolParser gerado pelo ANTLR temBasePortugolParser como classe base, que oferece algumas funcionalidades. O resultado da análise sintática, efetuada pelo PortugolParser em conjuntocom o PortugolLexer, será uma árvore abstrata ou nulo, dependendo da ocorrênciade erros na análise. A árvore é gerada segundo as regras de geração de nós nagramática definida no arquivo parser/parser.g e os nós são objetos da classePortugolAST. Essa interação é representada na Figura 21.
  • 43. 42 Figura 21: Representação da geração da árvore de análise sintática Fonte: Wiki do Projeto G-Portugol A AST (Abstract syntax tree) será utilizada, em seguida, como entrada para aanálise semântica, realizada pela classe SemanticWalker em conjunto com a classeSemanticEval. Examinando os arquivos parser/SemanticWalker.* eparser/SemanticEval.* veremos que os primeiros foram geradosautomaticamente pelo ANTLR, de acordo com as regras definidas emparser/semantic.g. Sempre que essa fase for bem sucedida, o resultado será amesma árvore, porém, com dados semânticos preenchidos no nós, como o tipo dedado, por exemplo. Essa árvore anotada é resultado da etapa de análise e a entradada fase de síntese, mostradas na Figura 2. A fase de geração de código do GPT será executada por um dos três módulosapresentados na seção anterior: c_translator, interpreter e x86. Eles recebem comoentrada a AST preenchida e realizam alguma atividade a partir dessa árvore.Portanto, o ponto de entrada de cada módulo “treewalker” que percorre os nós daárvore e realiza operações de acordo com a estrutura desses nós e que foi geradoautomaticamente pelo ANTLR com base na gramática definida no arquivo com aextensão .g, presente em cada módulo. Esses módulos possuem a seguintecomposição e funcionalidades: 1. c_translator: o módulo de tradução para linguagem C é o mais simples do três, possuindo apenas um arquivo fonte, pt2c.g, que define a gramática ANTLR para navegação na árvore sintática. A partir desse arquivo serão criados a
  • 44. 43 classe Portugol2CWalker, no arquivo Portugol2CWalker.*, e outros arquivos com funcionalidades auxiliares. 2. interpreter: é o módulo que faz a interpretação do algoritmo sem gerar qualquer arquivo de saída. Além do arquivo que definirá a gramática, interpreter.g, e será utilizado pelo ANTLR para geração da classe InterpreterWalker, esse módulo possui outros dois conjuntos de arquivos InterpreterEval.*, suja classe é responsável pela realização de operações sobre os dados, controle de chamadas de sub-rotinas e etc, e InterpreterDBG.*, que é o responsável pela comunicação com um cliente para efetuar a depuração interativa. 3. x86: o módulo x86 é responsável tanto pela geração do executável, quanto pela tradução do algoritmo para Assembly. Na realidade, o trabalho desse módulo é somente a tradução, e quando é necessário a criação do executável, internamente o GPT executa o NASM. Além da gramática no arquivo x86.g, e da classe gerada X86Walker gerada pelo ANTLR com base nessa gramática, esse módulo também contém outros auxiliares e que são referenciados por X86Walker, com destaque para X86.*, que dá todo o suporte para a criação do arquivo em Assembly, eliminando muito código que de outra maneira estaria em X86Walker. 4.3. GRAMÁTICA DAS NOVAS INSTRUÇÕES DE G-PORTUGOL A definição da gramática para as novas instruções de G-Portugol foi feitalevando-se em consideração os princípios de simplicidade e uniformidade queguiaram a concepção da linguagem. A gramática atual da linguagem é apresentadano Anexo D. A seguir, apresentamos as propostas de alteração nessa gramática paraque G-Portugol tenha suporte para as novas instruções. 4.3.1. Instruções de controle As novas instruções de controle em G-Portugol são a repetição com testelógico no fim e a escolha múltipla, citadas no capítulo 3. A Figura 22 apresenta agramática para essas novas instruções.
  • 45. 44 stm_list : stm_attr | fcall ";" | stm_ret | stm_se | stm_enquanto | stm_para | stm_repita | stm_caso ; stm_repita : "repita" stm_list "até" expr ";" ; stm_caso: : "caso" expr (stm_seja)+ stm_senao? "fim-caso" ; stm_seja : "seja" expr "faça" (stm_list)+ ; stm_senao : "senao" (stm_list)+ ; Figura 22: Alterações na gramática de G-Portugol para controle de repetição com laço no fim e controle de decisão com múltipla escolha 4.3.2. Passagem de Parâmetros por Referência Esta é a alteração mais simples, bastando que seja adicionado o termovariável antes da declaração dos parâmetros de uma função, indicando que apassagem será por referência e não por valor. As alterações na gramática sãoapresentadas na Figura 23. fvar_decl : ("variável")? (var_decl ";")* ; Figura 23: Sintaxe da definição para parâmetros por referencia 4.3.3. Tipos de Dados Heterogêneos Os tipos de dados heterogêneos darão a G-Portugol a capacidade demanipular dados de tipos diferentes em uma única variável, facilitando a resolução demuitos problemas. As alterações na gramática são apresentadas na Figura 24.
  • 46. 45 algoritmo : declaracao_algoritmo (decl_record)+ (var_decl_block)? stm_block (func_decls)* EOF ; decl_record : "tipo" def_record ; def_record : T_IDENTIFICADOR "= registro" field_decl "fim-registro" ; field_decl : (var_decl ";")* ; Figura 24: Alterações na gramática de G-Portugol para suporte a tipos de dados heterogêneos 4.4. ADIÇÃO DE UMA NOVA INSTRUÇÃO: O CASO DO REPITA... ATÉ As modificações necessários no código-fonte do GPT para a adição de umanova instrução em G-Portugol são mostradas usando, como estudo de caso, ocontrole de iteração com teste lógico no fim, que possuirá a sintaxe exibida na Figura25: repita <instruções que serão executadas pelo menos uma vez> até <condição>; Figura 25: Sintaxe nova instrução repita no G-Portugol 4.4.1. Extensão do Analisador Sintático As primeiras alterações foram feitas no analisador sintático, que é comum aostrês modos de operação do GPT. Esse momento foi composto das seguintes etapas: 1. Definição dos termos léxicos (tokens): no arquivo modules/parser/lexer.g estão definidos os termos léxicos da nova instrução, que no caso é repita e até. Esse termos são definidos na seção
  • 47. 46 tokens, que tem início na linha 57. Seguindo o padrão já adotado, adicionamos na linha 84 T_KW_REPITA="repita"; Como o até já é um termo léxico da linguagem, utilizado na instrução para, não será necessário defini-lo novamente.2. Definição do parser: no arquivo modules/parser/parser.g definimos a gramática da linguagem. Na linha 338 vemos a definição da lista de instruções suportada pela linguagem, então adicionamos nossa nova instrução nessa lista, como mostra a Figura 26. Figura 26: Inclusão da instrução repita no analisador sintático Em que: stm_repita: é a regra ANTLR que definirá como a árvore AST será gerada; {tk=lastToken;}: significa que após a gramática ser consumida, o token referenciado será o último; T_SEMICOL!: T_SEMICOL é o ponto-e-vírgula obrigatório após a expressão do até, e o ! significa que esse token não gerará um nó na árvore AST. A definição da regra stm_repita, foi feita a partir da linha 574, conforme podemos parcialmente ver na Figura 27 e por completo no Apêndice A. Figura 27: Regra ANTLR no analisador semântico para a instrução repita3. Definição da analise semântica: a gramática do analisado semântico é definida no arquivo modules/parser/semantic.g, algumas definições feitas no arquivo parser.g serão repetidas aqui, mas com ligeiras diferenças, sendo mais simples, pois nessa etapa muitos elementos foram eliminados. Vejamos na linha 177 a lista de instruções da linguagem, onde adicionamos a nova instrução, como mostra a Figura 28.
  • 48. 47 Figura 28: Inclusão da instrução repita no analisador semântico Como o ponto-e-virgula foi desprezado na fase anterior, ele não consta aqui. E na linha 250 definimos a regra stm_repita, conforme Figura 29. Figura 29: Trecho do arquivo modules/parser/semantic.g com a definição da regra stm_repita 4. Definição da classe BasePortugolParser: conforme falamos anteriormente a classe BasePortugolParser, definida nos arquivos modules/parser/BasePortugolParser.*, serve de base para a classe PortugolParser, gerada pelo ANTLR, e possui algumas funcionalidades. Nela estão definidas algumas mensagens que são exibidas para o usuário quando necessário e também alguns tratamentos de palavras-chaves. Como o método bool isKeyword(int tk)identifica se um token é uma palavra-chave, foi adicionado o reconhecimento para o TK_REPITA, e também a mensagem que será exibida para o usuário quando houver a falta do comando até para finalizar a instrução repita, conforme Figura 30. Figura 30: Mensagem que será exibida se o comando repita estiver com erro de sintaxe 4.4.2. Extensão do Módulo x86 O módulo x86 é o responsável por gerar o programa executável do algoritmo.Os arquivos modules/x86/X86.* definem a classe X86, e outras, que proveemserviços auxiliares para a geração do código Assembly. Esses arquivos nãonecessitam de alterações. Portanto, apenas o arquivo de definição da gramática,modules/x86/x86.g, que é usado pelo ANTLR para criação automática do geradorde código foi modificado. Na linha 162 está a definição da lista de instruções da
  • 49. 48linguagem, onde foi adicionada a regra para a nova instrução, como mostra a Figura31. Figura 31: Inclusão da instrução repita no módulo x86 A definição dessa regra foi feita na linha 461, conforme Figura 32. Conforme épossível notar, foi usada a classe X86 e criado o código Assembly equivalente aocódigo G-Portugol. Figura 32: Definição do stm_repita no módulo x86 4.4.3. Extensão do Módulo Tradutor para C Este é o módulo mais simples. Possui somente um arquivo, omodules/c_translator/pt2c.g. Semelhante ao módulo x86, a linha 635 contéma definição da lista de instruções do G-Portugol, a qual adicionada a referência ao
  • 50. 49repita. Posteriormente definida a partir na linha 786, conforme mostrado na Figura33. Figura 33: Definição do stm_repita no módulo c_translator Conforme é possível notar, a instrução repita do G-Portugol é traduzidapara a instrução do da linguagem C, sendo que a condição de parada é negada (como ! em C), já que o while de C, tem valor semântico diferente do até de G-Portugol.No repita o laço é executado enquanto a expressão avaliada no até for falsa, já nodo a repetição acontece caso a expressão seja verdadeira. 4.4.4. Extensão do Módulo Interpretador Após a adição da regra do repita na lista de instruções, que está na linha179 do arquivo modules/interpreter/interpreter.g, a regra foi definida apartir da linha 311, como mostra a Figura 34. Os demais arquivos deste módulo não precisaram ser alterados, pois sãoutilizados como suporte para o interpretador e são responsáveis pela depuraçãointerativa.
  • 51. 50 Figura 34: Definição do stm_repita no módulo interpreter 4.5. SUPORTE PARA RETORNE NO BLOCO PRINCIPAL Na gramática da linguagem definida por (SILVA, 2006), podemos ver que éprevista a instrução retorne dentro do bloco principal, semelhante ao que acontececom C e Java. No entanto, ele não é descrito no manual da linguagem. Quando um algoritmocomo o da Figura 35 é executada, uma mensagem informando o erro é apresentada,como mostra a Figura 36. algoritmo test_retorne; início retorne 42; fim Figura 35: Algoritmo com comando retorne no bloco principal Figura 36: Execução de um algoritmo sem suporte ao retorne no bloco principal Portanto, o compilador estava em desacordo com a gramática definida. Entãoteríamos duas possibilidades:
  • 52. 51 1. corrigir a gramática; 2. implementar o suporte para essa instrução. Em conversa na lista de discussão dos desenvolvedores do G-Portugol foidecidido pela segunda opção26. A instrução seria implementada e o valor retornadoseria passado para o sistema operacional, que no caso do GNU/Linux pode serrecuperado como mostrado na Figura 37: Figura 37: Execução de um algoritmo com suporte ao retorne no bloco principal As modificações necessárias para essa implementação foram enviadas para orepositório Subversion através das revisões 529, 531, 532, que podem seracessadas através das URLs http://urele.com/vge, http://urele.com/ktw ehttp://urele.com/g48, respectivamente. Assim como todas as contribuições para oprojeto G-Portugol realizadas durante este trabalho podem ser conferidas peloendereço http://urele.com/g25, cuja conteúdo é exibido no Apêndice A.26 Discusão disponível em https://lists.berlios.de/pipermail/gpt-devel/2009-February/000006.html
  • 53. 52 5. CONCLUSÕES FINAIS 5.1. RESULTADOS Durante este trabalho identificou-se softwares para o auxílio ao ensino dealgoritmos em sistemas GNU/Linux: AlgoMais, Quila e G-Portugol. Após uma análisecomparativas entres eles, o G-Portugol foi caracterizado como sendo o maisadequado. No entanto, algumas deficiências foram apresentadas, sobretudo aausência de algumas instruções comumente utilizadas em disciplinas de introdução aprogramação. Este trabalho propôs a extensão da gramática de G-Portugol com novasinstruções, de forma que seja possível uma disciplina inteiramente com essaferramenta. Dessa forma, os alunos poderão verificar se sua proposta de soluçãopara os problemas apresentados está correta, sem depender da presença de umprofessor para fazer essa avaliação, e não sendo necessário a transcrição dosalgoritmos para uma linguagem de programação, onde o professor e aluno deverãoestar atentos a detalhes de implementação da linguagem. Alunos e professorespoderão, então, concentrar-se tão somente no objetivo da disciplina, que é odesenvolvimento do raciocínio lógico para a resolução de problemas, contribuindopara um processo de ensino-aprendizado mais acelerado. Depois de feita a extensão da gramática, implementamos no compilador ainstrução repita/até. Também implementamos o suporte para o comandoretorne no bloco principal, que já estava previsto na gramática, mas nãoimplementado no compilador da linguagem, além da correção de alguns bugs. Essa implementação foi feita diretamente no repositório de código-fonte do G-Portugol, resultando em contribuições práticas para um software livre. Usando orepita/até como exemplo, todo o processo de implementação foi documentado,facilitando que novos trabalhos sejam desenvolvidos e novas contribuições sejamfeitas para o G-Portugol.
  • 54. 53 5.2. SUGESTÕES PARA TRABALHOS FUTUROS Como sugestão para trabalhos futuros, algumas possibilidades sãodestacadas: 1. A implementação dos recursos que foram identificados como ausentes, mas não implementados nesse trabalho: ◦ Controle de decisão com múltipla escolha; ◦ Tipo de dado heterogêneo; ◦ Passagem de parâmetros por referência; 2. Implementação de acesso a recursos do sistema, como abrir um arquivo. Essa característica tem sido constantemente solicitada pelo usuários através da lista de discussão da linguagem; 3. Desenvolvimento de uma ferramenta gráfica de conversão de um algoritmo em diagrama e vice-versa, visto que os diagramas são muito utilizados em cursos introdutórios de programação; 4. Suporte para programação orientada a objetos.
  • 55. 54 REFERÊNCIASAHO, Alfred V.; SETHI, Ravi; ULLMAN, Jeffrey D. Compiladores: Princípios,Técnicas e Ferramentas. Local: Porto Alegre. LTC – Livros Técnicos e CientíficosEditora S.A., 1995.ARAÚJO, Adorilson Bezerra de. Ferramentas de auxílio ao ensino de algoritmos emGNU/Linux. Trabalho apresentado no Encope 2006.BACKUS, John W. The FORTRAN automatic coding system. University of CaliforniaRadiation Laboratory, 1957.BREIJS, Cies. MAHFOUG, Anne-Maria. O Manual do KTurtle. 2004. Disponível emhttp://docs.kde.org/stable/pt_BR/kdeedu/kturtle. Acesso em 09 de dezembro de2009.BROOKSHEAR, J. Glenn. Ciência da Computação: uma visão abrangente. 7ºEdição. Bookman, 1999.BROWNSTON, Lee. Programming expert system in OPS5: an introduction to rule-based programming. Reimpressão. Addison-Wesley, 1985CLOCKSIN, Willian F. MELLISH, Christopher S. Programamming in Prolog. 5ªEdição. Springer, 2003.COSTA, Rogerio Luis de Carvalho. SQL – Guia Prático. 2ª Edição. Brasport, 1999.DIJKSTRA, Edsger W. Notes on strutured programming. Local: Eindhoven, 1970.GOSLING, James. JOY, Bill. The Java language specification. 3ª Edição. Addison-Wesley, 2005.GUIMARÃES, Angelo de Moura; LAGES Newton Alberto de Castilho. Algoritmos eestruturas de dados. Local: Rio de Janeiro. Livros Técnicos e Científicos, 1994.HYDE, Randall. The Art of Assembly Language. No Starch Press, 2003.
  • 56. 55IDC – Press Release. Open Source Software Market Accelerated by Economy andIncreased Acceptance From Enterprise Buyers, IDC Finds. 2009. Disponível emhttp://www.idc.com/getdoc.jsp?containerId=prUS21947509. Acesso em 09 de agostode 2009.JARGAS, Aurélio Marinho. Expressões Regulares – Uma abordagem divertida.Novatec, 2006.JENSEN, Kathlenn. WIRTH, Nicklaus. MICKEL, Andrew B. MINER, James F. Pascaluser manual and report: ISO Pascal standard. Springer, 1991.KERNIGHAN, Brian W. C Programming Language. 2ª Edição. Prentice Hall, 2005.LOUDEN, Kenneth C. Compiladores – Príncipios e Práticas. Thomson Pioneira,2004.MANZANO, José Augusto N. G. Fundamentos em Programação Assembly: paracomputadores IBM-PC a partir de microprocessadores Intel 8086/8088. Local: SãoPaulo. Érica. 2004.MANZANO, José Augusto N. G.; OLIVEIRA, J. F. Algoritmos: Lógica para odesenvolvimento de programação. Local: São Paulo. Érica. 2001. --PINHEIRO, Marden Cicarelli. Uma experiência no Ensino de Lógica deProgramação para Cursos de Engenharia Usando o Pascal e o Logo. 2003.PRICE, Ana Maria de Alencar; TOSCANI, Simão Sirineo. Implementação delinguagens de programação: compiladores. 2º Edição. Local: Porto Alegre. SagraLuzzato, 2001.ROSSUM, Guido Van. DRAKE, Fred L. An introduction to Python: release 2.2.2.Network Theory Ltd, 2003.ROY, M. K. GHOSH, Debabrata. Cobol Programming. Tata McGraw-Hill, 1989.SEBESTA, Robert W. Conceitos de linguagens de programação; trad. José CarlosBarbosa dos Santos. 5. ed. Local: Porto Alegre. Bookman, 2003.
  • 57. 56SILVA, Thiago. G-Portugol: Manual da versão 1.0. 2006. Disponível emhttp://gpt.berlios.de/manual_big/manual.html. Acesso em 14 de julho de 2009.SILVEIRA, Sérgio Amadeu da. Software livre: a luta pela liberdade doconhecimento. Local: São Paulo. Fundação Perseu Abramo, 2004.WEXELBLAT, Richard L. History of Programming Languages. Local: Los Angeles.Academic Press, 1981.Wiki do projeto G-Portugol. http://gpt.berlios.de/wikki/index.php/Developing1x.Acesso em 09 de agosto de 2009.WIRTH, Niklaus. Compiler Constructions. Local: Zurich, 2005.
  • 58. 57APENDICE A – PÁGINA MOSTRANDO TODAS AS CONTRIBUIÇÕES FEITAS PARA O PROJETO G-PORTUGOL DURANTE ESTE TRABALHO Disponível em: http://urele.com/g25
  • 59. 58ANEXO A – PARTE DA MATRIZ DO CURSO DE CIÊNCIA DA COMPUTAÇÃO DA UERN
  • 60. 59ANEXO B – MATRIZ DO CURSO DE CIÊNCIA DA COMPUTAÇÃO DA UFRN
  • 61. 60ANEXO C – MATRIZ DO CURSO TÉCNICO EM INFORMÁTICA DO IFRN
  • 62. 61ANEXO D – GRAMÁTICA DA LINGUAGEM G-PORTUGOL
  • 63. 62

×