Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente...
63
UNIVERSIDADE DO ESTADO DO RIO GRANDE DO NORTE ADORILSON BEZERRA DE ARAÚJO INVESTIGAÇÃO E EXTENSÃO DE UMA FERRAMENTA PARA AUXÍLIO AO ENSINO DE ALGORITMOS EM AMBIENTES GNU/LINUX - G-PORTUGOL NATAL 2009
-
Upload
adorilson-bezerra -
Category
Education
-
view
3.863 -
download
1
description
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.
Transcript of Investigação e extensão de uma ferramenta para auxílio ao ensino de algoritmos em ambiente...
UNIVERSIDADE DO ESTADO DO RIO GRANDE DO NORTE
ADORILSON BEZERRA DE ARAÚJO
INVESTIGAÇÃO E EXTENSÃO DE UMA FERRAMENTA PARA AUXÍLIO AO ENSINO DE ALGORITMOS EM AMBIENTES GNU/LINUX - G-PORTUGOL
NATAL2009
ADORILSON BEZERRA DE ARAÚJO
INVESTIGAÇÃ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
OrientadoraROSIERY DA SILVA MAIA
NATAL2009
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
Copyright (C) 2009 by Adorilson Bezerra de Araújo ([email protected]) 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.
Bibliotecária: Valéria Maria Lima da Silva CRB 15 / 451
ADORILSON BEZERRA DE ARAÚJO
INVESTIGAÇÃ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
Dedicado a todos que abandonaram cursos
de informática em função das dificuldades
impostas nas aulas de algoritmos e/ou
decorrentes desta.
AGRADECIMENTOS
O caminhar durante esse curso de Ciência da Computação, que encerra-se com
esta 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 minhas
escolhas 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 de
estudo e diversão.
Ao Thiago Silva, que criou o projeto G-Portugol e o distribuiu sob a forma de
software livre, sem o qual este presente trabalho não teria sido possível. E também pela
disponibilidade para esclarecimentos de dúvidas acerca do mesmo.
Aos professores do curso pela dedicação desprendida para a preparação das
aulas e orientação, mostrando os caminhos e atalhos dessa longa jornada. E em
particular aos que foram mais que professores de uma disciplina, mas que tornaram-se
exemplos a serem seguidos. Citar nomes seria injusto, mas gostaria de agradecer à
professora Rosiery Maia pela preciosa orientação durante essa monografia, e para o
professor 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 outros
que contribuíram de forma direta e indireta.
Meu muito obrigado.
Programas devem ser escritos para
pessoas lerem e, apenas incidentalmente,
máquinas executarem.
Abelson e Sussman
RESUMO
No início dos cursos de computação no Brasil é oferecida uma disciplina de introdução a
programação, em que comumente é utilizado um pseudo-código, conhecido como
portugol, para a escrita dos algoritmos. A utilização de uma linguagem de programação
dificultaria o aprendizado, já que as instruções das linguagens de programação são em
inglês, sobretudo por quem tem deficiências nesse idioma. Porém, devido a ausência de
um compilador para o portugol, esses algoritmos não são convertidos em um programa
executável, causando dúvida sobre a corretude dos mesmos e até desinteresse na
disciplina por parte dos alunos, entre outros problemas. Por outro lado, a adoção e uso
de softwares livres tem crescido por todo o mundo. Contudo, em alguns cursos, o aluno
só tem contato com esses softwares em disciplinas mais avançadas, o que pode causar
atraso no andamento, uma vez que alguns alunos tem dificuldades devido a falta de
conhecimento até mesmo dos conceitos básicos. Dessa forma, em um cenário ideal
teríamos uma ferramenta de auxílio ao ensino de algoritmos sendo largamente utilizada
sob uma plataforma livre. Na Internet, estão disponíves algumas ferrramentas com esse
propósito. Em estudos comparatívos, o projeto G-Portugol foi apontado como sendo o
mais adequado. Esse projeto especifica um dialeto de portugol e disponibiliza um
compilador 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 às
instruções suportadas. Como também é um software livre, este trabalho propõe a adição
de algumas novas instruções que estão ausentes mas são utilizadas nos cursos de
algoritmos. Além de propor as instruções, também fazemos a implementação de algumas
delas e a correção de algumas falhas no projeto.
Palavras-chaves: Algoritmos. Compiladores. Programação. G-Portugol.
ABSTRACT
At the beginning of the computing courses in Brazil is offered an discipline of
introduction to programming, which is commonly used a pseudo-code, known as
portugol, for the writing of algorithms. The use of a programming language difficult to
learn because the instructions programming languages are in English, especially by
those who have deficiencies in that language. However, due to lack of a compiler for
portugol, these algorithms are not converted into an executable program, causing
doubt about the accuracy the same and disinterest in the discipline by students,
among other problems. Moreover, the adoption and use of free software has grown
around the world. However, in some courses, the student only has contact with
these software in more advanced subjects, which can cause delay in progress, since
some 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 is
widely used on a free platform. On the Internet, some tools are available for this
purpose. In comparative studies, the project G-Portugol was identified as the most
appropriate. 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 paper
proposes the addition of some new instructions that are missing but are used in
algorithms courses. In addition to proposing the instructions, also make the
implementation of some of them and correction of some bugs in the project.
Keywords: Algorithms. Compilers. Programming. G-Portugol.
LISTA DE FIGURAS
Figura 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 com laç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 dados heterogê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 regra stm_repita....................................................................................................................47Figura 30: Mensagem que será exibida se o comando repita estiver com erro de sintaxe.........................................................................................................................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
LISTA DE TABELAS
Tabela 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
LISTA DE ABREVIATURAS E SIGLAS
ANTLR 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
SUMÁRIO
1. INTRODUÇÃO ......................................................................................................14
1.1. OBJETIVOS.........................................................................................................16
1.1.1. Objetivo Geral..................................................................................................16
1.1.2. Objetivos Específicos.....................................................................................16
1.2. ESTRUTURA DO TRABALHO............................................................................16
2. CONSTRUÇÃO DE COMPILADORES..................................................................18
2.1. UM BREVE HISTÓRICO.....................................................................................18
2.2. VISÃO GERAL DE UM COMPILADOR ..............................................................20
2.3. VISÃO DETALHADA DE UM COMPILADOR.....................................................20
2.3.1. Análise Léxica.................................................................................................20
2.3.2. Análise Sintática.............................................................................................20
2.3.3. Análise Semântica..........................................................................................21
2.3.4. Geração de Código.........................................................................................21
2.3.5. Manipulador de Erros.....................................................................................21
2.4. TRADUTORES DE LINGUAGENS DE PROGRAMAÇÃO.................................22
2.5. EXPRESSÃO REGULAR PARA A DEFINIÇÃO DA GRAMÁTICA DE UMA LINGUAGEM...............................................................................................................23
2.5.1. O metacaractere . (ponto)...............................................................................24
2.5.2. O metacaractere [] (lista)................................................................................24
2.5.3. O metacaractere ? (opcional)........................................................................24
2.5.4. O metacaractere * (asterisco)........................................................................25
2.5.5. O metacaractere + (mais)...............................................................................25
2.5.6. O metacaractere () (grupo).............................................................................25
2.5.7. O metacaractere | (ou)....................................................................................25
3. O PROJETO G-PORTUGOL..................................................................................26
3.1. FERRAMENTAS DE AUXÍLIO AO ENSINO DE ALGORITMOS EM SISTEMAS GNU/LINUX.................................................................................................................27
3.2. DEFINIÇÃO DE UMA FERRAMENTA PARA O ENSINO DE ALGORITMOS....28
3.3. DECISÕES DE PROJETO ADOTADAS PARA A LINGUAGEM........................29
3.4. CARACTERÍSTICAS GERAIS DA LINGUAGEM................................................31
3.4.1. Declaração do Algoritmo ...............................................................................31
3.4.2. Declaração de Variáveis Globais..................................................................32
3.4.3. Bloco Principal................................................................................................32
3.4.4. Declaração de Funções..................................................................................34
3.5. O PROGRAMA GPT............................................................................................35
3.6. O PROGRAMA GPTEDITOR..............................................................................36
3.7. LIMITAÇÕES DA LINGUAGEM G-PORTUGOL.................................................36
4. ESTENDENDO A LINGUAGEM G-PORTUGOL...................................................39
4.1. ORGANIZAÇÃO GERAL DO CÓDIGO-FONTE DO GPT...................................40
4.2. FUNCIONAMENTO INTERNO DO COMPILADOR GPT....................................41
4.3. GRAMÁTICA DAS NOVAS INSTRUÇÕES DE G-PORTUGOL.........................43
4.3.1. Instruções de controle....................................................................................43
4.3.2. Passagem de Parâmetros por Referência....................................................44
4.3.3. Tipos de Dados Heterogêneos......................................................................44
4.4. ADIÇÃO DE UMA NOVA INSTRUÇÃO: O CASO DO REPITA... ATÉ...............45
4.4.1. Extensão do Analisador Sintático.................................................................45
4.4.2. Extensão do Módulo x86................................................................................47
4.4.3. Extensão do Módulo Tradutor para C...........................................................48
4.4.4. Extensão do Módulo Interpretador...............................................................49
4.5. SUPORTE PARA RETORNE NO BLOCO PRINCIPAL......................................50
5. CONCLUSÕES FINAIS..........................................................................................52
5.1. RESULTADOS.....................................................................................................52
5.2. SUGESTÕES PARA TRABALHOS FUTUROS..................................................53
APENDICE A – PÁGINA MOSTRANDO TODAS AS CONTRIBUIÇÕES FEITAS PARA O PROJETO G-PORTUGOL DURANTE ESTE TRABALHO........................57
ANEXO A – PARTE DA MATRIZ DO CURSO DE CIÊNCIA DA COMPUTAÇÃO DA UERN ..........................................................................................................................58
ANEXO B – MATRIZ DO CURSO DE CIÊNCIA DA COMPUTAÇÃO DA UFRN....59
ANEXO C – MATRIZ DO CURSO TÉCNICO EM INFORMÁTICA DO IFRN...........60
ANEXO D – GRAMÁTICA DA LINGUAGEM G-PORTUGOL..................................61
14
1. INTRODUÇÃO
Geralmente no primeiro ou segundo semestre dos cursos da área de
Computação, seja de nível técnico ou superior, é oferecida uma disciplina de
construção de algoritmos ou de introdução à programação. Conforme mostram os
anexos A, B e C.
(MANZANO, 2001) destaca que normalmente são utilizadas nessas
disciplinas, para a definição dos algoritmos, uma técnica narrativa denominada
pseudocódigo, também conhecida como “português estruturado” ou ainda chamada
de “Portugol”. E ainda, que a diferença entre uma linguagem de programação e o
Portugol é que este não pode ser convertido em um programa executável no
computador. Sendo necessário que o professor leia a solução para que o aluno saiba
se sua implementação está correto. Como o professor também pode cometer
equívocos, além da possibilidade da existência de mais uma solução para um dado
problema, em alguns casos não haverá certeza absoluta de que a solução proposta
está completamente correta. O que acaba tornando desestimulante e cansativo o
estudo para a iniciação da programação.
Depois de algum tempo aprendendo algoritmos dessa forma, os alunos
passam a utilizar uma linguagem de programação. (PINHEIRO, 2003) aponta que
uma das linguagens mais utilizada em disciplinas de introdução à programação é a
linguagem Pascal, uma vez que ela é praticamente uma transcrição do Portugol.
A linguagem Pascal (JENSEN et al., 1991) foi criada pelo suíço Niklaus Wirth
no início da década de 70, e batizada com esse nome em homenagem ao
matemático Blaise Pascal (BROOKSHEAR, 1999). Um dos objetivos de Niklaus
Wirth com a criação dessa linguagem era o ensino de programação estruturada, que
preconiza que todos os programas possíveis podem ser reduzidos a apenas três
estruturas: sequência, decisão e iteração, como proposto por (DIJKSTRA, 1970).
Por ser praticamente uma transcrição do Portugol, em primeiro momento os
alunos transcrevem seus algoritmos para Pascal. Portanto, os alunos aprendem
lógica de programação, escrevem os algoritmos em uma pseudo-linguagem e
transcrevem 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
15
inserido 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 o
auxílio de um computador, forçando que o aluno torne-se versado em uma linguagem
em particular. Considerando que essa disciplina é o alicerce para toda vida
acadêmica e profissional dos estudantes de computação, esse panorama torna-se
bastante preocupante.
Por outro lado, a adoção e uso de softwares livres, que são caraterizados
pelas liberdades de uso, cópia, modificações e redistribuição (SILVEIRA, 2004), tem
crescido em todo mundo, sendo o Brasil um dos maiores utilizadores e
desenvolvedores desses softwares. Segundo (IDC, 2009), o mercado de software
livre mundial deverá ter um crescimento de 22,4% ao ano até 2013. Contudo, nos
cursos de Computação, os alunos só terão contado com esses softwares em
disciplinas mais avançadas, causando atraso no andamento normal das aulas, uma
vez que alguns alunos têm dificuldades devido à falta de conhecimento até mesmo
dos conceitos básicos inerentes a esses softwares.
Em um cenário ideal, seria conveniente uma ferramenta de auxílio ao ensino
de programação largamente utilizada sob uma plataforma livre, em particular um
sistema GNU/Linux. Um dos softwares que poderia ser essa ferramenta é o KTurtle1,
um ambiente de programação educativo que usa a linguagem de programação
Logo2, e tenta manter a programação tão acessível quanto possível, tornando-se
adequado para ensinar às crianças disciplinas como matemática, geometria e
programação (BREIJS, 2004).
Outras ferramentas também se propõem a suprir essa necessidade.
(ARAÚJO, 2006) conclui que o projeto G-Portugol3 é o projeto com maior potencial
para ser utilizado em cursos de computação no ensino de algoritmos sob ambientes
GNU/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ácil
instalação e simples utilização, a ausência de alguns recursos impede que disciplinas
introdutórias de algoritmos sejam inteiramente ofertadas com esta ferramenta. Com
1 Disponível em http://edu.kdeedu.org/kturtle e também nos repositórios da maioria das distribuições GNU/Linux
2 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
16
isso, este trabalho determina pontos ainda limitadores do G-Portugol e demonstra a
implementação de uma extensão.
1.1. OBJETIVOS
1.1.1. Objetivo Geral
O objetivo geral deste trabalho é estender a linguagem G-Portugol e suas
ferramentas correlatas, em particular o compilador GPT4, de forma que possa ser
completamente utilizada em cursos de computação, em disciplinas introdutórias de
programaçã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: no
primeiro 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.
17
O segundo capítulo apresenta uma breve revisão acerca da teoria de
compiladores.
A linguagem G-Portugol e suas ferramentas correlatas são apresentadas no
terceiro capítulo.
O capítulo seguinte, informa a extensão da linguagem G-Portugol, e propõe as
novas instruções, com implementação de algumas delas no compilador.
E por fim, o capítulo cinco apresenta os resultados obtidos, conclusão e
indicações para trabalhos futuros.
18
2. CONSTRUÇÃO DE COMPILADORES
2.1. UM BREVE HISTÓRICO
Para (PRICE, 2001), “o meio mais eficaz de comunicação entre pessoas é a
linguagem (língua ou idioma)”. A mesma autora ainda afirma que para a
comunicaçã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 o
processamento da máquina.
Quando o primeiro computador eletrônico, chamado de Eletronic Numerical
Integrator and Computer (ENIAC), foi criado, na década de 40, a linguagem utilizada
para 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 a
serem efetivamente executadas”, aceitando somente informações expressas em
notação de código binário, mas que podiam ser representados em notação
hexadecimal (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 da
dé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 muito
mais fáceis de lembrar que seu código equivalente em binário ou mesmo
hexadecimal (MANZANO, 2004). Essas linguagens são a segunda geração das
linguagens de programação.
Ainda na década de 50, surgiram as linguagens de programação de terceira
geração. Fortran (BACKUS, 1957) é considerada por muitos, embora alguns
discordem5, como a primeira linguagem compilada largamente aceita e utilizada. No
entanto, a linguagem foi projetada para a comunidade científica, e ainda era
específica para a máquina em que seria executada (SEBESTA, 2003). A primeira em
que pode ser compilada para múltiplas arquiteturas foi a COBOL6 (ROY, 1989), em
1960.
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.
19
(PRICE, 2001) alerta para o fato de que as linguagens de terceira geração
foram projetadas para profissionais da área de processamentos de dados e não para
usuários finais e, ainda, que a “depuração de programas escritos nessas linguagens
consome tempo, e a modificação de sistemas complexos é relativamente difícil”. Em
resposta 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 linguagens
de terceira geração, que são ditas linguagens de propósito geral. Para atingir esses
objetivos, as linguagens dessa geração utilizam mecanismos não presentes nas
linguagens da geração anterior, como preenchimento de formulários, interação via
ví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 do
BrOffice.org7. Uma linguagem dessa geração bastante popular é o SQL (Structured
Query Language), que fornece um padrão para a manipulação e consulta de banco
de dados, sendo hoje em dia muito usada em conjunto com as linguagens de terceira
geração (COSTA, 1999).
Depois, surgiram as linguagens de quinta geração, que são usadas
principalmente na área de Inteligência Artificial, facilitando a representação do
conhecimento essencial para a simulação de comportamentos inteligentes (PRICE,
2001). Prolog8 (CLOCKSIN, 2003), OPS59 (BROWNSTON, 1985) e Mercury10 são
linguagens 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 6011 (WIRTH, 2005), que foram
fundamentadas 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.
20
2.2. VISÃO GERAL DE UM COMPILADOR
Para (WIRTH, 2005), compilador é um programa que traduz um programa
escrito em uma linguagem de programação em instruções que serão executadas por
um computador, o que pode ser graficamente representado pela Figura 1.
(PRICE, 2001) afirma que os compiladores “aceitam (como entrada) uma
representação textual de um problema expresso em uma linguagem fonte, e
produzem uma representação do mesmo algoritmo expresso em uma outra
linguagem, 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, as
quais 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 chamados
de tokens, que constituem a linguagem. O analisador léxico despreza comentários e
brancos desnecessários.
Durante a análise léxica, é feita o preenchimento da tabela de símbolos. Essa
estrutura de dados conterá um registro para cada token, com os campos contendo os
atributos 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 pelo
analisador léxico pode ser gerada pela gramática da linguagem-fonte (AHO, 1995).
Figura 1: Esquema de um compiladorFonte: Adaptado de PRICE, 2001
Programa objetoCompiladorPrograma fonte
21
2.3.3. Análise Semântica
Após a confirmação da análise sintática que todas as cadeias de tokens foram
corretamente gerada pela gramática da linguagem-fonte, é necessário verificar se
esses elementos estão corretamente combinados. A análise semântica é
responsável por fazer essa verificação. (AHO, 1995) aponta que um importante
componente 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 na
linguagem-objeto. O resultado dessa fase é quase sempre código em linguagem de
montagem, como o Assembly.
2.3.5. Manipulador de Erros
Durante as fases de análise o compilador poderá encontrar erros no
programa-fonte. Se o compilador tiver a capacidade de identificar esse erro e a linha
em que ele ocorreu, além de recuperar-se do erro, e continuar o processo de
compilação será de grande utilidade para quem escreveu o programa.
Figura 2: Visão detalhada de um tradutorFonte: Adaptado de (PRICE, 2001) e (AHO, 1995)
22
2.4. TRADUTORES DE LINGUAGENS DE PROGRAMAÇÃO
Existem alguns tipos de ferramentas com funções semelhantes aos
compiladores, no sentido de converter programas de uma linguagem para outra, no
entanto 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 tanto
implementações compiladas como interpretadas para uma linguagem”. Dessa forma
o 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 ser
compilados para aumentar sua velocidade de execução. As implementações
23
interpretadas serão particularmente úteis em laboratórios para ensino de
programação.
Além dos tradutores, existem outros diversos programas relacionados a
compiladores, tais como carregadores, montadores, editores entre outros. Uma
rá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 de
expressõ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ção
de identificadores válidos em G-Portugol, que devem começar com uma letra ou o
caractere “_” e serem seguidos de letras, números ou novamente o caractere “_”, em
qualquer quantidade e ordem. A Figura 3 apresenta a expressão regular que define
esse padrão.
Os caracteres [, ] e * são chamados de metacaracteres, símbolos com funções
especiais, e que associados aos símbolos normais formam as expressões regulares.
(JARGAS, 2006) é uma obra completa sobre expressões regulares. A Tabela
1 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)
[a-zA-Z_][a-zA-Z0-9_]*
Figura 3: Expressão regular que define um identificador válido em G-Portugol
24
2.5.1. O metacaractere . (ponto)
O metacaractere . é um curinga que substitui qualquer outro caractere, sendo
que é 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 os
caracteres 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 caracteres
aceitos foram reduzidos graças a possibilidade do uso de intervalos, através do
caractere -, 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 American
Standard 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á permitido
uma ocorrência. No caso de G-Portugol, teremos o bloco de declaração de variáveis
12 Disponível em http://www.tabelaascii.com/. Acesso em 08 de setembro de 2009.
25
como opcional, representado por (var_decl_block), portanto a expressão regular
terá a forma apresentada na Figura 4.
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 de
funçõ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 na
definição do inteiros decimais em G-Portugol, apresentado na Figura 5.
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úmeros
binários em G-Portugol, que podem ter um “b” ou um “B”, conforme Figura 6.
2.5.7. O metacaractere | (ou)
O metacaractere | significa “ou”, permitindo a ocorrência de uma coisa ou
outra, como na regra para a definição de números inteiros em G-Portugol,
apresentada na Figura 7.
[0-9]+
Figura 5: Expressão regular que define números inteiros decimais em G-Portugol
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
algoritmo
: declaracao_algoritmo (var_decl_block)? stm_block
(func_decls)* EOF
;
Figura 4: Exemplo de uso do metacaractere ? na gramática de G-Portugol
'0' ('b'|'B') [01]+
Figura 6: Expressão regular que define os números inteiros em G-Portugol
26
3. O PROJETO G-PORTUGOL
Em 1953, Grace Hopper sugeriu que “(...) programas de processamentos de
dados deveriam ser escritos em inglês” (WEXELBLAT, 1981 citado por SEBESTA,
2003). Para conseguir o financiamento para o desenvolvimento desse projeto, que
seria a principal progenitora do COBOL, foi necessária a implementação de um
protótipo, que envolveu compilar e executar um pequeno programa, inicialmente
usando palavras-chaves em inglês, depois palavras-chaves francesas e por fim com
palavras-chaves alemãs. Hoje em dia, as linguagens mais comuns possuem essa
característica de utilizar a língua inglesa como referência, facilitando o aprendizado
para quem dominar o idioma inglês.
Geralmente para ensinos introdutórios de programação de computadores e de
concepção de algoritmos, usa-se uma linguagem/pseudo-código conhecido como
Portugol 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 algoritmo
escrito em Portugol é fundamental para o alcance do objetivo de uma disciplina de
algoritmos e introdução a programação ser alcançado, que é possibilitar ao aluno
desenvolver o raciocínio lógico necessário para a resolução de problema com o
auxílio de um computador, e não que ele seja versado em uma linguagem em
particular. Quando lança-se mão de uma linguagem para essas disciplinas, os
estudantes e professores acabam por atendo-se mais com o estudo dessa
linguagem, fugindo do objetivo da disciplina (SILVA, 2006). Além disso, raramente os
livros fornecem ferramentas para converter o algoritmo escrito em Portugol em um
programa executável. Dessa forma, os aprendizes não podem executar os
programas 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 algum
projeto que disponibilize um compilador, e provavelmente o dialeto implementado
será diferente do livro-texto.
27
O projeto mais conhecido e utilizado para o ensino de algoritmos que faça uso
de palavras-chaves em português é o VisuAlg13. Porém ele só está disponível para
sistemas Windows e, por não ser software livre, não é possível que ele seja adaptado
para 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ílio
ao ensino de algoritmos foram identificados e analisados três projetos que poderiam
suprir 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-Portugol18 é 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 C19
(KERNIGHAN, 2005) e Assembly, e interpretação dos algoritmos. A outra
13 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.
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 de
algoritmos em sistema GNU/Linux, levando-se em consideração a provável
inexperiência dos alunos com esse sistema e até mesmo com computação de forma
geral, foi feita uma comparação entre esses três projetos, que é apresentado na
Tabela 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;
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 desenvolvido
C++ Java C++
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 indicado
como mais promissor para ser utilizado em cursos de algoritmos sob ambiente
GNU/Linux. Outra boa vantagem desse projeto era o fato de também ser possível a
sua execução em ambiente Windows, pois embora não fosse uma característica
fundamental, ter uma ferramenta multiplataforma é sempre desejável. Além disso, o
procedimento de instalação está facilitado, uma vez que não existem mais as falhas
de incompatibilidade de codificação de caracteres citadas por (ARAÚJO, 2006) e
estão disponibilizado os pacotes de instalação no repositório da distribuição Debian20
GNU/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-Portugol
sejam detalhados, é importante conhecermos quais foram os parâmetros que
influenciaram nas decisões de projeto.
20 Disponível em: http://debian.org/. Acesso em 22 de agosto de 2009.
30
O ponto fundamental que guiou as diretrizes da linguagem é seu propósito
educacional. Ela deveria expressar o raciocínio lógico para a solução dos problemas
de forma que um aluno iniciante os compreenda sem ater-se a detalhes da
linguagem, estimulando a capacidade de abstração do estudante.
Também é interessante que a linguagem mantenha compatibilidade com os
dialetos de Portugol apresentadas pela literatura, como o utilizado por (MANZANO,
2001). Portanto, embora o desenvolvimento da linguagem fosse direcionado por
algumas diretrizes, em alguns momentos elas foram sacrificadas em prol dessa
compatibilidade. 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
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.
• 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 Python21 (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 ou
apresenta novidades em relação ao uso popular de portugol”. É uma linguagem
imperativa, com comandos de controle de fluxo, manipulação de dados e recursos
básicos de entrada e saída. Além disso é uma linguagem case-sensitive, ou seja, ela
faz distinção entre letras maiúsculas e minúsculas. Uma função “leia” é diferente de
uma 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 do
algoritmo será utilizado para o arquivo gerado pelo processo de compilação, caso
21 Disponível em: http://python.org/. Acesso em 22 de agosto de 2009.
variáveis
idade: inteiro;
fim-variáveis
Figura 8: Exemplo de declaração de variáveis em G-Portugol
32
não seja informado outro nome. No projeto do compilador, ele poderia ter sido
omitido, no entanto foi mantido por questões de compatibilidade com a literatura.
A declaração do algoritmo possui a sintaxe apresentada na Figura 9.
3.4.2. Declaração de Variáveis Globais
Essa seção é opcional. É semanticamente similar ao Pascal, que define um
bloco 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.
Entre a abertura e o fechamento do bloco podem ser declaradas diversas
variáveis, de acordo com os tipos suportados, explicitados na Tabela 6. Com esses
tipos é 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 algoritmo
começ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 chamadas
para 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.
algoritmo <nome do algoritmo>;
Figura 9: Sintaxe da declaração de algoritmos em G-Portugol
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
33
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.
• 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.
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
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
enquanto <teste lógico> faça
<comandos a serem executados>
fim-enquanto
Figura 12: Sintaxe da instrução enquanto em G-Portugol
início
<comandos>
fim
Figura 11: Sintaxe da declaração do bloco principal em G-Portugol
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.
Embora não possua todas as estruturas comumente apresentadas na
literatura, com as instruções oferecidas pelo G-Portugol é possível resolver qualquer
tipo de problema.
3.4.4. Declaração de Funções
Enquanto (GUIMARÃES, 1994) utiliza o conceito de procedimentos e funções
para sub-programas, o G-Portugol disponibiliza funções com ou sem retorno. As
definições de funções deverão ser feitas após o bloco principal, contrastando com
Pascal, que exige a declaração das funções antes de sua chamada. O retorno das
funções é feito através da instrução retorne, e o valor de retorno deve ser
compatível com o tipo da função.
A declaração das variáveis locais é feita entre a assinatura da função e a
palavra 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 de
parâmetros da função também não segue estritamente o formato de declaração de
variáveis. Veja a sintaxe da declaração de funções na Figura 15.
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
35
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 NASM22 (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.
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
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 de
editores de arquivo (abrir, fechar, salvar), ele possui o recurso de destaque de
sintaxe, evidenciando para o usuário as palavras-chaves da linguagem, facilitando o
aprendizado e fixação dos termos de G-Portugol, conforme mostra a Figura 16.
No que diz respeito a depuração dos algoritmos, é possível adicionar pontos
de parada, ou seja, quando o algoritmo está em execução e chega em uma linha
marcada 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 o
restante 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 disponibilizando
todas as instruções e recursos costumeiramente utilizados em cursos introdutórios de
programação. Fazendo um comparativo com (MANZANO, 2001), estão ausentes em
G-Portugol os seguintes elementos:
Figura 16: GPTEditor: o editor da linguagem G-PortugolFonte: http://gpt.berlios.de/demos/gpteditor/debug/debug.html
37
1. Controle de repetição com teste lógico no fim, que possui a estrutura mostrada
na Figura 17.
2. 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.
3. 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.
4. 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.
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 fim
tipo <identificador> = registro
<campo1>: <tipo do campo1>;
<campo2>: <tipo do campo2>;
...
fim-registro
Figura 19: Sintaxe da definição de tipos de dados heterogêneo
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 escolha
38
A ausência desses recursos impede o uso de G-Portugol e o seu compilador
GPT durante todo um curso de algoritmos com programação estruturada. Além
desses 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.
39
4. ESTENDENDO A LINGUAGEM G-PORTUGOL
Para que a linguagem G-Portugol possa ser inteiramente utilizada e bem
sucedida em disciplinas de construção de algoritmos, é necessário que ela venha a
dar 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 v223 (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 Subversion24.
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.
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 do
GPT. 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();
Os dois primeiros métodos exibem, respectivamente, uma ajuda e a versão do
compilador no terminal. Os outros métodos são os responsáveis por fazer a
25 Usaremos arquivo.* para representar o arquivo cabeçalho C++ (.hpp) e sua implementação (.cpp)
Figura 20: Organização geral do código-fonte do GPT
41
compilação, a tradução para a linguagem C e a interpretação de um programa escrito
em G-Portugol, que será a entrada para o GPT.
Esses métodos usarão as classes e funções definidas nos subdiretórios
abaixo 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 que
abstraem os símbolos da linguagem, a tabela de símbolos e a árvore sintática
abstrata, respectivamente.
4.2. FUNCIONAMENTO INTERNO DO COMPILADOR GPT
Para qualquer operação relevante do GPT (compilar, traduzir, interpretar), o
arquivo fonte em G-Portugol deverá passar, pelo menos, pela análise léxica, sintática
e 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 tem
BasePortugolParser como classe base, que oferece algumas funcionalidades.
O resultado da análise sintática, efetuada pelo PortugolParser em conjunto
com o PortugolLexer, será uma árvore abstrata ou nulo, dependendo da ocorrência
de erros na análise. A árvore é gerada segundo as regras de geração de nós na
gramática definida no arquivo parser/parser.g e os nós são objetos da classe
PortugolAST. Essa interação é representada na Figura 21.
42
A AST (Abstract syntax tree) será utilizada, em seguida, como entrada para a
análise semântica, realizada pela classe SemanticWalker em conjunto com a classe
SemanticEval. Examinando os arquivos parser/SemanticWalker.* e
parser/SemanticEval.* veremos que os primeiros foram gerados
automaticamente pelo ANTLR, de acordo com as regras definidas em
parser/semantic.g. Sempre que essa fase for bem sucedida, o resultado será a
mesma árvore, porém, com dados semânticos preenchidos no nós, como o tipo de
dado, por exemplo. Essa árvore anotada é resultado da etapa de análise e a entrada
da 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ódulos
apresentados na seção anterior: c_translator, interpreter e x86. Eles recebem como
entrada 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 gerado
automaticamente pelo ANTLR com base na gramática definida no arquivo com a
extensão .g, presente em cada módulo. Esses módulos possuem a seguinte
composiçã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
Figura 21: Representação da geração da árvore de análise sintáticaFonte: Wiki do Projeto G-Portugol
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 feita
levando-se em consideração os princípios de simplicidade e uniformidade que
guiaram a concepção da linguagem. A gramática atual da linguagem é apresentada
no Anexo D. A seguir, apresentamos as propostas de alteração nessa gramática para
que 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 teste
lógico no fim e a escolha múltipla, citadas no capítulo 3. A Figura 22 apresenta a
gramática para essas novas instruções.
44
4.3.2. Passagem de Parâmetros por Referência
Esta é a alteração mais simples, bastando que seja adicionado o termo
variável antes da declaração dos parâmetros de uma função, indicando que a
passagem será por referência e não por valor. As alterações na gramática são
apresentadas na Figura 23.
4.3.3. Tipos de Dados Heterogêneos
Os tipos de dados heterogêneos darão a G-Portugol a capacidade de
manipular dados de tipos diferentes em uma única variável, facilitando a resolução de
muitos problemas. As alterações na gramática são apresentadas na Figura 24.
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
fvar_decl : ("variável")? (var_decl ";")* ;
Figura 23: Sintaxe da definição para parâmetros por referencia
45
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 uma
nova instrução em G-Portugol são mostradas usando, como estudo de caso, o
controle de iteração com teste lógico no fim, que possuirá a sintaxe exibida na Figura
25:
4.4.1. Extensão do Analisador Sintático
As primeiras alterações foram feitas no analisador sintático, que é comum aos
trê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
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
repita<instruções que serão executadas
pelo menos uma vez>até <condição>;
Figura 25: Sintaxe nova instrução repita no G-Portugol
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.
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.
3. 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.
Figura 27: Regra ANTLR no analisador semântico para a instrução repita
Figura 26: Inclusão da instrução repita no analisador sintático
47
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.
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.
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 proveem
serviços auxiliares para a geração do código Assembly. Esses arquivos não
necessitam 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 gerador
de código foi modificado. Na linha 162 está a definição da lista de instruções da
Figura 29: Trecho do arquivo modules/parser/semantic.g com a definição da regra stm_repita
Figura 30: Mensagem que será exibida se o comando repita estiver com erro de sintaxe
Figura 28: Inclusão da instrução repita no analisador semântico
48
linguagem, onde foi adicionada a regra para a nova instrução, como mostra a Figura
31.
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 ao
código G-Portugol.
4.4.3. Extensão do Módulo Tradutor para C
Este é o módulo mais simples. Possui somente um arquivo, o
modules/c_translator/pt2c.g. Semelhante ao módulo x86, a linha 635 contém
a definição da lista de instruções do G-Portugol, a qual adicionada a referência ao
Figura 32: Definição do stm_repita no módulo x86
Figura 31: Inclusão da instrução repita no módulo x86
49
repita. Posteriormente definida a partir na linha 786, conforme mostrado na Figura
33.
Conforme é possível notar, a instrução repita do G-Portugol é traduzida
para a instrução do da linguagem C, sendo que a condição de parada é negada (com
o ! 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á no
do 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 linha
179 do arquivo modules/interpreter/interpreter.g, a regra foi definida a
partir da linha 311, como mostra a Figura 34.
Os demais arquivos deste módulo não precisaram ser alterados, pois são
utilizados como suporte para o interpretador e são responsáveis pela depuração
interativa.
Figura 33: Definição do stm_repita no módulo c_translator
50
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 acontece
com C e Java.
No entanto, ele não é descrito no manual da linguagem. Quando um algoritmo
como o da Figura 35 é executada, uma mensagem informando o erro é apresentada,
como mostra a Figura 36.
Portanto, o compilador estava em desacordo com a gramática definida. Então
teríamos duas possibilidades:
algoritmo test_retorne;
inícioretorne 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
Figura 34: Definição do stm_repita no módulo interpreter
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 foi
decidido pela segunda opção26. A instrução seria implementada e o valor retornado
seria passado para o sistema operacional, que no caso do GNU/Linux pode ser
recuperado como mostrado na Figura 37:
As modificações necessárias para essa implementação foram enviadas para o
repositório Subversion através das revisões 529, 531, 532, que podem ser
acessadas através das URLs http://urele.com/vge, http://urele.com/ktw e
http://urele.com/g48, respectivamente. Assim como todas as contribuições para o
projeto G-Portugol realizadas durante este trabalho podem ser conferidas pelo
endereç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
Figura 37: Execução de um algoritmo com suporte ao retorne no bloco principal
52
5. CONCLUSÕES FINAIS
5.1. RESULTADOS
Durante este trabalho identificou-se softwares para o auxílio ao ensino de
algoritmos em sistemas GNU/Linux: AlgoMais, Quila e G-Portugol. Após uma análise
comparativas entres eles, o G-Portugol foi caracterizado como sendo o mais
adequado. No entanto, algumas deficiências foram apresentadas, sobretudo a
ausência de algumas instruções comumente utilizadas em disciplinas de introdução a
programação.
Este trabalho propôs a extensão da gramática de G-Portugol com novas
instruções, de forma que seja possível uma disciplina inteiramente com essa
ferramenta. Dessa forma, os alunos poderão verificar se sua proposta de solução
para os problemas apresentados está correta, sem depender da presença de um
professor para fazer essa avaliação, e não sendo necessário a transcrição dos
algoritmos para uma linguagem de programação, onde o professor e aluno deverão
estar atentos a detalhes de implementação da linguagem. Alunos e professores
poderão, então, concentrar-se tão somente no objetivo da disciplina, que é o
desenvolvimento do raciocínio lógico para a resolução de problemas, contribuindo
para um processo de ensino-aprendizado mais acelerado.
Depois de feita a extensão da gramática, implementamos no compilador a
instrução repita/até. Também implementamos o suporte para o comando
retorne no bloco principal, que já estava previsto na gramática, mas não
implementado 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 o
repita/até como exemplo, todo o processo de implementação foi documentado,
facilitando que novos trabalhos sejam desenvolvidos e novas contribuições sejam
feitas para o G-Portugol.
53
5.2. SUGESTÕES PARA TRABALHOS FUTUROS
Como sugestão para trabalhos futuros, algumas possibilidades são
destacadas:
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.
54
REFERÊNCIAS
AHO, Alfred V.; SETHI, Ravi; ULLMAN, Jeffrey D. Compiladores: Princípios, Técnicas e Ferramentas. Local: Porto Alegre. LTC – Livros Técnicos e Científicos Editora S.A., 1995.
ARAÚJO, Adorilson Bezerra de. Ferramentas de auxílio ao ensino de algoritmos em GNU/Linux. Trabalho apresentado no Encope 2006.
BACKUS, John W. The FORTRAN automatic coding system. University of California Radiation Laboratory, 1957.
BREIJS, Cies. MAHFOUG, Anne-Maria. O Manual do KTurtle. 2004. Disponível em http://docs.kde.org/stable/pt_BR/kdeedu/kturtle. Acesso em 09 de dezembro de 2009.
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, 1985
CLOCKSIN, 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 e estruturas de dados. Local: Rio de Janeiro. Livros Técnicos e Científicos, 1994.
HYDE, Randall. The Art of Assembly Language. No Starch Press, 2003.
55
IDC – Press Release. Open Source Software Market Accelerated by Economy and Increased Acceptance From Enterprise Buyers, IDC Finds. 2009. Disponível em http://www.idc.com/getdoc.jsp?containerId=prUS21947509. Acesso em 09 de agosto de 2009.
JARGAS, Aurélio Marinho. Expressões Regulares – Uma abordagem divertida. Novatec, 2006.
JENSEN, Kathlenn. WIRTH, Nicklaus. MICKEL, Andrew B. MINER, James F. Pascal user 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: para computadores IBM-PC a partir de microprocessadores Intel 8086/8088. Local: São Paulo. Érica. 2004.
MANZANO, José Augusto N. G.; OLIVEIRA, J. F. Algoritmos: Lógica para o desenvolvimento de programação. Local: São Paulo. Érica. 2001. --
PINHEIRO, Marden Cicarelli. Uma experiência no Ensino de Lógica de Programação para Cursos de Engenharia Usando o Pascal e o Logo. 2003.
PRICE, Ana Maria de Alencar; TOSCANI, Simão Sirineo. Implementação de linguagens de programação: compiladores. 2º Edição. Local: Porto Alegre. Sagra Luzzato, 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é Carlos Barbosa dos Santos. 5. ed. Local: Porto Alegre. Bookman, 2003.
56
SILVA, Thiago. G-Portugol: Manual da versão 1.0. 2006. Disponível em http://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 do conhecimento. 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.
57
APENDICE A – PÁGINA MOSTRANDO TODAS AS CONTRIBUIÇÕES FEITAS PARA O PROJETO G-PORTUGOL DURANTE ESTE TRABALHO
Disponível em: http://urele.com/g25
58
ANEXO A – PARTE DA MATRIZ DO CURSO DE CIÊNCIA DA COMPUTAÇÃO DA UERN
59
ANEXO B – MATRIZ DO CURSO DE CIÊNCIA DA COMPUTAÇÃO DA UFRN
60
ANEXO C – MATRIZ DO CURSO TÉCNICO EM INFORMÁTICA DO IFRN
61
ANEXO D – GRAMÁTICA DA LINGUAGEM G-PORTUGOL
62
