jportugol: uma ferramenta de auxÍlio À … · tema compilador. ideia que surgiu no ... conhecer,...

ANDRÉIA CRISTINA DOS SANTOS GUSMÃO

JPORTUGOL: UMA FERRAMENTA DE AUXÍLIO À APRENDIZAGEM DE ALGORITMOS

UNIVERSIDADE DO VALE DO SAPUCAÍ POUSO ALEGRE

2010



Trabalho de Conclusão de Curso apresentado ao Departamento de Sistemas de Informação da Faculdade de Filosofia, Ciências e Letras “Eugênio Pacelli” da Universidade do Vale do Sapucaí, como requisito parcial para obtenção do título de Bacharel em Sistemas de Informação. Orientador: Artur Luís Ribas Barbosa

UNIVERSIDADE DO VALE DO SAPUCAÍ POUSO ALEGRE

2010



Trabalho de conclusão de curso defendido e aprovado em __/___/_____ pela banca

examinadora constituída pelos professores:

________________________________ Professor Artur Luís Ribas Barbosa Orientador ________________________________ Professora Crishna Irion Examinadora ________________________________ Professor Ednardo David Segura Examinador

A meus pais, Cida e Juraci, razões da minha vida, força e luz para enfrentar todas as crueldades humanas. Amo vocês demais!

AGRADECIMENTOS

A Deus, por guiar sempre a minha vida e permitir, pela intercessão de Santa Catarina de

Alexandria, padroeira dos estudantes, que eu concluísse com sucesso essa jornada,

mesmo quando faltava ânimo para os estudos.

A meus pais, Cida e Juraci, motivo maior da minha existência, pelo apoio e amor

constantes. Com toda simplicidade, sempre lutaram pela família e para que mesmo nos

piores momentos da minha vida, eu tivesse força para continuar estudando. Sem vocês,

hoje não estaria aqui, obrigada por tudo, amores da minha vida.

A minha irmã, Micheli, por fazer parte da minha vida e pelos elogios que me deram

coragem para ir além.

Ao Prof. Artur Luís Ribas Barbosa, orientador deste projeto, pela competência, por ter

acreditado em mim e por todo o conhecimento transmitido nesses anos todos. Obrigada

pela atenção. Um exemplo de profissionalismo não compreendido por muitos que só

queriam brincar.

Ao Prof. Márcio Emílio, por todo o aprendizado proporcionado que foram de grande

importância neste projeto. As aulas de Java e Engenharia de Software nunca serão

esquecidas.

Às Professoras Priscila P. Ferraz e Crishna Irion, pelos primeiros contatos com o mundo

dos algoritmos, importantíssimos para a concretização deste projeto e para o meu

crescimento profissional.

Ao Prof. Fábio Augusto, mesmo sem saber, é totalmente responsável pela escolha do

tema Compilador. Ideia que surgiu no 5º período de SI quando no laboratório de Redes,

o professor falou da possibilidade de desenvolver na UNIVÁS um compilador para a

linguagem C. Daí nasceu o interesse pelo tema.

Em especial à Professora de TCC, Joelma Faria, por todo o embasamento metodológico.

A todos os professores, colegas, que me acompanharam desde o início, e que também

proporcionaram uma troca de conhecimento e experiências, em especial ao Marco

Antônio, amigo de todas as horas e ao Adair, que chegou quase no final do curso, mas

que juntos construímos uma amizade que vai durar a vida inteira.

Não podendo deixar de citar uma pessoa que teve uma importância muita grande no

início deste projeto, Luiz Fernando Noschang, aluno do curso de Ciências da

Computação da Universidade do Vale do Itajaí, em Santa Catarina, que mesmo sem me

conhecer, me ensinou os primeiros passos para construir um compilador através da

ferramenta ANTLR. Suas palavras de incentivo através de e-mails foram determinantes

para seguir em frente.

Um agradecimento todo especial ao Marcos Roberto da Silva, que me deu força,

coragem, entendeu minhas ausências e cuidou para que cada imagem utilizada nos

botões do interpretador desenvolvido fosse criada conforme minha vontade. Esse

destino desumano não permitiu que você estivesse aqui comigo hoje, mas com certeza

você faz parte da minha história. Eterna gratidão e saudades.

Ao amigo virtual Pedro Satorelli, presente em muitos momentos difíceis, onde as

palavras de carinho e incentivos, mesmo que de longe, deram ânimo para seguir em

frente.

Aos colegas de trabalho da Eleven Tecnologia, INPETTECC e Colégio Objetivo, em

especial à Isabela Gubiotti, Elton de Souza, Luciene Silva, Tatiane Nunes, Jeane

Barbosa, Sílvia e Marilene. Obrigada pela paciência e compreensão, por terem confiado

na minha capacidade e me dado uma oportunidade de conhecimento e experiência que

nunca será esquecida.

A todas as pessoas que não citei, mas que de uma forma ou de outra fizeram parte da

minha vida, me apoiaram quando precisei. O caminho não foi fácil, muitas vezes pensei

em desistir, muito obrigada. Essa conquista é nossa.

“Provamos através da lógica, mas descobrimos a partir da intuição.”

Jules Henri Poincaré

GUSMÃO, Andréia C. dos Santos. JPortugol: uma ferramenta de auxílio à aprendizagem de algoritmos. 2010. Trabalho de Conclusão de Curso – Curso de Bacharelado em Sistemas de Informação, Faculdade de Filosofia, Ciências e Letras Eugênio Pacelli, Universidade do Vale do Sapucaí, Pouso Alegre, 2010.

RESUMO

O aprendizado de algoritmos é fundamental para a evolução do aluno na disciplina de Laboratório de Programação. A falta de ambientes onde se possa testar e simular os algoritmos faz com que ele não tenha uma ideia clara da importância dessa disciplina, pois os conceitos ficam abstratos. Com o intuito de auxiliar na aprendizagem de lógica de programação, este projeto tem por objetivo relatar o desenvolvimento de um interpretador que produzirá efeitos de execução, através de códigos em português estruturado, digitados pelo usuário. Foi utilizada a pesquisa aplicada, pois o desenvolvimento dessa ferramenta busca melhorar um processo de aprendizagem. Tem como público alvo, alunos da área de informática que estejam iniciando seus estudos na disciplina de algoritmos e desejam aprender, de forma mais prática, esses conhecimentos, os quais estão diretamente ligados ao sucesso do desenvolvimento de software. Foi desenvolvido na linguagem Java através do ambiente de programação Eclipse e utilizou-se o ANTLRWorks para criação da análise léxica e sintática do interpretador. Espera-se que o aluno possa se sentir mais motivado para aprender lógica de algoritmos, pois poderá visualizar o resultado dos seus códigos sem a necessidade de uma linguagem de programação, através de um ambiente que permitirá experimentar, simular, investigar possibilidades, errar e conhecer os limites do algoritmo. A disciplina de algoritmos é de vital importância na área de desenvolvimento e seu aprendizado não pode ter dúvidas, pois é com a lógica bem desenvolvida que construímos os algoritmos para solucionar problemas e melhorar processos. Através do interpretador, uma nova proposta de testes foi criada, podendo influenciar na aprendizagem de forma mais prática e dinâmica.

Palavras-chave: Aprendizagem de algoritmos. Compilador. Interpretador.

GUSMÃO, Andréia C. dos Santos. JPortugol: a tool for the learning algorithms. 2010. Trabalho de Conclusão de Curso – Curso de Bacharelado em Sistemas de Informação, Faculdade de Filosofia, Ciências e Letras Eugênio Pacelli, Universidade do Vale do Sapucaí, Pouso Alegre, 2010.

ABSTRACT

The learning algorithm is crucial for the development of the student in the discipline of Programming Lab. The lack of areas where we can test and simulate the algorithms makes it does not have a clear idea of the importance of this discipline, because the concepts are abstract. In order to assist in learning logic programming, this project aims to report the development of an interpreter that effect implementation through codes in Portuguese structured, typed by the user. Applied research was used, because the development of this tool aims to improve a learning process. Its target audience, students of computer science who are starting their studies in the discipline of algorithms and want to learn, more practice, this knowledge, which are directly linked to the success of software development. It was developed in Java using the Eclipse programming environment and used the ANTLRWorks for creating the lexical and syntactic analysis of the interpreter. It is expected that the student can feel more motivated to learn logic algorithms, as you can see the result of their codes without the need for a programming language, through an enabling environment to experiment, simulate, investigate options, make mistakes and learn the limits of the algorithm. The discipline of algorithms is of vital importance in development and their learning can’t have doubts, because the logic is well developed that build the algorithms to solve problems and improve processes. Through the interpreter, a proposed new test was created and may influence learning the most practical and dynamic.

Key-words: Learning algorithms. Compiler. Interpreter.

LISTA DE FIGURAS

Figura 1 – Fases do algoritmo ................................................................................................. 23 Figura 2 – Um compilador ...................................................................................................... 27 Figura 3 – Interpretação de código ......................................................................................... 28 Figura 4 – Fases de um compilador ........................................................................................ 29 Figura 5 – Apresentação do diagrama da sintaxe de IDENTIFICADOR ............................... 32 Figura 6 – Representação de uma AST ................................................................................... 35 Figura 7 – Representação da árvore sintática para a expressão b>2 ...................................... 36 Figura 8 – Editor ANTLRWorks ............................................................................................ 40 Figura 9 – Criando um arquivo de gramática no ANTLRWorks ........................................... 41 Figura 10 – Menu arquivo ....................................................................................................... 44 Figura 11 – Estrutura do arquivo padrão alg........................................................................... 44 Figura 12 – Tela abrir arquivo JPortugol ................................................................................ 45 Figura 13 – Barra de título atualizada ..................................................................................... 45 Figura 14 – Menu editar .......................................................................................................... 46 Figura 15 - Opções do menu pop-up ....................................................................................... 47 Figura 16 – Tela localizar linha .............................................................................................. 48 Figura 17 – Tipo de arquivo a ser criado ................................................................................ 53 Figura 18 – Tela ANTLRWorks com as regras definidas ...................................................... 55 Figura 19 – Tela de entrada de código para testes .................................................................. 56 Figura 20 – Tela execução de testes........................................................................................ 57 Figura 21 – AST do teste ........................................................................................................ 57 Figura 22 – Representação da árvore sintática do teste .......................................................... 58 Figura 23 – Menu gerar código léxico e sintático no ANTLRWorks ..................................... 58 Figura 24 – Tela com as classes geradas pelo ANTLRWorks ................................................ 59 Figura 25 – Diagrama de caso de uso das funções do interpretador ....................................... 60 Figura 26 – Menu algoritmo ................................................................................................... 61 Figura 27 – Tela de informação verificar código .................................................................... 62 Figura 28 – Tela criar arquivo padrão ..................................................................................... 62 Figura 29 – Tela verificação do código .................................................................................. 63 Figura 30 – Mensagem código verificado com sucesso ......................................................... 63 Figura 31 – Tela verificação do código com erro léxico ........................................................ 64 Figura 32 – Tela verificação do código com erro sintático..................................................... 66 Figura 33 – Opção Executar algoritmo ................................................................................... 69 Figura 34 – Tela algoritmo executado com erros semânticos ................................................. 70 Figura 35 – Tela Entrada de dados.......................................................................................... 71 Figura 36 – Tela console leitura executada com sucesso........................................................ 71 Figura 37 – Tela console leitura abortada ............................................................................... 71 Figura 38 – Tela código com erros semânticos 1ª fase ........................................................... 72 Figura 39 – Tela código com erros semânticos 2ª fase ........................................................... 74 Figura 40 – Tela console erro semântico em tempo de execução ........................................... 75 Figura 41 – Tela console execução semântica com sucesso ................................................... 75 Figura 42 – Opção Executar passo a passo o algoritmo ......................................................... 77 Figura 43 – Tela de execução passo a passo ........................................................................... 78 Figura 44 – Tela alteração na área de memória na execução passo a passo ........................... 79

Figura 45 – Tela de erro semântico na execução passo a passo ............................................. 80 Figura 46 – Tela opção parar execução .................................................................................. 80 Figura 47 – Tela opções iniciais do algoritmo ........................................................................ 81 Figura 48 – Tela execução do AL do cálculo fatorial ............................................................. 83 Figura 49 – Tela execução do AS do cálculo fatorial ............................................................. 85 Figura 50 – Tela execução do ASem do cálculo fatorial com erros ....................................... 88 Figura 51 – Tela execução do ASem do cálculo fatorial sem erros ........................................ 90 Figura 52 – Tela de interação com o usuário .......................................................................... 90 Figura 53 – Tela console erro tipo de dado inválido............................................................... 91 Figura 54 – Tela console erro divisão por zero ....................................................................... 91 Figura 55 – Tela execução final cálculo fatorial ..................................................................... 92 Figura 56 – Tela aba alerta ...................................................................................................... 93

LISTA DE QUADROS

Quadro 1 – Algoritmo média .................................................................................................. 24 Quadro 2 – Símbolos léxicos .................................................................................................. 31 Quadro 3 – Exemplo regra léxica para IDENTIFICADOR ................................................... 31 Quadro 4 – Trecho de código válido sintaticamente .............................................................. 33 Quadro 5 – Regra sintática comando de seleção “se/entao” .................................................. 33 Quadro 6 – Exemplo de reescrita de AST .............................................................................. 40 Quadro 7 – Código chamado ao clicar na ação desfazer ........................................................ 46 Quadro 8 – Trecho da classe responsável pelo método desfazer ............................................ 47 Quadro 9 – Código copiar, colar, recortar e selecionar tudo .................................................. 48 Quadro 10 – Exemplos de comentários .................................................................................. 50 Quadro 11 – Sintaxe do comando de seleção “se/entao” ....................................................... 52 Quadro 12 – Sintaxe das estruturas de repetição .................................................................... 52 Quadro 13 – Código verificar algoritmo ................................................................................ 68

LISTA DE TABELAS

Tabela 1 – Exemplos de tokens ............................................................................................... 30 Tabela 2 – Regras ANTLR ..................................................................................................... 41 Tabela 3 – Tipos de dados ....................................................................................................... 49 Tabela 4 – Operadores aritméticos .......................................................................................... 51 Tabela 5 – Operadores relacionais .......................................................................................... 51 Tabela 6 – Operadores lógicos ................................................................................................ 51 Tabela 7 – Funções disponíveis .............................................................................................. 53 Tabela 8 – Erros semânticos.................................................................................................... 76

LISTA DE ABREVIATURAS E SIGLAS

AL Analisador Léxico AMBAP Ambiente de Aprendizado de Programação ANTLR ANother Tool for Language Recognition AS Analisador Sintático ASem Analisador Semântico AST Abstract Syntax Tree BNF Forma de Backus-Naurs CSBC Congresso da Sociedade Brasileira de Computação EBNF Forma Estendida de Backus-Naurs GLC Gramática Livre de Contexto INATEL Instituto Nacional de Telecomunicações PDL Program Design Language SI Sistemas de Informação UFAL Universidade Federal de Alagoas UFMA Universidade Federal do Maranhão UML Unified Modeling Language UNIVÁS Universidade do Vale do Sapucaí XML Extensible Markup Language WEI Workshop sobre Educação em Computação

SUMÁRIO

1 INTRODUÇÃO ................................................................................................................... 15 2 ENSINO DE ALGORITMOS ............................................................................................. 22

2.1 A lógica de algoritmos para solucionar problemas ...................................................... 22

2.2 A aprendizagem de algoritmos ..................................................................................... 24 3 PRINCÍPIOS DE COMPILAÇÃO ..................................................................................... 27

3.1 Compiladores e interpretadores .................................................................................... 27 3.2 Análise léxica ............................................................................................................... 29 3.3 Análise sintática ........................................................................................................... 32

3.3.1 Árvore sintática ....................................................................................................... 35 3.4 Análise semântica ......................................................................................................... 36

4 FERRAMENTAS GERADORAS DE ANALISADORES ................................................ 38

4.1 ANTLR e seu ambiente de desenvolvimento ANTLRWorks ...................................... 38

5 METODOLOGIA DO DESENVOLVIMENTO ................................................................ 43

5.1 Funções básicas de editor de texto ............................................................................... 43 5.2 Criação do arquivo de gramática .................................................................................. 49 5.3 Funções do algoritmo ................................................................................................... 60

5.3.1 Verificando o algoritmo .......................................................................................... 61 5.3.2 Executando o algoritmo .......................................................................................... 69 5.3.3 Executando o algoritmo passo a passo .................................................................... 77 5.3.4 Parando a execução do algoritmo ........................................................................... 80

6 DISCUSSÃO DOS RESULTADOS ................................................................................... 82

6.1 Desenvolvimento do analisador léxico ........................................................................ 82 6.2 Desenvolvimento do analisador sintático ..................................................................... 84 6.3 Desenvolvimento do analisador semântico .................................................................. 87 6.4 Desenvolvimento do interpretador ............................................................................... 91

7 CONCLUSÃO ..................................................................................................................... 94 8 REFERÊNCIAS .................................................................................................................. 95

APÊNDICES ........................................................................................................................

ANEXOS .............................................................................................................................

1 INTRODUÇÃO

Este projeto tem como objetivo geral desenvolver uma ferramenta que auxilie no

processo de aprendizagem de algoritmos de forma mais didática, permitindo interpretar

um código escrito em português estruturado, verificando sua estrutura de acordo com a

linguagem definida e mostrando o resultado após a entrada e processamento dos dados,

sem necessidade de geração de um executável.

Para alcançar esse objetivo é preciso que alguns itens específicos sejam

concretizados, como: a) desenvolver um analisador léxico que reconheça, a partir da

gramática1 definida, todas as palavras que fazem parte da linguagem e que também

identifique as que não fazem através de mensagem de erro; b) desenvolver um

analisador sintático cuja característica é identificar se a seqüência do algoritmo digitado

equivale a um programa válido de acordo com as especificações da gramática e, c)

desenvolver um analisador semântico que permita executar o programa e verificar se

existem incoerências, como por exemplo: variáveis usadas que não foram declaradas,

variáveis declaradas mais de uma vez, tipos de operando incompatíveis com operadores

etc.

As linguagens de programação auxiliam a criação de softwares com a finalidade

de facilitar os processos e as atividades do dia-a-dia. Os cursos voltados à área de

informática ensinam essas tecnologias para a prática de desenvolvimento de sistemas.

Aprender a programar requer disciplina, dedicação, força de vontade e muito

estudo. Só com uma lógica de programação bem desenvolvida é que o aluno consegue

resolver problemas e compreender as funcionalidades dos comandos utilizados para

criar o software propriamente dito. Lógica é uma coerência de ideias, uma sequência de

ações a ser executada em determinada ordem para alcançar um objetivo. É através da

lógica que se constroem algoritmos que são transformados em programas de

computadores para solucionar vários tipos de problemas ou melhorar processos.

1 Arquivo que contém todos os símbolos válidos e as regras para validar a linguagem utilizada, aqui será o Portugol, que será explicado posteriormente.

16

Segundo Farrer et al (1999, p. 15), “geralmente, um algoritmo se destina a

resolver um problema: fixa um padrão de comportamento a ser seguido, uma norma de

execução a ser trilhada, para se atingir, como resultado final, a solução de um

problema”. Para a resolução desse tipo de problema utiliza-se um procedimento de

desenvolvimento, conhecido também como algoritmo.

Algoritmo é a união de comandos que quando executados em ordem e

corretamente, geram um resultado. Fazemos, a todo instante, esses procedimentos

mesmo sem saber, como por exemplo, as receitas de culinária, o manual de um aparelho

eletrônico e, até mesmo, o simples fato de chupar uma bala.

Manzano (2007, p. 6) define algoritmo como

(...) um processo de cálculo matemático ou de resolução de um grupo de problemas semelhantes estipulados com generalidade e sem restrições. Pode se dizer que são regras formais para obtenção de um resultado ou da solução de um problema, englobando fórmulas de expressões aritméticas.

O aprendizado de algoritmos é fator crítico de sucesso na área computacional.

Uma vez que esse estudo não é bem compreendido, pode influenciar o rendimento em

outras disciplinas que dependem diretamente desses conhecimentos, como por exemplo,

Laboratório de Programação.

Neste projeto o algoritmo será tratado como pseudocódigo, que é uma forma de

representá-lo em português estruturado, um portugol2, adaptado à linguagem para

melhor facilitar o entendimento.

Para que seja possível testar o algoritmo de forma prática, como se fosse uma

linguagem de programação, pode-se desenvolver um ambiente interpretador, que segue

os conceitos de um compilador, com particularidades específicas para cada linguagem

definida.

Para Price (2001, p. 4), compiladores “são tradutores que mapeiam programas

escritos em linguagem de alto nível para programas equivalentes em linguagem

simbólica ou linguagem de máquina”.

Já o interpretador difere do compilador no sentido de que não gera um

executável do programa. Toda vez que se desejar executá-lo é necessário compilar

novamente, pois a interpretação do código fonte ocorre durante essa compilação. Aceita

como entrada um código e produz o “efeito de execução”, sem transformá-lo em

linguagem de máquina (Price, 2001).

2 A linguagem portugol utilizada para a construção deste projeto será explicada nas seções 2.1 e 5.2.

17

Diante da complexidade do estudo de algoritmos e da importância de um

software que permite testá-los, várias ferramentas já foram desenvolvidas.

O WebPortugol3 tem como objetivo auxiliar a aprendizagem de algoritmos em

português estruturado através da web. Esta ferramenta permite executar os códigos

passo a passo e as mensagens de erros são todas em português com exemplos para

melhor demonstrar os resultados, além de permitir ao professor disponibilizar arquivos

em formato Extensible Markup Language (XML) com questões de algoritmos (Hostins,

2006).

Numa outra linha, mas seguindo o mesmo propósito de auxiliar disciplinas

introdutórias de lógica de programação, pode ser citado o UFMA-CP4 v.3.1,

desenvolvido por alunos da Universidade Federal do Maranhão (UFMA). Um grande

diferencial é a tradução para C++ e pode, ainda, gerar o código executável utilizando

um compilador, por exemplo, o gcc (Neto, 2008).

Outra ferramenta bastante conhecida é o projeto da Universidade Federal de

Alagoas (UFAL), denominado Ambiente de Aprendizado de Programação (AMBAP5),

que tem como principal objetivo desenvolver um ambiente para facilitar o aprendizado

de lógica de programação, que permita minimizar o esforço do estudante em aplicar

corretamente os conceitos e técnicas de programação, através de um processo de

simulação (Deitos, 2003).

Todos os softwares citados foram desenvolvidos na linguagem Java e precisam

da máquina virtual6 para funcionar.

Este projeto se propõe a desenvolver uma ferramenta que atue como um

interpretador de algoritmos em pseudocódigo, isto é, o código fonte será compilado,

mas sem a geração do código objeto. Nesta direção terá como base as ferramentas já

existentes, personalizando-as para melhor compreensão dos resultados e para auxiliar na

construção de programas computacionais.

O ensino de algoritmos para ingressantes que ainda não tiveram iniciação na

área de programação deve ser analisado cuidadosamente, pois a falta de estímulo nessa

disciplina pode comprometer todo o curso.

3 Acesso on-line da ferramenta pelo site http://siaiacad17.univali.br/webportugol/ 4 Download da ferramenta disponível no site http://www.gia.deinf.ufma.br/cp/ 5 Download da ferramenta disponível no site http://www.ufal.br/tci/ambap/ 6 JRE, software necessário para funcionar sistemas em Java. Download no site http://java.com/pt_BR/download/

18

Na maioria das vezes, para ser testado, o algoritmo é convertido em uma

linguagem de programação, o que gera conflitos para o iniciante. Outra alternativa é o

famoso Teste de Mesa7, mas que uma vez não executado corretamente ou não alterando

um valor de uma variável, por exemplo, põe em risco o sucesso do resultado esperado.

Quando não se entende bem a importância de algoritmos e não se tem uma forma de

testá-lo, fica mais difícil compreender a disciplina.

Diante do exposto, este projeto tem a finalidade de possibilitar ao aluno uma

alternativa de testes, o que permitirá executar seu código como se fosse uma linguagem

de programação, ao invés de toda vez que fizer um algoritmo e quiser saber se está

correto, tiver que converter em outra linguagem para testá-lo.

Com o interpretador espera-se que o aluno possa entender melhor a lógica de

desenvolvimento através do português estruturado para facilitar a compreensão das

linguagens utilizadas nas disciplinas de laboratório de programação, e não utilizar essas

disciplinas para aprender e testar o algoritmo, o que ocorre normalmente.

Através deste projeto, a disciplina de algoritmos terá um atrativo a mais para a

prática de exercícios, pois eles poderão ser executados. Será algo real e não ficará só no

papel, como o teste de mesa, pois uma vez que se consegue visualizar o resultado da

própria lógica, fica mais fácil aprender a programar.

A ferramenta pode ser executada em qualquer computador, não dependendo de

acesso à internet, o que contribui para que mais pessoas, e em mais lugares, possam

utilizá-la como uma opção de aprendizagem, necessitando apenas, ter Java instalado.

É um projeto relevante, visto a importância da disciplina de lógica para os cursos

na área de informática, que não tem o intuito de mudar a prática do professor com o

ensino de algoritmos, mas de auxiliá-los com as possibilidades de testes e execução, o

que mostrará um resultado de mais fácil compreensão para quem está iniciando.

O tipo de pesquisa utilizado foi a pesquisa aplicada, a qual é assim definida por

Ander-Egg (apud Marconi, 2009, p. 6): “pesquisa aplicada, como o próprio nome

indica, caracteriza-se por seu interesse prático, isto é, que os resultados sejam aplicados

ou utilizados, imediatamente, na solução de problemas que ocorrem na realidade”.

O projeto se utilizou desse tipo de pesquisa, pois foi desenvolvida uma

ferramenta que pode ser utilizada em vários lugares com a finalidade de auxiliar um

processo de aprendizagem. Tem como público alvo, alunos da área de informática, seja

7 Simulação passo a passo das instruções do algoritmo usando apenas papel e caneta.

19

de cursos universitários ou técnicos, que estejam iniciando seus estudos na disciplina de

algoritmos e desejam aprender, de forma mais prática, esses conhecimentos, os quais

estão diretamente ligados ao sucesso do desenvolvimento de software.

Os estudantes precisam de um ambiente onde possam testar, simular,

compreender os erros e aprender a desenvolver a lógica de um modo genérico, sem se

fixar em uma linguagem de programação.

Os participantes desse projeto foram a acadêmica Andréia Cristina dos Santos

Gusmão, que trabalha há 06 anos em uma empresa de desenvolvimento de software,

utilizando a linguagem Delphi e os bancos de dados SQL Server e Firebird, e o

professor orientador Artur Luís Ribas Barbosa.

As funções da acadêmica relacionaram-se à pesquisa das teorias utilizadas,

estudo de ferramentas já existentes, análise das gramáticas de algoritmos, definição de

uma linguagem em português estruturado compatível com os conceitos de algoritmos

defendidos pelos autores pesquisados para compor a base teórica. Após toda essa

análise, foi desenvolvida a ferramenta interpretadora.

O professor Artur, que ministra atualmente as disciplinas de Banco de Dados I e

Tópicos Avançados na Universidade do Vale do Sapucaí (UNIVÁS), no curso de

Sistemas de Informação (SI), foi escolhido para ser o orientador desse projeto e teve

como papel nesta pesquisa, orientar a acadêmica na construção e análise de todo o

projeto.

O desenvolvimento desse projeto foi dividido em fases. A primeira mostra as

tecnologias utilizadas; a segunda, como se constituiu a base teórica; a terceira, o estudo

das ferramentas existentes; a quarta, a definição da gramática a ser utilizada; na quinta

fase deu-se início a construção da ferramenta, e, na última fase, são os testes, com a

ferramenta já concluída.

A primeira fase foi a escolha das tecnologias utilizadas. Este projeto foi

desenvolvido com a linguagem Java, por ser Open Source e por ter sido a mais vista

durante o curso de SI na UNIVÁS. O ambiente de programação é o Eclipse, que é um

projeto que permite aos usuários um software para auxiliar os desenvolvedores a

realizar o desenvolvimento de seus produtos.

Para auxiliar na criação do arquivo que contém a especificação das regras de

algoritmos foi utilizada a ferramenta ANother Tool for Language Recognition (ANTLR)

20

em conjunto com o software ANTLRWorks8, que permite gerar classes para o

reconhecimento léxico e sintático do interpretador.

Para a documentação dos diagramas do interpretador foi usada a linguagem de

modelagem Unified Modeling Language (UML), através da ferramenta Jude, que pode

ser baixada gratuitamente.

A fase seguinte foi o estudo das informações que constituem a base teórica desse

projeto, as quais foram coletadas em livros específicos de compiladores e algoritmos,

como também na Internet, artigos e monografias.

A terceira e quarta fases ocorreram em paralelo. As ferramentas existentes

encontradas disponíveis para download foram testadas para poder ter uma base melhor

de como é a teoria aplicada à prática. A partir desses testes, foi definido um arquivo de

gramática que contém todas as regras básicas utilizadas pela ferramenta. Esse arquivo

foi criado com o auxílio do ANTLRWorks e depois incluídas as classes geradas no

projeto do Eclipse.

Com os conceitos bem definidos e especificado o que conterá nesse

interpretador, deu-se início a quinta fase, que foi a construção do projeto. Primeiro foi

desenvolvido o analisador léxico, que reconhece os tokens9 do algoritmo digitado pelo

usuário; depois o analisador sintático, que verifica se os tokens estão seguindo a regra

sintática definida. E por fim, o analisador semântico, responsável por identificar os erros

semânticos que não são verificados na fase anterior.

A ferramenta possui uma interface muito próxima a um editor de textos, com a

possibilidade de salvar o código do algoritmo, abrir um código já existente, as

operações de editar o texto como selecionar tudo, copiar, colar e recortar. Além dessas

funcionalidades extras, as que compõem os objetivos específicos são: verificar o código,

executar o código, executar passo a passo e parar a execução.

Por fim, a sexta fase mostra a seqüência de testes com a ferramenta já concluída.

Em toda a construção da ferramenta foi avaliado seus requisitos específicos, mas é aqui

que os testes serão mais intensos e de uma forma mais ampla.

Com a conclusão positiva dessas etapas fundamentais da produção de dados, o

objetivo geral desse projeto foi alcançado, respeitando as regras estabelecidas e a

proposta defendida.

8 Será detalhado seu funcionamento na seção 4.1. 9 Símbolos terminais em uma gramática, que podem ser palavras-chave, operadores, identificadores, constantes ou literais. Será mais detalhado na seção 3.2.

21

Após o capítulo introdutório, esse projeto foi organizado em 05 capítulos.

O capítulo 2 apresenta a base teórica sobre o ensino algoritmos, como é usada a

lógica para solucionar problemas, a linguagem portugol e as dificuldades na

aprendizagem de lógica de programação.

No capítulo 3 está descrita a diferença entre compilador e interpretador e as fases

necessárias para a construção da ferramenta interpretadora.

O capítulo 4 aborda as ferramentas utilizadas para a construção da análise léxica

e sintática.

O capítulo 5 discute o detalhamento de como a ferramenta foi desenvolvida, toda

a implementação dos casos de uso e uma explicação das telas do sistema.

No capítulo 6, os objetivos iniciais são retornados para a discussão dos

resultados.

E por fim, o capítulo 7 conclui este projeto.

22

2 ENSINO DE ALGORITMOS

Neste capítulo são apresentados os conceitos de lógica, problema e algoritmos.

Será mostrado também o portugol utilizado para escrever códigos algorítmicos. Para

finalizar, as dificuldades encontradas no ensino e aprendizagem da disciplina de

algoritmos é uma proposta que visa solucionar esses problemas.

Os conceitos estão embasados nas teorias dos autores: Miranda (2004), Pessoa

(2004), Rodrigues Jr. (2004) e Manzano (2007) e pelos Anais do Congresso da

Sociedade Brasileira de Computação (CSBC) – Workshop sobre Educação em

Computação (WEI): Hostins (2007), Cristóvão (2008) e Hinterholz Jr. (2009).

2.1 A lógica de algoritmos para solucionar problemas

A lógica é fundamental para se desenvolver qualquer que seja a ação desejada, e

não é diferente na construção de algoritmos. Manzano (2007, p. 3) define lógica como

sendo “a ciência dos princípios formais do raciocínio.” É uma coerência de ideias

usadas de forma ordenada. É uma interpretação de problemas e a partir de tal

compreensão, é possível formular soluções através de uma sequência de ações.

Ninguém ensina ninguém a pensar, mas é possível aperfeiçoar a técnica de

raciocínio, desenvolver uma lógica coerente com a solução do problema através de

muitos treinos de algoritmos (Manzano, 2007).

O que não foi previsível e altera o resultado esperado, é um problema. Do ponto

de vista computacional, problema é tudo aquilo que é contrário a uma regra e que

impede que determinado objetivo seja executado com sucesso (Manzano, 2007).

Primeiro se tem o problema e, através da lógica, é apresentada uma solução em

algoritmo, que pode ser transformado em um programa computacional.

Algoritmo é um conjunto de instruções que executados em ordem atingem um

objetivo. São desenvolvidos de forma teórica, mas para solucionar problemas práticos

(Pessoa, 2004).

23

Para Salvetti e Barbosa (apud Miranda, 2004, p. 11) algoritmo é

(...) uma sequência finita de instruções ou operações básicas que, quando executadas, resolvem um problema computacional de qualquer instância, apoiando-se na estratégia de ordenação da seqüência de instruções estabelecida durante a análise do problema. O desenvolvimento do mesmo não pode perder-se nos tipos de dados e sua representação.

O algoritmo deve ser escrito de forma clara e com precisão, para que qualquer

pessoa possa ler e compreendê-lo sem dificuldades. Definir como o algoritmo se inicia,

quais as condições de execução e como ele termina são fundamentais para a

interpretação do código, principalmente quando este for utilizado por pessoas que não o

desenvolveram. Deve ser próximo da maneira como falamos, para ser um intermediário

entre qualquer linguagem de programação.

É dividido em três fases: entrada, processamento e saída. Na entrada, os dados

são fornecidos, pode ser feito pela digitação do usuário, leitura de arquivo entre outros.

O processamento é responsável pelos cálculos, é a parte inteligente do algoritmo, onde a

entrada é processada. E a saída apenas mostra para o usuário o resultado do

processamento. Não é obrigatório ter a fase da entrada e saída. A Figura 1 representa as

fases de um algoritmo.

Fig. 1 – Fases do algoritmo. Fonte: Elaborado pela autora (2010)

O algoritmo deve-se preocupar com a lógica em si e não se prender em uma

linguagem de programação, embora seja capaz de implementá-lo em todas, desde que se

adapte às regras da linguagem em questão.

Neste projeto, o algoritmo será representado através da “linguagem” portugol,

que é uma combinação de português + algol10, muito utilizada no início dos estudos de

lógica. Seus comandos são em português, o que facilita a compreensão do iniciante na

área de programação para desenvolver uma boa lógica.

O portugol pode ser classificado como pseudocódigo ou português estruturado.

Baseia-se em uma técnica chamada Program Design Language (PDL) – Linguagem de

10 Algol é o nome de uma linguagem de programação estruturada usada inicialmente no final da década de 50 e que deu origem ao Pascal.

24

Projeto de Programação, sua forma original é escrita em inglês, muito parecida com os

comandos em Pascal11 (Manzano, 2007).

O Quadro 01 exemplifica o portugol através de um código de algoritmo para

calcular a média de dois números digitados pelo usuário e mostrar o resultado desse

processamento.

Quadro 1 – Algoritmo média

Fonte: Elaborado pela autora através da ferramenta JPortugol (2010)

A representação do portugol não tem um padrão fixo e cada autor utiliza de uma

forma diferente. Este projeto será embasado nos autores apresentados no início do

capítulo 2, com possíveis alterações para melhor compreensão dos resultados. Toda a

estrutura do portugol utilizada será detalhada na seção 5.2.

Discutidas as questões iniciais, com a conclusão de que é através da lógica que

podemos apresentar soluções para corrigir falhas e melhorar processos através de

algoritmos, a seção seguinte abordará a importância e a dificuldade de aprendizagem

dessa disciplina.

2.2 A aprendizagem de algoritmos

A disciplina de algoritmos tem muita importância nos cursos da área de

computação, pois é a base para o ensino de programação. Quem aprende bem 11 Uma Linguagem de Programação Estruturada que surgiu na década de 70.

25

algoritmos, desenvolve com facilidade qualquer linguagem, pois a maior dificuldade é

desenvolver uma boa lógica, no mais, é só adaptar os comandos.

O fator crítico é o alto índice de reprovação nas instituições brasileiras, sendo

considerado um dos maiores entre todas as disciplinas (Rodrigues Jr., 2004). Vários

problemas no ensino contribuem para a desmotivação, reprovação ou evasão. Entre eles,

são citados por Rodrigues (apud Hinterholz Jr., 2009, p. 486):

(...) dificuldade de adaptação dos alunos desenvolverem raciocínio lógico quando estão acostumados a decorar o conteúdo; falta de motivação do aluno gerada pelo despreparo e o desânimo quando ele acredita que a disciplina constitui um obstáculo extremamente difícil de ser superado.

Muitas vezes não fica claro para os alunos, a importância de aprender bem a

lógica para dar continuidade na área de desenvolvimento de software. Os conceitos

ficam abstratos, e os alunos querem logo executar em uma linguagem de programação

para ver o resultado. Se ocorrer algum erro, o aluno ainda não tem maturidade lógica

suficiente para saber se o erro é na lógica do algoritmo ou se no uso de algum comando

da linguagem, e com isso o resultado não é o esperado.

Além disso, o aluno ainda tem o medo de errar, atrapalhando a execução dos

exercícios que precisam de várias experimentações parara alcançar o resultado desejado

(Cristóvão, 2008).

Um dos problemas mais relatados pelo professor no ensino de algoritmos é a

falta de programas, onde o aluno possa testar seus códigos e receber um feedback das

suas soluções para resolver o problema proposto (Cristóvão, 2008). Daí, a grande

necessidade de ter ferramentas onde possa testar os códigos e só depois de executado

com sucesso, transformar em uma linguagem de programação.

Cristóvão (2008, p. 2) acredita que (...) “o aluno necessita de ambientes que

possa experimentar, simular, investigar possibilidades e, sobretudo errar bastante para

que tenha percepção sobre os limites de um algoritmo”.

É preciso conhecer bem a linguagem que vai utilizar para poder usar de forma

correta nas soluções dos problemas. O ensino de algoritmos não apenas ajuda o aluno

desenvolver uma lógica para desenvolver programas computacionais, como em todas as

situações do dia a dia. O que não se sabe solucionar de forma manual dificilmente

conseguirá através de código de programa.

26

A falta de ambientes para testar no início da aprendizagem de algoritmos supõe

que o aluno já possui um ótimo nível de abstração e um raciocínio lógico capaz de

verificar o resultado do programa apenas de olhar no código. Toda essa abstração é

desenvolvida aos poucos, pois bons programadores são capazes de encontrar erros e isso

se faz através do teste de mesa, executando passo a passo o algoritmo (Cristóvão, 2008).

Para melhorar a aprendizagem de algoritmos de forma mais prática e enfrentar

todos os problemas descritos acima, é proposta o desenvolvimento de ferramentas que

possam auxiliar na construção da lógica algorítmica (Hostins, 2007).

Tendo em vista essa proposta, este projeto tem o intuito de auxiliar na

aprendizagem de algoritmos, através do desenvolvimento do interpretador de códigos

em portugol e para alcançar o objetivo, o próximo capítulo abordará os princípios de um

compilador para o desenvolvimento da ferramenta.

27

3 PRINCÍPIOS DE COMPILAÇÃO

Serão apresentados, neste capítulo, os conceitos de compiladores e

interpretadores, a diferença entre ambos e as fases utilizadas para o desenvolvimento de

um interpretador. A base teórica é embasada nas teorias de Aho et al (1995), Price

(2001), Delamaro (2004) e Hostins (2006).

3.1 Compiladores e interpretadores

O estudo de um compilador é muito amplo e requer conhecimentos específicos

que não serão utilizados neste projeto. A Figura 2 ilustra um compilador de forma geral.

Fig. 2 - Um compilador. Fonte: Aho et al (1995, p. 1)

O compilador é um programa que recebe uma entrada de um código em uma

linguagem de programação, faz o processamento e produz outro arquivo contendo outra

linguagem.

Segundo Aho et al (1995, p. 1)

Um compilador é um programa que lê um programa escrito numa linguagem – a linguagem fonte – e traduz num programa equivalente numa outra linguagem – a linguagem alvo. Como uma importante parte no processo de tradução, o compilador reporta ao seu usuário a presença de erros no programa fonte.

O compilador gera um executável do código fonte ao ser executado. Já o

interpretador simula essa execução, sem gerar esse objeto e são menores que os

28

compiladores. A grande desvantagem dos interpretadores é o tempo de execução, pois

executar um programa objeto (compilado) é mais rápido que um programa interpretado.

Price (2001, p. 5) explica o conceito de interpretadores:

São processadores que aceitam como entrada o código intermediário de um programa anteriormente traduzido e possuem o “efeito de execução” do algoritmo original sem, porém, traduzir para linguagem de máquina. Os interpretadores processam uma forma intermediária do programa fonte e dados ao mesmo tempo.

A Figura 3 mostra um o processo de interpretação:

Fig. 3 – Interpretação de código. Fonte: Price (2001, p. 6)

Algumas ferramentas constituem a etapa de análise do código fonte, dentre elas

o analisador léxico (AL), analisador sintático (AS) e o analisador semântico (ASem). A

etapa de síntese por sua vez conta com um gerador de código intermediário, otimizador

de código e gerador de código que construirá o programa alvo (Louden apud Hostins,

2006).

A estrutura de um compilador é apresentada na Figura 4 de um modo geral, mas

serão detalhadas apenas as etapas necessárias para a construção de um interpretador:

29

Fig. 4 – Fases de um compilador. Fonte: Aho et al (1995, p.5)

Definido o conceito de interpretador e compilador, as próximas seções

apresentam as fases do compilador utilizadas para a construção de um interpretador,

iniciando pela análise léxica.

3.2 Análise léxica

O AL é a primeira fase do compilador. Tem como função analisar o código fonte

da esquerda para direita e separar cada símbolo que tenha significado para a linguagem

e mostrar um erro quando for encontrado algum símbolo ou valor que não faça parte da

especificação da linguagem (definido no arquivo de gramática).

Nas palavras de Price (2001, p. 7)

O analisador léxico lê, caractere a caractere, o texto fonte, verificando se os caracteres lidos pertencem ao alfabeto da linguagem, identificando tokens e desprezando espaços e brancos desnecessários. Os tokens constituem classes de símbolos tais como palavras reservadas, delimitadores, identificadores etc (...).

É nessa análise que verifica se um símbolo faz parte ou não da linguagem, neste

projeto é o português estruturado.

30

Esses símbolos encontrados pelo AL são chamados de tokens ou símbolos

léxicos.

Tokens são símbolos terminais na gramática de uma linguagem. Segundo Price

(2001), cada token representa 03 informações:

1. Classe do token: define o tipo do token, como identificadores, constante,

palavras reservadas, operadores entre outros.

2. Valor do token: depende da classe do token. Se a classe for número

inteiro, o valor só pode ser um número inteiro, exemplo 1, 2 ou 890. A

classe de palavras reservadas não tem valor correspondente.

3. Posição do token: linha e coluna no código fonte que encontrou o token.

Muito utilizado para especificar erro.

Padrão é uma regra que descreve como um token pode ser representado.

Geralmente essas regras são escritas através de expressões regulares. Lexema nada mais

é do que o valor do token seguindo a regra definida pelo padrão.

Na Tabela 1, serão mostrados exemplos da utilização de tokens, padrão e

lexemas.

Tabela 1 – Exemplos de tokens TOKEN LEXEMAS EXEMPLO DESCRIÇÃO INFORMAL DO PADRÃO Const Const Const

If If If Relacao <, <=, =, <>, >, >= < ou <= ou = ou <> ou > ou >=

Id pi, contador, D2 Letra seguida por letras e/ou dígitos Num 3.1416, 0, 6.02E23 Qualquer constante numérica

Literal “conteúdo da memória” Quaisquer caracteres entre aspas, exceto aspas Fonte: Aho et al (1995, p. 39)

As palavras reservadas, os identificadores, as constantes e os operadores da

linguagem são os tokens válidos, que serão utilizados na próxima fase, a análise

sintática. Os comentários, espaços em branco, tabulações e caracteres de avanço de

linha são retirados do código fonte pelo AL, são os tokens que não constituem a

linguagem (Aho et al, 1995).

O AL não se preocupa em verificar se a ordem em que o token aparece é válida

ou não, apenas verifica se é válido de acordo com a especificação da linguagem,

retornando a sua classificação.

No Quadro 2 temos um código com uma sequência de símbolos para exemplificar a análise do AL.

31

Quadro 2 – Símbolos léxicos

Fonte: Elaborado pela autora, baseado em Delamaro (2004, p. 3)

Analisando essa entrada, o AL deverá reconhecer 08 símbolos, de categorias

diferentes:

• 56 = valor inteiro

• 5.6 = valor real

• PI = nome de uma constante

• maior = nome de uma variável

• se = palavra reservada

• “teste@” = valor literal

• falso = valor lógico

• //aqui tem comentário = linha de comentário

Lembrando que essa análise varia de linguagem para linguagem. O Exemplo em

questão é para o portugol utilizado neste projeto, mas não é válido para Java, Delphi,

entre outras. No Quadro 3, será mostrado um exemplo de definição regra léxica válida

para IDENTIFICADOR.

Quadro 3 – Exemplo regra léxica para IDENTIFICADOR

Fonte: Elaborado pela autora através da ferramenta ANTLRWorks (2010)

Neste projeto, o identificador pode ser o nome de uma variável ou o nome do

algoritmo. Para criar a regra léxica é necessário conhecer expressões regulares, que não

é o foco deste projeto.

Na Figura 5, o mesmo IDENTIFICADOR será representado em forma de um

diagrama de sintaxe para melhor compreensão da regra.

32

Fig. 5 - Apresentação do diagrama da sintaxe de IDENTIFICADOR. Fonte: Elaborada pela autora através da ferramenta ANTLRWorks (2010)

Em outras palavras: o identificador obrigatoriamente inicia por underline “_” ou

uma letra minúscula e pode vir seguida por uma letra minúscula, um underline ou um

número inteiro, nenhuma ou várias vezes.

Uma dificuldade do AL é que este pode se encontrar em “estados” diferentes.

Por exemplo, o ‘@’ é um símbolo inválido na regra da linguagem portugol e se este é

encontrado no código, deve ser enviado um erro léxico. Mas se aparecer em “exemplo

de uma string com @”, não é um erro, e sim uma literal (Delamaro, 2004).

O AL deve ser capaz de reconhecer o símbolo e verificar o estado em que se

encontra, pois dependendo do estado pode ser um erro ou não. Além disso, todos os

erros encontrados devem ser informados ao usuário e em paralelo poderá iniciar a

segunda fase, que é a análise sintática que será discutida na próxima seção.

3.3 Análise sintática

O AS é a segunda fase do compilador. É conhecido como o “coração” do

compilador, devido sua importância para a fase seguinte.

Para o AL o símbolo é conhecido como token, já o AS o trata como parser, que

nada mais é do que a sequência de tokens que constituem uma regra sintática.

O AS verifica se a sequência de tokens do AL pode ser processada pela regra da

linguagem (Aho et al, 1995). Essa norma pode ser descrita por meio de uma gramática

livre de contexto (GLC12) em uma notação conhecida como Forma de Backus-Naurs

(BNF), “permite que o lado direito das produções possua alguns operadores”, conforme

explica Delamaro (2004, p. 12).

12 Regras recursivas que podem ser usadas para guiar a análise sintática.

33

O AL não se preocupa em verificar se a ordem em que o token aparece é válida

ou não, apenas verifica se faz parte da linguagem. É nessa segunda fase que ocorre a

verificação se a ordem em que o token aparece é válida de acordo com a regra definida

no arquivo de gramática.

Segundo Price (2001) o AS identifica os símbolos que constituem estruturas

sintáticas, como expressões e comandos, por meio da varredura do código fonte.

Considerando o português estruturado que é o alvo do interpretador

desenvolvido para este projeto, será mostrado no Quadro 4 um exemplo13 de um trecho

de código válido sintaticamente:

Quadro 4 – Trecho de código válido sintaticamente

Fonte: Elaborado pela autora (2010)

O AS deve reconhecer esse código como válido para a linguagem definida. Para

isso deve ser especificado que após a palavra reservada “se” deve vir uma expressão

lógica, a palavra reservada “entao”, logo após um ou mais comandos, nesse caso tem

uma atribuição e termina o comando com a palavra “ fim_se;” . Para o comando

atribuição, o AS deve reconhecer que a sequência é uma variável seguida do sinal “<-” e

logo após, uma expressão. Nesse caso a expressão é o valor da variável “b”. Poderia ter

o bloco do senão, mas que não é obrigatório e não consta no exemplo do Quadro 4.

A regra sintática do comando de seleção “se então/ senão” será exemplificado no

Quadro 5. O código que vêm após o símbolo “>” já faz parte da regra para criação de

uma árvore sintática abstrata, que será citada na próxima seção.

Quadro 5 – Regra sintática comando de seleção “se/entao”

Fonte: Elaborado pela autora através da ferramenta ANTLRWorks (2010)

13 Na seção 3.3.1 será mostrada uma representação de árvore sintática desse exemplo.

34

Se houver erro de sintaxe, o analisador deve armazená-lo e apresentá-lo de

forma legível ao usuário. O AS deve ser desenvolvido de forma que consiga continuar a

processar o arquivo fonte mesmo que encontre algum erro (Price, 2001).

Os erros sintáticos constituem tudo aquilo que foge ao que foi estabelecido pela

gramática da linguagem, como por exemplo, um comando “se” sem o seu respectivo

“fim_se”, um literal sem fechar as aspas, um comando leia sem o nome de nenhuma

variável etc. Não é possível executar a análise semântica se pelo menos uma das fases

anteriores apresentar erros.

Existem dois tipos de analisadores sintáticos.

• Análise descendente (Top-Down): analisa a gramática desde seu início

até o seu fim, construindo sua árvore da esquerda para a direita. Primeiro

cria a raiz, depois as sub-árvores filhas, fazendo com que ela cresça até

atingir suas folhas.

• Análise ascendente (Bottom-Up): analisa a gramática do fim para o seu

começo, isto é, constrói a árvore das filhas até a raiz.

Para a construção do interpretador deste projeto foi utilizada usada a análise

descendente recursiva, que garante que o AS trabalhe recursivamente a partir do

símbolo inicial.

Segundo Aho et al (1995), a análise top-down segue os seguintes passos:

primeiro escolhe um não-terminal a partir do símbolo inicial, escolhe uma produção

deste não-terminal e expande o nodo da árvore. Caso exista um não-terminal a expandir,

volta a escolher uma produção deste não-terminal para trabalhar recursivamente.

Na construção do analisador descendente recursivo é utilizada uma gramática

denominada LL(1) .O primeiro L indica que a entrada será da direita para a esquerda. O

segundo L indica que analisador procura construir uma derivação à esquerda. E o

número 1 indica que com apenas um símbolo conhecido é possível decidir qual

“caminho” seguir na análise do código fonte (Delamaro, 2004).

Tendo conhecimento do que é o AS, a próxima seção mostrará a árvore sintática

que será utilizada para a análise semântica e na construção da tabela de símbolos.

35

3.3.1 Árvore sintática

Outra função do AS é produzir uma estrutura hierárquica do código fonte a

partir do resultado das regras sintáticas chamada árvore sintática.

É uma representação em forma de árvore, na qual os operadores aparecem como

nós interiores e os operandos de um operador são os filhos do nó daquele operador (Aho

et al, 1995).

Árvores sintáticas abstratas (Abstract Syntax Tree - AST) diferenciam da árvore

sintática no sentido em que na primeira os nós são valorizados diretos em seus símbolos

terminais, não tendo a representação completa com os não-terminais.

Na figura 6, pode ser visto um exemplo de AST para o comando de seleção

“se/então” visto no Quadro 4.

Fig. 6 – Representação de uma AST. Fonte: Elaborada pela autora através da ferramenta ANTLRWorks (2010)

Já na Figura 7, será mostrado como ficaria uma árvore sintática com a

representação dos símbolos não-terminais, apenas para a expressão “b>2”.

36

Fig. 7 - Representação da árvore sintática para a expressão b>2. Fonte: Elaborada pela autora através da ferramenta ANTLRWorks (2010)

É a partir da AST, que se constrói a tabela de símbolo utilizada pela fase

seguinte. Essa tabela nada mais é que um repositório (em Java pode ser representada por

um ArrayList ou Vector) das variáveis declaradas, seu tipo de dado, valor, se foi

inicializada etc.

Discutida a análise sintática, a próxima seção aborda a última fase que será

utilizada para a construção do interpretador, a análise semântica.

.

3.4 Análise semântica

O ASem é a terceira fase do compilador e a última para o desenvolvimento do

interpretador. Não utiliza mais o código fonte para fazer suas verificações, e sim, a AST

criada pelo AS.

Essa fase detecta erros de semântica e captura informações para a geração do

código objeto (Aho et al, 1995). Esse código objeto é apenas para a construção de

compilador e não para interpretador.

A função do ASem é criar uma interpretação do código sobre a análise da árvore

sintática, e fazer o papel da execução, quando não existem mais fases.

Segundo Delamaro (2004) o ASem deve procurar incoerências como:

37

• Operações com operandos inválidos. Ex: d <- 5 * a; onde “a” é uma

variável do tipo literal e “d” do tipo inteiro. Além dos tipos de variáveis

serem diferentes, não é possível multiplicar o valor de uma variável

literal;

• Variáveis não declaradas sendo usada em alguma atribuição, expressão

etc.;

• Redeclaração de variáveis, não pode ter duas ou mais variáveis com o

mesmo nome;

• Utilização de um comando errado, como por exemplo, o comando break

fora de uma estrutura de repetição.

Esses erros não são detectados pelo AS, pois para a regra da linguagem o

comando de atribuição “d<- 5 * a;” é válido. O AS não verifica o tipo das variáveis

envolvidas (Delamaro, 2004). Os erros semânticos são erros de execução e não mais de

compilação.

Para realizar sua função, o ASem utiliza da tabela de símbolos. Através dessa

tabela, o ASem consegue fazer essas verificações de tipos incompatíveis, verificar se foi

atribuído valor à variável antes de usá-la em uma expressão etc.

O interpretador tem que parar a execução quando encontra um erro semântico.

Neste projeto a análise semântica foi dividida em 02 fases, que serão focadas na

seção 5.3.2. Com a análise semântica encerra-se o capítulo sobre Princípios de

Compilação, e o próximo aborda as ferramentas utilizadas para a construção do

interpretador, mais precisamente dos analisadores léxico e sintático.

38

4 FERRAMENTAS GERADORAS DE ANALISADORES

Existem várias ferramentas que auxiliam na criação das análises léxica e

sintática para construção do compilador/interpretador. São conhecidas como

“compilador de compiladores”. Dentre as existentes, podem citar: YaCC, JavaCC,

SableCC e ANTLR.

Aqui serão apresentados o ANTLR e o ANTLRWorks. As informações são

embasadas no site oficial da ferramenta: www.antlr.org e

www.antlr.org/works/index.html e nas teorias do autor criador Parr (2007).

4.1 ANTLR e seu ambiente de desenvolvimento ANTLRWorks

ANTLR é o gerador de parses 14 escolhido para auxiliar na criação da análise

léxica e sintática deste projeto devido sua facilidade de uso, testes e a interface gráfica

ANTLRWorks. Foi desenvolvido por Terence Parr, professor de Ciência da

Computação da Universidade de San Francisco.

É uma ferramenta que fornece uma estrutura para construir interpretadores,

compiladores e tradutores de descrições gramaticais contendo ações em uma variedade

de linguagem de destino, como Java, C, entre outras, além de fornecer um excelente

suporte para a construção da árvore, recuperação de erros etc. (ANTLR, 2010).

A versão mais recente e utilizada nesse projeto é a 3 – ANTLR v3.2, em

conjunto com o ANTLRWorks. O ANTLR v2 (última versão 2.7.7 de 2006) não possui

suporte para utilizar o ANTLRWorks, somente o ANTLR v3.

Segundo Parr (2007), algumas coisas mudaram para melhor na v3, incluindo:

• Uma extensão muito poderosa para LL(k) chamada LL(*);

• Um modo de auto-retorno (auto-backtracking);

• Memorização do resultado parcial de análise para aumentar a velocidade

de recuo;

14 Segundo Aho et al (1995), parser é o analisador sintático que obtém uma sequência de tokens do analisador léxico e verifica se essa sequência pode ser gerada pela gramática da linguagem.

39

• Mecanismo de regras para reescrever AST;

• Melhor recuperação de erros.

ANTLRWorks15 é um ambiente de desenvolvimento de gramática para ANTLR

v3 desenvolvido por Jean Bovet com casos de uso sugerido por Terence Parr. Já vem

com o jar16 do ANTLR embutido, não necessitando do download separado e requer Java

1.5 ou superior instalado (ANTLRWorks, 2010).

Essa ferramenta combina um editor excelente com um intérprete para

prototipagem rápida e um depurador de linguagem para isolar os erros gramaticais,

destacando os caminhos ambíguos no diagrama de sintaxe associada com uma

gramática (ANTLRWorks, 2010).

Algumas características do ANTLRWorks, associadas com o ANTLR v3 que

foram importantes para a escolha dessa ferramenta:

• Acompanha os eventos de depuração como um analisador de processos

de entrada;

• Suporta geração de código em todas as linguagens que o ANTLR v3 sabe

gerar, através do output = opção de linguagem, no arquivo de gramática;

• Visualização da árvore sintática e da AST.

• Possibilidade de testes com códigos, apresentando exceções, se houver.

Um grande diferencial do ANTLR v3 é que não requer que seja especificado um

valor para lookahead (opção k na v2). O novo algoritmo ANTLR de LL(*) permite o

parser percorrer os símbolos e encontrar uma sequência que desambigúe a decisão

(Parr, 2007).

Isso faz com que não precise determinar quantos caracteres a frente o analisador

vai percorrer na regra, para evitar ambiguidade.

Basta acrescentar na seção options {backtrack = true;} que se for encontrado

alguma ambiguidade no código, o ANTLR volta e reavalia a expressão indo para outro

caminho. É possível também para construir AST, acrescentando na mesma seção

output=AST; (Parr, 2007)

15 Versão utilizada 1.3.1 (2009) – versão atual 1.4, não foi utilizada, pois quando saiu essa versão (junho/2010) já estava pronto o arquivo de gramática para o projeto. Pode ser baixada em: http://www.antlr.org/download.html 16 Executável de um programa em Java

40

O Quadro 6 demonstra a reescrita de AST, onde qualquer coisa depois do “->” é

considerada uma gramática de árvore.

Quadro 6 – Exemplo de reescrita de AST

Fonte: Elaborado pela autora com base em Parr (2007)

A Figura 8 mostra a área do editor da ferramenta ANTLRWorks, já com regras

léxicas e sintáticas definidas.

Fig. 8 – Editor ANTLRWorks. Fonte: ANTLRWorks (2010)

41

O arquivo de gramática utilizado pelo ANTLRWorks pode ter qualquer nome

desde que tenha a extensão .g.

É possível escolher o tipo de arquivo: somente regras sintáticas, somente regras

léxicas, árvore sintática da gramática ou a combinação das regras de gramática em um

único arquivo. Alguns itens léxicos já podem ser criados no modelo padrão como:

valores inteiros, identificadores, valores reais, comentário de uma única linha ou um

bloco de comentário entre outros, conforme pode ser visto na Figura 9.

Fig. 9 – Criando um arquivo de gramática no ANTLRWorks. Fonte: ANTLRWorks (2010)

Conforme Parr (2007), existem regras para criar um arquivo.g, porém serão

apresentadas na Tabela 2 somente as que foram importantes para o desenvolvimento

deste projeto.

Tabela 2 – Regras ANTLR

Regra Descrição Exemplo Nome dos tokens Devem sempre iniciar com a

letra maiúscula. Geralmente utiliza-se em UpperCase.

ALGORITMO: ’meu token de algoritmo’;

Regras sintáticas Devem sempre iniciar com a letra minúscula. Geralmente utiliza-se em LowerCase.

start: INT+;

42

Seção options Define algumas opções

importantes como: gerar uma AST e verificar caminhos ambíguos.

options{ ASTLabelType= CommonTree; output = AST; backtrack = true; }

Seção tokens Tokens especiais, não confundir com os tokens da gramática. Por exemplo, os que são utilizados na AST

tokens{ PROGRAMA = 'PROGRAMA'; }

Seção header Define as importações de pacote.

// Este é o package do analisador //sintático @parser::header { package edu.univas.tcc.; } // Este é o package do analisador //léxico @lexer::header { package edu.univas.tcc; }

Seção members Onde pode ser implementado código Java nas classes léxicas e /ou sintáticas

@members { //exemplo é sobrescrever método //getErrorMessage para tratamento de //erros. }

Regras EBNF É uma BNF melhorada, solucionando problemas de notação para representar facilmente decisões e repetições

‘?’ = a regra é opcional. Não ocorre nenhuma vez, ou ocorre somente uma vez. ‘+’ = a regra ocorre uma ou mais vezes. Ou seja, pode ocorrer mais de uma vez, mas é obrigada no mínimo uma ocorrência. ‘*’ = A regra ocorre zero ou mais vezes. Ou seja, pode não ocorrer nenhuma vez, pode ocorrer uma vez ou pode ocorrer várias vezes.

Fonte: Elaborada pela autora baseado em Parr (2007)

Com a definição do arquivo de gramática, o ANTLR gera o código do AL e AS,

e transforma a gramática inserida em uma AST, e a partir dessa árvore é que vão ser

criadas as funcionalidades semânticas para cada nó reconhecido.

O ANTLR utiliza como linguagem a Forma Estendida de Bakus-Naur (EBNF),

que é uma extensão melhorada da BNF, através de expressões regulares.

43

5 METODOLOGIA DO DESENVOLVIMENTO

Este projeto foi desenvolvido com a linguagem Java através do ambiente de

programação Eclipse e com o auxílio das ferramentas ANTLRWorks e Jude, para

criação das classes léxica e sintática e modelagem de diagramas, respectivamente.

Tendo em vista todo o embasamento teórico já apresentado e os testes com

algumas ferramentas já existentes, como mencionadas no capítulo introdutório, este

capítulo mostrará como foi feito o desenvolvimento das principais funções do

interpretador. Além das funções específicas, também foram desenvolvidas algumas

relacionadas com editor de texto, como salvar um arquivo, abrir um arquivo, copiar,

colar etc.

A próxima seção mostrará essas funções do editor, que não constituem funções

específicas do interpretador de algoritmos.

5.1 Funções básicas de editor de texto

O interpretador de algoritmos constitui-se de algumas funções relacionadas com

editor de texto. Essas funções estão divididas em dois menus: Arquivo e Editar, como

em qualquer editor, com a função de auxiliar o usuário na criação dos códigos de

algoritmos.

A Figura 10 apresenta o menu Arquivo da ferramenta JPortugol com todas as

funcionalidades disponíveis.

44

Fig. 10 – Menu arquivo. Fonte: Elaborada pela autora (2010)

Conforme a Figura 10 é possível criar um arquivo de duas formas: no padrão

alg, utilizado neste projeto ou um arquivo vazio. O arquivo vazio é um arquivo que não

contém nenhum texto e o usuário deve começar a escrever seu código de algoritmo com

todos os requisitos básicos para a estrutura do algoritmo. O arquivo no padrão alg,

apresentado na Figura 11, já mostra para o usuário a estrutura básica para começar o

algoritmo, de acordo com as regras de gramática definidas para este projeto.

Fig. 11 – Estrutura do arquivo padrão alg. Fonte: Elaborada pela autora (2010)

Alg é apenas uma extensão criada para JPortugol, nada mais é, que um arquivo

de texto simples.

A segunda função no menu arquivo é Abrir. Por padrão, o tipo de arquivo

mostrado na tela para escolher o diretório é arquivos JPortugol na extensão .alg, mas é

possível também escolher todos os tipos e abrir um código de algoritmo salvo em um

bloco de nota com a extensão .txt, por exemplo. Uma vez escolhido o arquivo a ser

aberto e clicando em selecionar, todo o conteúdo do arquivo será apresentado na área do

editor e pode ser alterado, fechado e utilizado todas as funções disponíveis.

45

A Figura 12 mostra a tela de escolha do diretório, com o tipo de arquivo padrão

do JPortugol sendo selecionado para atualizar na tela do editor.

Fig. 12 – Tela abrir arquivo JPortugol. Fonte: Elaborada pela autora (2010)

Depois de aberto o arquivo, a barra de título da ferramenta JPortugol é

atualizado com o caminho e nome do arquivo aberto, conforme Figura 13.

Fig. 13 – Barra de título atualizada. Fonte: Elaborada pela autora (2010)

A terceira opção é Fechar o arquivo. Quando o usuário seleciona essa opção é

mostrada uma mensagem perguntando se deseja salvar o arquivo. Se a resposta for sim,

o arquivo é salvo antes de ser fechado, senão, simplesmente é fechado, sem verificar se

houve alterações para salvar.

A quarta e quinta opção, Salvar e Salvar Como, respectivamente, se referem a

um arquivo já aberto. Se o usuário clica em Salvar, primeiro o interpretador verifica se

esse arquivo já foi salvo pelo menos uma vez, e se não foi, é chamada automaticamente

a opção Salvar Como, onde o usuário pode escolher a pasta de destino e nome do

arquivo. Se sim, apenas salva as alterações do texto no mesmo arquivo. Por padrão, o

tipo de arquivo a ser salvo é .alg, podendo mudar a extensão.

46

A última opção desse menu é Sair. É apresentada uma mensagem ao usuário

perguntando se realmente deseja sair do sistema. Se a resposta for sim, é encerrada a

aplicação, senão, continua a execução da ferramenta.

Encerrando o menu Arquivo, a Figura 14 ilustra o menu Editar com suas opções

disponíveis.

Fig. 14 – Menu editar. Fonte: Elaborada pela autora (2010)

As duas primeiras opções, Desfazer e Refazer, são respectivamente, desfazer a

última ação e refazer uma última ação desfeita. Para isso, foi criada uma classe Java que

implementa UndoableEditListener, toda vez que o evento for alterado, é adicionado a

ação em uma lista de ações correspondentes ao componente JTextPane, que é a área de

digitação do código do interpretador. Quando o usuário clica em Desfazer, a última

ação é retirada da lista de ações e adicionada na lista de “desfazer”. Se o usuário clica

em Refazer, a última ação é retirada da lista de “desfazer” e adicionada na lista de

“refazer”. O máximo de ações que podem ser armazenadas neste projeto é de 50. O

Quadro 7 mostra o código da classe InterpretadorController que é chamado quando o

usuário clica no item Desfazer.

Quadro 7 – Código chamado ao clicar na ação desfazer @Override public void undo() { getUndoableListener().undo(); } private MyUndoableController getUndoableListener(){ if ( _myUndoable == null){ _myUndoable = new MyUndoableController(); } return _myUndoable ; }


47

Já o Quadro 8 mostra trecho do código da classe que implementa de

UndoableEditListener – MyUndoableController, responsável pelo método desfazer

chamado da classe InterpretadorController.

Quadro 8 – Trecho da classe responsável pelo método desfazer private List<UndoableEdit> _actions = new ArrayList<UndoableEdit>(); //lista para armazenar Desfazer private List<UndoableEdit> _undos = new ArrayList<UndoableEdit>();

/** * Desfazer uma ação - remove da lista de ações e * adiciona na lista de Desfazer */ public void undo(){ if ( _actions .size() == 0) return; UndoableEdit edit = _actions .remove( _actions .size() - 1); _undos .add(edit); edit.undo(); }


As 04 últimas opções desse menu são: Copiar, Colar, Recortar e Selecionar

Tudo, que podem ser vistas de duas maneiras: no menu Editar e clicando com o mouse

direito sobre a área de digitação de código do editor em forma de janela pop-up,

conforme pode ser visto na Figura 15.

Fig. 15 – Opções do menu pop-up. Fonte: Elaborada pela autora (2010)

A função Copiar é fazer uma cópia de um texto ou palavra em outra parte do

editor, por exemplo, é duplicar informações. A função Colar é que faz essa função de

duplicar, depois de já ter selecionado o texto e clicado em Copiar. Recortar é retirar um

texto ou parte dele de um lugar e pode ser movido para outro com a função Colar.

Selecionar Tudo é deixar marcado, selecionando toda a área do editor que

contém algum texto digitado. No quadro 9 é apresentado o código dessas funções,

48

lembrando que o método getAreaEditor() apenas retorna o componente JTextPane

responsável por permitir a digitação pela área do editor.

Quadro 9 – Código copiar, colar, recortar e selecionar tudo //Método que realiza a ação de Copiar em um arquivo - Crtl+C public void copy() { getAreaEditor().copy(); } // Método que realiza a ação de Colar em um arquivo - Crtl+V public void paste() { getAreaEditor().paste(); } //Método que realiza a ação de Recortar em um arqui vo - Crtl+X public void cut() { getAreaEditor().cut(); } //Método que realiza a ação de Selecionar todo o te xto em um arquivo public void selectAll() { getAreaEditor().selectAll(); }


A última função do menu Editar é Ir para a linha, que permite digitar um número

de linha e o cursor do mouse apontará a linha na área do editor, conforme Figura 16.

Fig. 16 – Tela localizar linha. Fonte: Elaborada pela autora (2010)

Caso a linha digitada não exista na área de digitação é mostrada uma mensagem

com essa informação.

Após a apresentação das funções básicas do editor, a próxima seção mostrará a

criação do arquivo de gramática do interpretador.

49

5.2 Criação do arquivo de gramática

Essa seção mostra os passos para a criação do arquivo de gramática utilizado

pela ferramenta JPortugol. É nele que estão contidas todas as regras da linguagem

portugol definida para o interpretador deste projeto.

O arquivo de gramática é onde vai conter todas as regras da linguagem

escolhida, por exemplo, a estrutura do algoritmo, os comandos utilizados, como declarar

uma variável, etc.

Essa seção mostra os passos para a criação do arquivo de gramática utilizado

pela ferramenta JPortugol. É nele que estão contidas todas as regras da linguagem

portugol definida para o interpretador deste projeto.

O arquivo de gramática é onde vai conter todas as regras da linguagem

escolhida, por exemplo, a estrutura do algoritmo, os comandos utilizados, como declarar

uma variável etc.

Para definir esse arquivo, deve-se ter em mente todos os comandos que serão

utilizados, embasados nos autores relacionados no capítulo introdutório e no capítulo 2 -

Ensino de Algoritmos, adaptados para o uso neste projeto de acordo com a escolha da

autora. A linguagem portugol utilizada neste projeto para uso da ferramenta JPortugol

suprirá as seguintes necessidades para verificação e execução do algoritmo:

• Tipos básicos de dados: os tipos de dados disponíveis estão detalhados

na Tabela 3.

Tabela 3 - Tipos de dados

Tipo de Dado

Descrição Exemplo

Inteiro Toda informação numérica que pertence ao conjunto dos números inteiros relativos. (sem casa decimal)

1, 3, 7

Real Toda informação numérica que pertence ao conjunto dos números inteiros reais. (com ou sem casa decimal)

1.6, 3, 7.89

Literal Conjunto alfanumérico, aceita símbolos especiais ($, @, #, etc). Deve vir dentro de aspas duplas.

“aqui tem um literal”

50

Lógico Toda informação que posa assumir somente dois valores lógicos, booleanos.

falso, verdadeiro

Fonte: Elaborada pela autora baseado em Manzano (2007)

• Variável e constante: são espaços reservados na memória para

armazenar um tipo de dado definido. Os nomes devem começar por letra

e pode conter outras letras e/ou números. Não aceita caracteres especiais

e nem espaço entre os nomes. O valor da variável é alterável, já as

constantes têm seu valor fixo e não pode ser modificado e o seu nome

deve ser em letra maiúscula. Exemplos:

1. Nomes válidos: idade, peso, nome, n1, n23a, PI, MAIOR

2. Nomes inválidos: _idade, &peso, n ome, 1n, -n23a, :PI, @MAIOR

• Matriz e Vetor: são coleções de variáveis do mesmo tipo de dado. O

Vetor só tem uma dimensão, isto é, uma linha e várias colunas. Já a

matriz tem mais de uma linha e pode ter uma ou mais colunas.

• Atribuição: é representada pelo símbolo <-. A atribuição é feita somente

para variáveis, podendo ser vetor, matriz ou simples. Somente é possível

atribuir um valor por vez. Uma atribuição deve conter um identificador

válido à esquerda e uma expressão à direita do símbolo.

• Comentários: os comentários servem apenas de auxílio para o

programador, é desprezado na compilação. Pode ter comentário de uma

linha e um bloco de comentário. No Quadro10 é apresentada a estrutura

dos comentários.

Quadro 10 – Exemplos de comentários


51

• Operadores: os operadores utilizados são: aritméticos, relacionais e

lógicos. A Tabela 4 apresenta os operadores aritméticos, além dos

operadores de resto e divisão inteira.

Tabela 4 – Operadores aritméticos Operador Símbolo

Adição + Subtração - Multiplicação * Divisão / Potenciação ** Resto da divisão resto Divisão inteira – quociente da divisão div

Fonte: Elaborada pela autora (2010)

A Tabela 5 apresenta os operadores relacionais.

Tabela 5 – Operadores relacionais

Operador Símbolo Maior > Menor < Igual = Maior ou igual >= Menor ou igual <= Diferente <>


Os operadores relacionais podem ser utilizados para tipo de dado inteiro,

real e literal. Os símbolos “>” e “<” para o tipo de dado literal são usados

para ordenação (ordem alfabética). A Tabela 6 apresenta os operadores

lógicos.

Tabela 6 – Operadores lógicos Operador Símbolo

Inversão nao Junção e Disjunção ou


• Entrada e Saída: a entrada de valores para variáveis digitados pelo

usuário será feita através do comando “leia”. A saída de informações será

no console através do comando “escreva”.

52

• Estrutura de seleção: será aceita somente a estrutura “se então/senão”.

Executa um ou mais comandos de acordo com o resultado do teste

lógico. Pode ser simples ou composta e pode conter encadeamento de

outras estruturas. O Quadro 11 mostra a sintaxe da estrutura de seleção

“se” composta.

Quadro 11 – Sintaxe do comando de seleção “se/entao”

se (condicao) entao //comandos se verdadeiro senao // comandos se falso fim_se; Fonte: Elaborado pela autora (2010)

• Estrutura de repetição: são estruturas que contêm comandos que devem

ser executados mais de uma vez. Pode fazer o teste da repetição no

início, no fim ou com variável de controle, quando se sabe exatamente o

inicio e o fim da repetição. O Quadro 12 mostra a sintaxe das 03

estruturas de repetições suportadas pela ferramenta JPortugol.

Quadro 12 – Sintaxe das estruturas de repetição

-Repetição com teste no início – enquanto/faca enquanto (condicao) faca //comandos; fim_enquanto; -Repeticao com teste no fim – repita/ate repita //comandos ate(condicao); -Repetição com variável controladora para variavel de valor inicio ate valorfim (passo (+ou-) numerointeiro) faca //comandos; fim_para; *comando passo não é obrigatório. Fonte: Elaborado pela autora (2010)

• Funções disponíveis: algumas funções foram pré-definidas para

auxiliar em cálculos simples, conforme pode ser visto na Tabela

7.

53

Tabela 7 – Funções disponíveis

Função Descrição Representação Valor absoluto Retorna o valor absoluto

do número, desprezando o sinal (+ ou -).

abs (inteiro ou real);

Parte Fracionária Retorna a parte fracionária do número.

frac (real);

Parte inteira Retorna a parte inteira do número.

trunc (real);

Raiz quadrada Retorna a raiz quadrada do número.

raiz (inteiro ou real);

Seno Retorna o seno do número. sen (inteiro ou real); Cosseno Retorna o cosseno do

número. cos (inteiro ou real);

Tangente Retorna a tangente do número.

tan (inteiro ou real);

Converter para Maiúsculo

Converte um literal para maiúsculo.

maiusc (literal);

Converter para Minúsculo

Converte um literal para minúsculo.

minusc(literal);

Comprimento Retorna o comprimento de um literal.

compr(literal);


A linguagem utilizada pela ferramenta interpretadora JPortugol é case sensitive,

isto é, faz diferença entre letras maiúsculas e minúsculas, e não aceita acento, cedilha

(ç) e til(~), a não ser em blocos de comentários ou literal. Com exceção de nome de

constantes, toda a linguagem deve ser escrita em letra minúscula. Definido a estrutura

da linguagem, os próximos passos para a criação do arquivo, através da ferramenta

ANTLRWorks são:

1. Criar arquivo: na ferramenta ANTLRWorks escolha a opção – File –

New e selecione a criação de arquivo de gramática .g e clique em ok,

conforme a Figura 17.

Fig. 17 - Tipo de arquivo a ser criado. Fonte: ANTLRWorks (2010)

54

A próxima tela que aparece pode ser revista na Figura 9, onde é digitado o nome

do arquivo, com a opção de escolher o tipo de gramática e criar alguns símbolos léxicos

por padrão. O nome escolhido foi Portugol, o tipo de gramática foi Combined

Grammar, para poder criar a análise léxica e sintática no mesmo arquivo e foi marcado

apenas para criar o item léxico padrão referente aos comentários.

2. Definir regras: com o arquivo criado, agora temos que começar a

escrever as seções, que já foram explicadas na Tabela 2. Deve seguir a

seguinte ordem: options, tokens (não é obrigatório, só se tiver), header

(para os dois analisadores), members (se houver, deve ser escrito um para

cada analisador), todos os tokens das regras léxicas e por fim, as regras

sintáticas. Na seção members é que foram tratadas as exceções léxicas e

sintáticas lançadas pelo ANTLR.

A Figura 18 mostra a tela do ANTLRWorks. No item 1 são as regras léxicas

representadas pela letra L, no item 2, as regras sintáticas representadas pela letra P

(parser) e o item 3, é a visualização da regra sintática de declaração_algoritmo em

forma de diagrama de sintaxe.

55

Fig. 18 – Tela ANTLRWorks com as regras definidas. Fonte: Elaborada pela autora através do

ANTLRWorks (2010)

3. Testes: depois de definido as regras da linguagem, é possível realizar

testes através do ANTLRWorks. Basta acessar o menu Run e clicar na

opção Run.

A Figura 19 mostra a tela de entrada do código, onde este pode ser através do

Text, onde o usuário digita seu código ou através do File, onde é escolhido um arquivo.

56

Start rule é onde inicia a execução da gramática, a primeira regra que deve ser

executada. No exemplo, o algoritmo foi digitado.

.

Fig. 19 - Tela de entrada de código para testes. Fonte: ANTLRWorks (2010)

Com a entrada definida, basta clicar em Ok para ser processado o código. A

Figura 20 apresenta a tela do ANTLRWorks após a execução do algoritmo. Como

podemos observar, a área de input é o código digitado e temos duas representações após

a execução: AST e a Parse Tree – árvore sintática, ambas serão apresentadas nas

Figuras 21 e 22, respectivamente.

57

Fig. 20 – Tela execução de testes. Fonte: Elaborada pela autora através da ferramenta ANTLRWorks

(2010)

É possível verificar na Figura 20 a área de Input que contém o código digitado

para teste, o Parse Tree que mostra a imagem árvore sintática e a AST, ambas

representadas graficamente. A Figura 21 mostra a saída da AST conforme definida após

a execução do código.

Fig. 21 – AST do teste. Fonte: Elaborada pela autora através da ferramenta ANTLRWorks (2010)

58

Já na Figura 22, somente será apresentada parte da árvore sintática gerada, da

declaração do algoritmo até o início do programa.

Fig. 22 – Representação da árvore sintática do teste. Fonte: Elaborada pela autora através da ferramenta

ANTLRWorks (2010)

É possível perceber a exceção MissingTokenException que foi lançada após a

declaração da variável. Essa exceção se refere a um token esperado que não foi

encontrado. Se voltarmos ao código da Figura 19, é possível identificar que realmente

faltou o ‘; ’ depois do tipo de dado da variável. Através dos testes consegue-se verificar

se o código está correto sintaticamente e se alguma exceção será lançada se este for

executado. A partir daí, é possível analisar os erros para tratá-los.

4. Geração das classes: depois do arquivo testado através de entrada de

código o próximo passo é gerar a classe léxica e sintática. Através do

menu Generate apresentado na Figura 23, é só clicar na primeira opção

Generate Code.

Fig. 23 – Menu gerar código léxico e sintático no ANTLRWorks. Fonte: ANTLRWorks (2010)

59

Uma mensagem é mostrada informando que os códigos foram gerados com

sucesso. Por padrão, esses são salvos na pasta output no mesmo local onde está o

ANTLRWorks. As classes geradas podem ser vistas na Figura 24.

Fig. 24 – Tela com as classes geradas pelo ANTLRWorks. Fonte: Elaborada pela autora (2010)

A pasta classes contém os arquivos .class gerados, que não serão utilizados.

__Test__ e __Test__Input são arquivos que contém o código do algoritmo testado. O

que realmente importa aqui são os arquivos: Portugol.tokens, PortugolLexer.java e

PortugolParser. Portugol.tokens é um arquivo que contém todos os símbolos léxicos

definidos e um código único para cada token. PortugolLexer.java é a classe responsável

pela análise léxica do interpretador e PortugolParser.java é a classe da análise sintática.

É nessa última que também foi criada a AST para ser utilizada na análise semântica.

5. Integração com o eclipse: com a criação dessas classes, o último passo

deste capítulo é adicioná-las ao projeto do Eclipse, no pacote já

determinado na seção header e integrar ao código Java da classe

InterpretadorBI normalmente, como poderá ser visto nas outras seções

deste mesmo capítulo. Não é necessário adicionar o arquivo Portugol.g

no projeto, apenas as classes por ele geradas (Portugol.tokens,

PortugolLexer.java e PortugolParser.java)

60

Para fácil identificação dos comandos no interpretador JPortugol, foi criado um

outro arquivo de gramática apenas com a função de definir cor para os comandos da

linguagem de acordo com a categoria que se encontra. Assim que digitado um comando

no interpretador JPortugol, esse receberá a cor pré-estabelecida e não poderá ser

alterada.

Com o arquivo de gramática criado, a próxima seção apresenta as funções

específicas do interpretador de algoritmos.

5.3 Funções do algoritmo

As funções específicas do interpretador desenvolvido neste projeto são aquelas

ligadas à verificação e execução do código de algoritmo em português estruturado para

a linguagem definida e apresentada na seção 5.2.

A Figura 25 mostra o diagrama de caso de uso dessas funções do algoritmo.

Fig. 25 – Diagrama de caso de uso das funções do interpretador. Fonte: Elaborada pela autora (2010)

61

O usuário poderá verificar o algoritmo, executar e executar passo a passo. A

ação de parar uma execução exige que uma das funções executar ou executar passo a

passo tenham sido iniciadas e estas exigem que o código seja verificado anteriormente.

Já a ação de executar o próximo passo exige que tenha iniciado a função executar passo

a passo.

A Figura 26 apresenta o menu Algoritmo e suas funções utilizadas no

interpretador desenvolvido.

Fig. 26 – Menu algoritmo. Fonte: Elaborada pela autora (2010)

Todas as funções que compõem os itens do menu Algoritmo serão detalhadas

nas próximas seções. A primeira a ser apresentada é a função de verificar um código de

algoritmo.

5.3.1 Verificando o algoritmo

Verificar um código algoritmo significa validar se o código está sintaticamente

correto de acordo com as regras de linguagem definida, isto é, se a sequência digitada é

válida para a o português estruturado utilizado.

Para realizar essa função foram desenvolvidos o AL e o AS que serão abordados

nas seções 6.1 e 6.2 respectivamente, do capítulo referente à Discussão dos Resultados.

Primeiramente, para verificar um algoritmo é necessário criar um arquivo, seja

simples ou no padrão alg, que tenha um código digitado. A Figura 27 mostra a

mensagem informada ao usuário, caso tenha clicado em Verificar sem ter nenhum

código digitado.

62

Fig. 27 – Tela de informação verificar código. Fonte: Elaborada pela autora (2010)

A Figura 28 mostra como pode ser criado um arquivo padrão através do acesso à

função de criar arquivo através da barra de opções rápida.

Fig. 28 – Tela criar arquivo padrão. Fonte: Elaborada pela autora (2010)

Após criar um arquivo e digitar o código, é possível fazer a verificação. Na

Figura 29 é possível visualizar a utilização dessa função com um código simples de

algoritmo.

63

Fig. 29 – Tela verificação do código. Fonte: Elaborada pela autora (2010)

O código da Figura 29 foi verificado sintaticamente e não apresenta nenhum

erro. Nesse caso, é apresentada uma mensagem ao usuário, conforme Figura 30.

Fig. 30 – Mensagem código verificado com sucesso. Fonte: Elaborada pela autora (2010)

Os erros encontrados nessa fase podem ser de dois tipos: erros léxicos e erros

sintáticos. A primeira análise é a léxica e o interpretador deve continuar a validação

sintática, mesmo que ocorra algum erro léxico. O mesmo vale para a análise sintática,

deve continuar varrendo o código e somente no final apresentar todos os erros

encontrados no console (Aba Erro(s)) para o usuário.

PortugolLexer.java é a classe do AL e PortugolParser.java é a classe do AS

geradas através do ANTLRWorks, com o arquivo Portugol.g definido. Através do

64

método getErrorMessage(RecognitionExcetion e, String[] tokenNames) é possível tratar

todas as exceções encontradas de erros de caracteres inválidos e sintaxe incorreta. Esse

método pode ser sobrescrito no arquivo Portugol.g antes mesmo de criar as classes Java,

como foi feito neste projeto e poderá ser consultado nos apêndices.

A única exceção tratada na classe léxica é a NoViableAltException, que quer

dizer que o caracter encontrado não é uma alternativa viável para a linguagem definida,

pois não foi encontrado em nenhuma regra léxica válida. Por exemplo, o símbolo “&”

não pertence à linguagem utilizada neste projeto, portanto, se ele for encontrado no

código, o interpretador deve informar esse erro léxico, conforme ilustrado na Figura 31.

Fig. 31 – Tela verificação do código com erro léxico. Fonte: Elaborada pela autora (2010)

Essa análise léxica deve ser feita de acordo com a classe onde o caracter foi

encontrado. No exemplo da Figura 31 foi apresentado erro, pois o caracter “&” foi

utilizado para nome de variável, e para regra de identificador esse caracter não é viável.

65

Outro exemplo ilustrando a diferença de classe onde o caracter é encontrado será

mostrado na seção 6.1.

Já a classe parser apresenta mais exceções para serem tratadas e são mais

complicadas, pois as mensagens devem conter informações precisas e simples para o

usuário compreender sem dupla interpretação. Por se tratar de erros de sintaxe, muitas

vezes não fica muito claro o que realmente está errado no código, se é um erro de

digitação em uma palavra reservada ou se é mesmo uma atribuição em uma variável etc.

Para os itens 2 e 3 considere o seguinte código o seguinte trecho “se 5>1 entao

fim_se;”. As exceções tratadas são:

1. MismatchedTokenException: indica que o analisador estava procurando

por um símbolo especial e não é possível encontrar na posição de entrada

atual. Exemplo: Encontrado "algoritmos" tem esperado "algoritmo.";

2. NoViableAltException: o reconhecedor chegou a um ponto de decisão,

mas o lookahead não foi consistente com nenhuma das alternativas.

Exemplo: Inviável "5" nessa posição. Sintaxe: se (condicao) entao

//comandos; fim_se;

3. EarlyExitException: o reconhecedor chegou a um subrule (..)+ EBNF que

deve encontrar pelo menos um comando, mas não encontrou nada.

Exemplo: Estrutura incompleta. É necessário pelo menos um comando

antes de "fim_se";

4. MismatchedNotSetException: o reconhecedor tentou igualar o inverso de

um conjunto, mas não podia.

5. MismatchedSetException: O reconhecedor tentou combinar um conjunto

de símbolos, mas não conseguiu. Exemplo: declaração de constantes: A:

inteiros=1; - Encontrado "inteiros". Verifique se foi definido o tipo de

dado e atribuído o valor à constante.

6. MismatchedRangeException: O reconhecedor tenta combinar uma série

de símbolos, caracteres em geral, mas não podia. Ele controla o elemento

mínimo e máximo do intervalo.

66

Toda a mensagem de erro sintático apresenta o bloco do algoritmo onde foi

encontrado o erro e dependendo do tipo de exceção, até um exemplo de como é a

sintaxe correta. A Figura 32 apresenta um código com erros sintáticos de diversas

situações.

Fig. 32 – Tela verificação do código com erro sintático. Fonte: Elaborada pela autora (2010)

Selecionando um erro na lista de erros, a linha na área do editor que contém o

erro fica selecionada de cor diferente para melhor visualização.

Um erro sintático pode gerar outros erros, como é o caso dos dois primeiros

erros apresentados na Figura 32. Podem ser definidos como:

• Linha:6:1 Encontrado "algoritmos" tem esperado "algoritmo." [Bloco:

Declaração de Algoritmo] - [Erro Sintático]: a palavra reservada é

“algoritmo” e não “algoritmos”. Todo código deve iniciar com

“algoritmo” e vir seguido do seu nome;

67

• Linha:6:12 Encontrado "errosintatico" tem esperado "por ponto e vírgula

';' . " [Bloco: Declaração de Algoritmo] - [Erro Sintático]: continuando

o erro da linha 6, “errosintatico” é um nome válido para o algoritmo, mas

como não foi encontrada a palavra reservada correta, “algoritmos”

acabou sendo o nome e aqui seria o ‘;’;

• Linha:9:2 Encontrado "para" tem esperado "por ponto e vírgula ';' . "

[Bloco: Comando leia] - [Erro Sintático]: o comando leia deve ser

finalizado com o ‘;’ que não foi encontrado antes da palavra “para”;

• Linha:10:3 Encontrado "n" tem esperado "faca." [Bloco: Estrutura de

Repetição - para...faca] - [Erro Sintático]: o comando de repetição “para

faca” exige a palavra reservada “faca”. Nesse exemplo, iniciou uma

atribuição antes mesmo de completar a estrutura de repetição;

• Linha:10:8 Inviável ";" nessa posição. Verifique se foi erro de digitação

ou se é mesmo atribuição. Sintaxe: var<-expressao; [Bloco: Corpo de

Atribuição] - [Erro Sintático]: Esse é um erro difícil de definir. Nesse

caso foi encontrado o ‘;’ mas a expressão está incompleta, pois após o

sinal “+” não foi encontrado nenhum caracter válido para a expressão.

• Linha:11:1 Encontrado "fim" tem esperado "fim_para." [Bloco:

Estrutura de Repetição - para...faca] - [Erro Sintático]: foi encontrado o

“fim” do algoritmo antes de fechar a estrutura de repetição com o

“fim_para”.

A função Verificar apenas faz a validação sintática de acordo com as regras

estabelecidas. Por exemplo, na Figura 32 mostrada anteriormente, na linha 8 temos o

comando de leitura e a variável “n”. O erro apresentado na linha 9 foi a falta do ‘;’ no

final do comando da linha 8, mas em nenhum momento foi questionado se a variável

“n” foi declarada, qual seu tipo de dado, se foi inicializada. Esses testes fazem parte da

análise semântica, que verifica todas as incoerências que compõem erro de execução, e

não mais de compilação. Sintaticamente, o comando de entrada de dados é composto da

68

palavra reservada “leia” (nomevariavel); e este requisito foi verificado, não validando o

tipo de dado, valor e todas as especificações feitas na execução de um código.

O Quadro 13 mostra o código utilizado para fazer essa verificação, a partir das

classes geradas através do ANTLRWorks com o arquivo de gramática Portugol.g.

Quadro 13 – Código verificar algoritmo /** * Responsável por verificar se sintaticamente o código digitado está * correto , de acordo com o arquivo de gramática definido . * * @param codigo * @param acao - para saber se o método foi chamado em "Verificar Código " ou * em "Executar " ( - 1 é nulo , não vai mostrar a msg de "Codigo verificado com sucesso ") * @return * @throws AlgException */ @SuppressWarnings ( "static-access" ) @Override public programa_return verifify(String codigo, int acao) throws AlgException { /*Análise Léxica e Sintática */ /*Criar um obj da classe Lexer passando o código di gitado*/ _lexico = new PortugolLexer( new ANTLRStringStream(codigo)); /*Criar um obj da classe de Token a partir da class e Lexer*/ _tokens = new CommonTokenStream( _lexico ); /*Cria um obj da classe Parser a partir dos token recuperados*/ _parser = new PortugolParser( _tokens ); /*Obtém o retono do método "programa", que marca o início da verificação*/ PortugolParser.programa_return retorno = null; try { retorno = _parser .programa(); /*Obtém os erros encontrados e repassa essa lista d e erro para * a InterpretadorController*/ ArrayList<String> erros = new ArrayList<String>(); /*Erros léxicos*/ if(! _lexico .getErrorsLexicos().isEmpty()){ erros.addAll( _lexico .getErrorsLexicos()); } /*Erros sintáticos*/ if(! _parser .getErrorsSintaticos().isEmpty()){ erros.addAll( _parser .getErrorsSintaticos()); } _listener .findErrors(erros, acao, _listener . _ERRO); /*Atualiza o contador de erros léxicos/sintáticos*/ _contErrosLexSint = _parser .getErrorsSintaticos().size() +

69

_lexico .getErrorsLexicos().size(); } catch (RecognitionException e) { e.printStackTrace(); throw new AlgException( "Erro em verificar o código." ); } return retorno; } Fonte: Elaborado pela autora (2010)

Após executado esse código, a classe InterpretadorFrame (classe visual do

interpretador) é notificada se encontrou erros ou não, e se sim, estes serão apresentados

ao usuário. Caso contrário, será mostrada a mensagem da Figura 30. Essa mensagem só

é mostrada quando o usuário clica na opção Verificar e não quando essa opção é

chamada através de outra, como por exemplo, Executar, pois após a verificação do

código, se não encontrou erros, inicia a validação semântica.

Uma vez o código verificado, o próximo passo é executá-lo, que será abordado

na próxima seção.

5.3.2 Executando o algoritmo

Quando não mais existem incoerências sintáticas no código, o próximo passo é

executá-lo, que é a fase mais importante do interpretador. Para execução é criado o

ASem, que será mais detalhado na seção 6.3.

A Figura 33 mostra a opção de Executar o algoritmo habilitada.

Fig. 33 – Opção Executar algoritmo. Fonte: Elaborada pela autora (2010)

Para executar o código é preciso que o passo de verificar o algoritmo tenha

realizado com sucesso. Não é necessário clicar na opção Verificar, quando escolher

Executar, automaticamente o interpretador chama a opção Verificar e tenta executá-la.

70

Só depois de ter analisado o código e não encontrar nenhum erro léxico e/ou sintático é

que dará início a análise semântica.

Os erros encontrados nessa fase são os erros de execução, chamados de erros

semânticos.

Para executar um código não se usa mais as classes léxica e sintática geradas

pelo ANTLRWorks, mas assim a AST criada a partir da análise sintática. Essa árvore

será percorrida top-dow e a cada nó será analisado e adicionado uma função semântica,

de acordo com a classe de comando a que pertencer, para gerar um resultado. Através

dessa função semântica é que será possível a simulação da execução sem gerar o código

executável.

No apêndice 2 será apresentado o diagrama de classe das classes envolvidas na

análise semântica, divido em 3 partes.

A tabela de símbolo tem fundamental importância nessa análise, pois é nela que

se verifica o tipo de dado das variáveis, se foi inicializada ou não, seu valor. Não é

possível utilizar uma variável no código se ela não foi declarada, esse é um dos mais

comuns erros semânticos, conforme pode ser visto na Figura 34.

Fig. 34 – Tela algoritmo executado com erros semânticos. Fonte: Elaborado pela autora (2010)

71

O padrão da mensagem de erro apresentada na aba “Erro(s)” é o mesmo da

análise sintática. O usuário verificou a falta da declaração da variável “nome” e a

declarou como tipo literal. A interação com o usuário é através do comando “leia” onde

o usuário entra com um valor para uma variável, conforme a Figura 35.

Fig. 35 – Tela Entrada de dados. Fonte: Elaborada pela autora (2010)

Na Figura 35 o usuário digitou o valor e clicou em Ok. Ainda seguindo o

exemplo do código da Figura 34, foi apresentada no console a saída do algoritmo

executado com sucesso, como ilustrado na Figura 36.

Fig. 36 – Tela console leitura executada com sucesso. Fonte: Elaborada pela autora (2010)

Se no exemplo da Figura 35 o usuário clicasse na opção Cancelar, uma

mensagem seria informada no console, indicando que o usuário é que cancelou a leitura

de dados. A Figura 37 mostra essa mensagem.

Fig. 37 – Tela console leitura abortada. Fonte: Elaborada pela autora (2010)

Conforme pode ser verificado nas Figuras 36 e 37, o console tem um padrão de

cores para as mensagens. O valor do comando “escreva” é representado pela cor azul, a

leitura de dados que é o valor que o usuário digitou através da execução do comando

“leia” é em verde e mensagens de erros, como o cancelamento de entrada de dados é em

vermelho.

72

A verificação dos erros da análise semântica criada para o interpretador

JPortugol foi dividida em duas fases.

Primeiro foi feita uma varredura na AST e se verificou todas as incoerências que

podem ser tratadas sem depender de um valor digitado pelo usuário, como por exemplo:

variável usada que não foi declarada, variável usada em uma expressão sem ser

inicializada, índice de vetor utilizado maior do que o eu foi declarado etc.

A Figura 38 mostra um exemplo desses erros citados.

Fig. 38 – Tela código com erros semânticos 1ª fase. Fonte: Elaborada pela autora (2010)

73

Como pode ser visto nessa primeira fase os erros são encontrados, mas a análise

não é interrompida, continua até o fim da AST. Todos os erros encontrados são

guardados e só no final da varredura é que são apresentados ao usuário na aba “Erro(s)”.

Nessa fase não são utilizados valores de expressão para verificar o erro, somente o tipo

de dado e o valor do mesmo, desde que para chegar a esse valor não precisa resolver

uma expressão. Os erros encontrados na Figura 38 são:

• Linha:13:6 Variável "i" não é do tipo "inteiro" esperado. [Bloco: Estrutura de

Repetição - para...faca] - [Erro Semântico]

A variável “i” usada na estrutura de repetição foi declarada com real, mas a

variável controladora da estrutura é obrigatoriamente do tipo inteiro.

• Linha:14:9 Variável "i" não foi inicializada. [Bloco: Comando leia] - [Erro

Semântico]

Como ocorreu o erro na linha 13 com a variável “i”, ela não foi inicializa e não é

possível utilizar uma variável que não contenha valor atribuído.

• Linha:14:9 Variável "i" inválida para índice de vetor/matriz. Somente é aceito

tipo de dado "inteiro". [Bloco: Comando leia] - [Erro Semântico]

Índice de vetor/matriz só aceita valor inteiro e a variável “i” foi declarada do

tipo real.

• Linha:15:4 Variável "a" não foi inicializada. [Bloco: Corpo de Atribuição] -

[Erro Semântico]

Está tentando atribuir em uma variável uma variável que ainda na foi

inicializada.

• Linha:15:8 Variável "i" não foi inicializada. [Bloco: Corpo de Atribuição] -

[Erro Semântico]

O mesmo da Linha:14:9.

• Linha:15:8 Variável "i" não é do tipo "inteiro" esperado. [Bloco: Corpo de

Atribuição] - [Erro Semântico]

74

Está tentando atribuir o valor de “i” que é do tipo real em uma variável do tipo

inteiro “a”. O inverso é possível.

• Linha:17:42 Índice "7" do vetor "n" maior que a dimensão "5" declarada.

[Bloco: Comando escreva] - [Erro Semântico]

Está querendo mostrar o valor do vetor na posição 7, sendo que o tamanho do

vetor declarado é menor que 7.

Verificando o último erro apresentado, pode surgir uma dúvida, pois no bloco de

repetição do comando “para..faca” o valor final é 7, e está sendo utilizado esse valor

como índice do vetor a ser lido a não apontou erro. Aqui entra a segunda fase da análise

semântica.

A Figura 39 apresenta o código do algoritmo modificado dos erros apresentados

na Figura 38.

Fig. 39 – Tela código com erros semânticos 2ª fase. Fonte: Elaborada pela autora (2010)

75

Uma vez corrigidos os erros, é possível iniciar a execução do algoritmo

novamente. Nenhum erro foi apresentado e a tela de entrada de dados foi apresentada ao

usuário para leitura do vetor n até a posição 5. Quando a variável “i” recebeu o valor 6,

foi apresentada uma mensagem de erro no console e a execução do algoritmo parou.

Esse erro é semântico em tempo de execução e não mais será apresentado na aba

“Erro(s)” e sim no console, pois agora assim que um erro for encontrado é interrompido

o algoritmo. O erro apresentado no console pode ser visto na Figura 40.

Fig. 40 – Tela console erro semântico em tempo de execução. Fonte: Elaborada pela autora (2010)

Assim que a execução é interrompida é possível através da mensagem de erro

corrigir o algoritmo, apenas substituindo o valor 7 nos dois blocos de repetição para o

valor 5, que é o tamanho máximo do vetor declarado. Feito isso o algoritmo é executado

sem nenhum erro, conforme a saída que poderá ser visualizada na Figura 41.

Fig. 41 – Tela console execução semântica com sucesso. Fonte: Elaborada pela autora (2010)

O interpretador JPortugol conseguiu através das 3 análises desenvolvidas, da

AST e da tabela de símbolos simular a execução do código sem necessidade de criar um

código objeto. Essa simulação é apresentada no console e através da tela de entrada de

dados, onde o usuário digita valores. A Tabela 8 apresenta os erros semânticos

validados nas duas fases desenvolvidas.

76

Tabela 8 – Erros semânticos

Fonte: Elaborada pela autora, baseada em Delamaro (2004)

Além dos erros semânticos, nessa análise é possível encontrar warnings, que são

alertas apresentados ao usuário, mas não impede a execução do algoritmo. Para a

ferramenta JPortugol o alerta verificado foi a declaração de variável que não foi

utilizada em nenhuma parte do código do algoritmo. Esta é informada na mesma aba de

“Erro(s)” só alterada o nome para “Alerta(s)” quando encontrou um alerta, mas nenhum

erro ou “Erros(s)/Alerta(s)”, quando além do alerta também foi encontrado algum erro.

Finalizando a metodologia da execução do código do algoritmo, a próxima seção

mostrará como executar passo a passo o algoritmo.

Descrição do Erro Fase 1 Fase 2 Variável usada que não foi declarada. x Variável redeclarada. x Variável não inicializada sendo usada em uma expressão. x Índice de vetor inválido (menor ou maior) x Linha ou coluna de matriz inválida (menor ou maior) x Resultado para índice de vetor inválido (menor ou maior) x Resultado para linha/coluna inválida (menor ou maior) x Atribuição de valor à constante/variável de tipo de dado diferente do que é esperado.

x x

Variável controladora da estrutura para..faça diferente do tipo de dado inteiro.

x

Resultado da expressão que determina valor de início e/ou fim da estrutura para..faça diferente do tipo de dado inteiro.

X

Operação com tipos de dados incompatíveis. x Operador inválido para tipo de dado. x Variável inválida para ser índice de vetor, não é do tipo inteiro esperado.

x

Variável inválida para ser linha/coluna de matriz, não é do tipo inteiro esperado.

x

Comando “pare” usado fora de estrutura de repetição. x Função não pode ser atribuída para tipo de dado declarado para a variável usada na atribuição.

x

Valor digitado pelo usuário não é do tipo de dado esperado. X Acesso a um índice de vetor existente, mas sem valor atribuído. X Acesso a uma linha/coluna da matriz existente, mas sem valor atribuído.

X

Resultado da expressão não pode ser atribuído a um tipo de dado. Ex: resultado real e variável do tipo inteiro.

X

Resultado da expressão inválida, exemplo: divisão por zero. X

77

5.3.3 Executando o algoritmo passo a passo

Outra maneira de executar um algoritmo é passo a passo, isto é, a execução

ocorre linha a linha e esta é selecionada no código para visualização do usuário.

A Figura 42 mostra a opção de Executar o algoritmo passo a passo habilitada.

Fig. 42 – Opção Executar passo a passo o algoritmo. Fonte: Elaborada pela autora (2010)

A execução passo a passo funciona seguindo tudo já descrito na seção 5.3.2.

Executando o algoritmo, com a única diferença que para executar a próxima linha, o

usuário deve clicar no botão Próximo Passo ou através da tecla de atalho F5, que só será

habilitada após iniciar a execução passo a passo. Sem essa interação do usuário, a

execução fica parada, aguardando o comando para ir para a próxima linha.

A Figura 43 mostra um código de algoritmo sendo executado passo a passo.

78

Fig. 43 – Tela de execução passo a passo. Fonte: Elaborada pela autora (2010)

Como pode ser vista na Figura 43, a linha do código que está sendo executada

fica selecionada de cor diferente, além de aparecer outra tela, que representa a área de

memória do computador. Nessa área, serão criadas as variáveis, caso tenham sido

declaradas no algoritmo. No momento de sua criação, elas aparecem sem valor e

somente com a entrada de dados pelo usuário, através do comando “leia” ou uma

atribuição é que seu valor será alterado.

Na Figura 44, o usuário já entrou com os dois valores pedidos no algoritmo e a

área de memória foi atualizada.

79

Fig. 44 – Tela alteração na área de memória na execução passo a passo. Fonte: Elaborada pela autora (2010)

No exemplo da Figura 44, os dois valores digitados pelo usuário são os números

7 e 4, respectivamente, como podem ser visto na Aba Console. Caso o usuário tivesse

digitado um valor inválido, a execução seria interrompida e uma mensagem de erro

seria apresentada no Console para o usuário, conforme pode ser vista na Figura 45, da

mesma maneira que na execução de modo normal.

80

Fig. 45 – Tela de erro semântico na execução passo a passo. Fonte: Elaborada pela autora (2010)

Finalizando a execução passo a passo, a próxima seção mostrará como

interromper um algoritmo durante sua execução.

5.3.4 Parando a execução do algoritmo

Uma vez o código em execução, sendo pelo método normal ou passo a passo, é

possível a qualquer momento interrompê-lo. A Figura 46 mostra a opção Parar

Execução habilitada, na barra rápida de funções.

Fig. 46 – Tela opção parar execução. Fonte: Elaborada pela autora (2010)

81

Uma vez que o usuário acessou a função de executar o código, somente poderá

pará-lo e as outras funções referentes ao algoritmo ficam desabilitadas. A Figura 47

mostra as opções já atualizadas após a execução do algoritmo ou parado pelo usuário.

Fig. 47 – Tela opções iniciais do algoritmo. Fonte: Elaborada pela autora (2010)

A função Parar Execução somente cancela a execução do algoritmo e volta ao

menu Algoritmos para o estado inicial, podendo verificá-lo novamente, executá-lo ou

qualquer outra ação referente às funções disponíveis no interpretador.

82

6 DISCUSSÃO DOS RESULTADOS

Este capítulo retoma os objetivos do projeto para discutir os resultados

encontrados, a partir do que foi definido e estipulado para cumprir as metas propostas.

O arquivo de gramática que será mencionado nas seções deste capítulo se refere ao

Portugol.g, criado através da ferramenta ANTLRWorks e que será demonstrado no

Apêndice 1.

Para demonstrar o resultado e a interação de cada fase de um interpretador, cada

seção dará continuidade no mesmo exemplo, aqui será o cálculo do fatorial de um

número qualquer digitado pelo usuário.

6.1 Desenvolvimento do analisador léxico

O AL é a primeira fase do interpretador que foi desenvolvida com o auxílio do

ANTLR.

Lembrando sua função, o AL lê uma sequência de caracteres digitados e de

acordo com a gramática da linguagem de programação, coleta os tokens que constituem

o programa. Um token não reconhecido deve ser informado como erro. (Price, 2001).

Através do arquivo Portugol.g, foram estabelecidas regras, isto é, tudo o que é

possível na linguagem portugol utilizada neste projeto. Diante disso, fica fácil descobrir

os erros, pois é tudo que foge do que foi pré-estabelecido.

O erro encontrado nessa fase é chamado de erro léxico e caracteriza-se por

encontrar algum caracter no código de algoritmo digitado pelo usuário que não foi

definido para a linguagem utilizada.

Para ilustrar o AL do interpretador JPortugol, vale lembrar a regra léxica para

IDENTIFICADOR: obrigatoriamente inicia por underline “_” ou uma letra minúscula e

pode vir seguida por uma letra minúscula, um underline ou um número inteiro,

nenhuma ou várias vezes, que foi ilustrada no Quadro 3. A Figura 48 apresenta a

83

execução do AL através da verificação do código de um algoritmo, para o exemplo

citado na apresentação deste capítulo.

Fig. 48 – Tela execução do AL do cálculo fatorial. Fonte: Elaborada pela autora (2010)

Na aba “Erro(s)” é possível visualizar todos os erros encontrados e a

identificação do tipo de erro. Clicando em uma linha dessa aba, será selecionada no

código digitado, a linha que contém o erro, de cor diferenciada para melhor

compreensão.

Pode-se concluir que o desenvolvimento do AL foi realizado com sucesso. Os

caracteres inválidos para a linguagem são informados e não é possível executar o

algoritmo com erros, até que sejam solucionados. O desafio do AL, que é verificar o

token de acordo com a categoria onde se encontra, também foi concretizado. Como

pode ser vista na Figura 48, o AL não detectou erro na linha 15, pois o caracter “@”

inválido para a linguagem encontra-se em um bloco de comentário, e para comentário

todos os caracteres são possíveis. O mesmo ocorre na linha 16, onde o caracter se

encontra entre aspas, sinalizando que é um tipo de dado literal, e a regra para o literal

permite qualquer caracter entre aspas duplas, exceto quebra de linha.

Discutido o resultado do AL, a próxima seção dará continuidade ao exemplo do

fatorial na segunda fase do interpretador, a análise sintática.

84

6.2 Desenvolvimento do analisador sintático

Após analisar se os tokens fazem parte da linguagem, o próximo passo é

desenvolver um AS.

Para Price (2001), a função do AS é verificar se as construções usadas estão

gramaticamente corretas, como por exemplo, se a declaração de uma variável

corresponde às especificações definidas. Os analisadores sintáticos devem continuar

analisando o código fonte até o fim, mesmo que encontre algum erro.

Em outras palavras, a análise sintática verifica se o código está sintaticamente

correto, se a ordem em que os tokens aparecem forma uma regra válida, conforme a

especificação da linguagem.

Os erros encontrados nessa fase são os erros sintáticos, constituem erros de

compilação, pois não é possível compilar um código que esteja escrito de forma

incorreta.

Para ilustrar o AS do interpretador JPortugol será mostrada na Figura 49 a

verificação do código, para o exemplo do fatorial.

85

Fig. 49 - Tela execução do AS do cálculo fatorial. Fonte: Elaborada pela autora (2010)

Lembrando que o AL e o AS trabalham em conjunto, o AS é executado mesmo

que encontre algum erro léxico, e este é informado ao usuário. Da mesma maneira que

ocorre na análise léxica, a aba “Erros” apresenta todos os erros encontrados, a

identificação do tipo de erro e nessa fase, o bloco em que ocorreu o erro, como por

exemplo: na declaração de variável, na leitura de um dado, na escrita para o usuário etc.

Nesse pequeno código de algoritmo podem-se observar vários erros que

ocorrem normalmente:

1. Linha: 10:1 Inviável "inicio" nessa posição. Sintaxe: nomevar: tipo; [Bloco:

Declaração de Variáveis] - [Erro Sintático]

Esse erro informa que a palavra reservada “inicio” não é esperada nessa posição,

pois foi encontrado um bloco de declaração de variáveis incompleto, depois dos

“:” espera-se o tipo de dado da variável, que pode ser inteiro, real, lógico ou

literal.

86

2. Linha: 13:7 Encontrado "n" tem esperado "por '(' . " [Bloco: Comando leia] -

[Erro Sintático]

Esse erro informa que o comando leia está incompleto. Foi encontrado nome da

variável onde será armazenado o valor antes mesmo de abrir os parênteses.

3. Linha: 14:2 Inviável "fat" nessa posição. Verifique se foi erro de digitação ou se

é mesmo atribuição. Sintaxe: var<-expressao; [Bloco: Corpo de Atribuição] -

[Erro Sintático]

Analisando o código, é notável que nessa posição encontra-se uma atribuição,

porém o sinal de atribuição é “<-“, e foi digitado errado “<”. A mensagem alerta

para possível erro de digitação através da digitação de uma palavra reservada

escrita incorreta ou uma atribuição inválida.

4. Linha: 16:3 Inviável "escreva" nessa posição. Sintaxe: para var de inicio ate n

(passo +ou- ninteiro) faca //comandos; fim_para; [Bloco: Estrutura de Repetição

- para...faca] - [Erro Sintático]

O comando “escreva” foi encontrado antes mesmo de finalizar o bloco inicial d

comando de repetição “para..faca”, onde depois da variável ou valor final, pode

ou não ter o comando “passo”, mas é obrigatório a palavra reservada “faca”

antes da lista de comandos que será executada.

5. Linha: 17:2 Inviável "fimpara" nessa posição. Verifique se foi erro de digitação

ou se é mesmo atribuição. Sintaxe: var<-expressao; [Bloco: Corpo de

Atribuição] - [Erro Sintático]

Aqui, informa que é inválido “fimpara” na posição. Na verdade, não se trata de

uma atribuição, mas de um comando grafado incorretamente. O certo é

“fim_para”. O AS alerta para possível erro de digitação, pois se trata de um

identificador, mas ao mesmo tempo, para erro de atribuição, por esse

identificador poder ser o nome de uma variável.

6. Linha: 19:1 Encontrado "fim" tem esperado "fim_para." [Bloco: Estrutura de

Repetição - para...faca] - [Erro Sintático]

Erro informa que foi encontrado o “fim” do programa antes mesmo de encerrar o

bloco de repetição “para...faça” com seu respectivo “fim_para”.

87

Certamente, foram apresentados somente alguns erros de sintaxe para ilustrar as

funções do AS através do exemplo, mas tudo que foge à ordem do comando escrito na

linguagem definida o arquivo de gramática, constitui um erro sintático.

Mais uma etapa concluída, pois o AS desenvolvido para a ferramenta JPortugol

é capaz de varrer o código do algoritmo e verificar as incoerências sintáticas, além de

continuar executando após encontrar o primeiro erro. As mensagens informadas ao

usuário são todas em português, tentando chegar bem próxima do que é conhecido do

iniciante, através de dicas de sintaxe.

Finalizando a análise sintática, a próxima seção abordará a análise semântica.

6.3 Desenvolvimento do analisador semântico

Terceira e última fase desenvolvida para a construção do interpretador. É a

simulação da execução. Nesta fase, verificam-se os erros que não compõem erros de

compilação, como por exemplo, nome de variáveis sendo declarados mais de uma vez,

valores atribuídos para um tipo de dado incompatível, divisão por zero etc.

O AS verifica somente as incoerências sintáticas, não é capaz de verificar as

variáveis, o tipo de dado e seu valor. Esta é a função do ASem, que faz sua análise

através da AST em conjunto com a tabela de símbolos.

Os erros encontrados são chamados de erros semânticos, que são os erros em

tempo de execução.

Dando continuidade ao exemplo do código para calcular o fatorial, a Figura 50

ilustra a execução do código através da ferramenta JPortugol, apresentando os erros

semânticos.

88

Fig. 50 – Tela execução do ASem cálculo fatorial com erros. Fonte: Elaborada pela autora (2010)

Para executar um código, não pode haver erros léxicos e nem sintáticos.

Primeiro foi feito uma análise em todos os nós da AST para verificar as incoerências

possíveis de descobrir sem executar cálculo.

Pode-se observar 05 erros semânticos e um alerta só de fazer uma varredura na

AST e comparar com o que tem armazenado na tabela de símbolos.

Da mesma forma das análises anteriores, clicando em uma linha da aba “Erros”

ou “Erros/Informação”, a linha no código é selecionada.

O primeiro item que aparece na aba é um alerta: Linha:9:5 Variável "c"

declarada, mas não foi utilizada. [Alerta]. O ASem deve ser capaz de informar ao

usuário caso for declarada alguma variável que não foi utilizada em nenhum bloco do

algoritmo, para evitar desperdício de memória, porém esses alertas não impedem o

algoritmo de ser executado.

Logo após, são mostrados os erros semânticos encontrados:

89

1. Linha:15:5 Valor "1" não é do tipo "literal" esperado. [Bloco: Corpo de

Atribuição] - [Erro Semântico]: Mensagem informa que o tipo de dado que está

sendo atribuído é do mesmo tipo da variável declarada. Aqui, a variável é do

tipo literal e o valor atribuído do tipo inteiro.

2. Linha:16:7 Variável "i" não declarada. [Bloco: Estrutura de Repetição - para...

faca] - [Erro Semântico]: Mensagem informa que a variável usada para controle

inicial do comando “para..faca” não foi declarada.

3. Linha:16:12 Variável "b" não é do tipo "inteiro" esperado. [Bloco: Estrutura de

Repetição - para...faca] - [Erro Semântico]: Mensagem informa que o valor da

variável para iniciar o bloco “para...faca” não é do tipo inteiro. Aqui, a variável

“b” é do tipo literal.

4. Linha:17:8 Variável "fat" não foi inicializada. [Bloco: Corpo de Atribuição] -

[Erro Semântico]: Mensagem informa que a variável “fat” está sendo usada

numa expressão, porém não existe nenhum valor atribuído a ela, variável não foi

inicializada com nenhum valor.

5. Linha:17:12 Variável "b" não é do tipo "inteiro" esperado. [Bloco: Corpo de

Atribuição] - [Erro Semântico]: Mensagem informa que encontrou uma

expressão de multiplicação da variável “fat” do tipo inteiro com a variável “b”

do tipo literal, sendo atribuída à uma variável do tipo inteiro. Não existe

multiplicação com literal e espera-se um valor inteiro para ser atribuído na

variável “fat”.

Após a análise do erro, percebeu-se que não tinha necessidade da variável “b” do

tipo literal. Algumas modificações foram feitas no código, conforme pode ser vista na

Figura 51.

90

Fig. 51 – Tela execução do ASem cálculo fatorial sem erros. Fonte: Elaborada pela autora (2010)

Sem apresentar erros, somente um alerta, foi possível iniciar a execução do

código. A Figura 52 mostra a primeira interação da ferramenta JPortugol com o usuário,

através do comando “leia”.

Fig. 52 – Tela de interação com o usuário. Fonte: Elaborada pela autora (2010)

O usuário se distraiu, não percebeu o tipo de dado esperado e digitou um literal.

Logo o interpretador informou um erro semântico no console. Conforme a Figura 53, a

execução foi interrompida.

91

Fig. 53 – Tela console erro tipo de dado inválido. Fonte: Elaborada pela autora (2010)

O usuário executa o código novamente, digitando o valor 5 para calcular o

fatorial, mas outro erro foi encontrado, ao calcular uma expressão, conforme a Figura

54.

Fig. 54 – Tela console erro divisão por zero. Fonte: Elaborada pela autora (2010)

Voltando ao código, percebe-se que o valor final da estrutura “para...faca” é

somente o valor armazenado na variável “n” digitada pelo usuário, sendo um erro a

divisão por zero.

Com esse simples exemplo de cálculo de fatorial, vários erros semânticos

comuns de acontecer foram visualizados.

Conclui-se, que o último objetivo específico deste projeto foi realizado com

sucesso, pois o ASem foi capaz de analisar as incoerências semânticas no código de

algoritmo. A próxima seção mostrará o resultado final do interpretador, já com o código

sem erros.

6.4 Desenvolvimento do interpretador

O interpretador de algoritmos foi desenvolvido respeitando as regras do portugol

estabelecidas neste projeto. É possível verificar se um código está sintaticamente correto

92

e simular a sua execução em tempo real, sem geração de executável. Todos os erros

encontrados são informados ao usuário em português, indicando a linha e coluna no

código, além do bloco (para erros sintáticos e semânticos) onde se encontra para auxiliar

na melhor resolução do problema.

A Figura 55 mostra que após ter corrigido todos os erros encontrados, foi

possível a execução do código para o cálculo do fatorial com sucesso.

Fig. 55 – Tela execução final cálculo fatorial. Fonte: Elaborada pela autora (2010)

Pode-se verificar na Figura 56 a aba Alerta, que apenas traz uma informação que

não impede a execução do código.

93

Fig. 56 – Tela aba alerta. Fonte: Elaborada pela autora (2010)

Com isso, conclui-se que o objetivo geral foi alcançado com sucesso e espera-se

que realmente essa alternativa de testes possa melhorar a aprendizagem de algoritmos

dos alunos iniciantes e desenvolver neles, um raciocínio lógico e dedutivo capaz de

descobrir erros apenas de olhar no código, característica marcante de bons

desenvolvedores.

94

7 CONCLUSÃO

O objetivo proposto de desenvolver uma ferramenta interpretadora foi alcançado

em sua totalidade. O ambiente de programação em português estruturado denominado

JPortugol atende aos requisitos da estrutura de um compilador necessária para seu

funcionamento. É possível verificar, sintaticamente, um código como também executá-

lo, tanto no procedimento normal quanto passo a passo. Se houver erros, esses são

apresentados em português em uma linguagem simples, para melhor compreensão do

aluno iniciante em algoritmos.

O resultado é uma união de conhecimentos da disciplina de Compiladores, dos

cursos de Ciências da Computação e Engenharia da Computação, com a linguagem Java

que foi a mais vista durante o Curso de Sistemas de Informação na UNIVÁS, que

representou uma contribuição única para melhorar o aprendizado da disciplina de

algoritmos, problema este, dos três cursos mencionados.

Com isso, os alunos de algoritmos podem se beneficiar de um ambiente de

testes, tornando as aulas de lógica de programação mais atrativas com a teoria sendo

aplicada na prática.

O estudo em compiladores proporcionou um conhecimento bem amplo, no qual

suas teorias podem ser aplicadas em diversas situações, não só para construir com um

interpretador, mas tradutores, reconhecimento de gramática, entre outros.

Como proposta de trabalhos futuros, novas funcionalidades podem ser

implementadas, como a possibilidade de criar procedimentos e funções nos códigos de

algoritmos. Outra sugestão do Dr. Carlos Alberto Ynogut, Professor do Curso de

Mestrado do Instituto Nacional de Telecomunicações (INATEL), onde este projeto foi

apresentado na XXII Encontro de Iniciação Científica e Tecnológica do INATEL, a

implementação de listas e ponteiros utilizados na disciplina Estrutura de Dados.

Finalizando, este projeto espera alcançar sua proposta inicial de incentivar os

alunos na prática de testes de algoritmos, criando ótimos desenvolvedores de softwares,

capazes de compilar o código apenas de olhar no papel.

95

8 REFERÊNCIAS

AHO, Alfred V.; SETHI, Ravi; ULLMAN, Jeffrey D. Compiladores: princípios, técnicas e ferramentas. Tradução Daniel de Ariosto Pinto. Rio de Janeiro: LTC, 1995. ANTLR v3 . Disponível em: http://www.antlr.org. Acesso em: 08 abr. 2010. ANTLRWorks : The ANTLR GUI Development Environment. Disponível em: http://www.antlr.org/works/index.html. Acesso em: 08 abr. 2010. CRISTÓVÃO, Henrique Monteiro. Aprendizagem de Algoritmos num Contexto Significativo e Motivador: Um Relato de Experiência. In.: XVI Workshop de Educação em Computação, XXVIII Congresso da Sociedade Brasileira de Computação, Belém do Pará - Pará, 2008. p. 30-40. Disponível em: http://www.prodepa.gov.br/sbc2008/anais/pdf/arq0123.pdf . Acesso em: 07 abr. 2010. DEITOS, Anderson; NEDEL, Miguel Birck. Projeto Ambap. Disponível em http://www.inf.unisinos.br/~barbosa/paradigmas/consipa3/53/artigos/a19.pdf. Acesso em: 05 mai. 2010. DELAMARO, Márcio Eduardo. Como Construir um Compilador: Utilizando Ferramentas Java. São Paulo: Novatec, 2004. FARRER, Harry et al. Algoritmos Estruturados. 3. ed. Belo Horizonte: LTC, 1999. p. 14-27. HINTERHOLZ JR., Ornélio. Tepequém: uma nova Ferramenta para o Ensino de Algoritmos nos Cursos Superiores em Computação. In.: XVII Workshop de Educação em Computação, XXIX Congresso da Sociedade Brasileira de Computação, Bento Gonçalves – Rio Grande do Sul, 2009. p. 485-488. Disponível em: http://csbc2009.inf.ufrgs.br/anais/pdf/wei/st02_04.pdf. Acesso em: 01 mar. 2010. HOSTINS, Higor. Uma Ferramenta para Apoio a Construção e Teste de Algoritmos. Trabalho de Conclusão de Curso, Programa de Graduação em Ciência da Computação, Universidade do Vale do Itajaí, Itajaí, 2006. HOSTINS, Higor; RAABE, André. Auxiliando a Aprendizagem de Algoritmos com Ferramenta WebPortugol. In.: XV Workshop de Educação em Computação, XXVII Congresso da Sociedade Brasileira de Computação, Rio de Janeiro – Rio de Janeiro, 2007. p. 96-105. Disponível em: http://www.de9.ime.eb.br/~sousamaf/cd/pdf/arq0011.pdf. Acesso em: 07 abr. 2010. MANZANO, José A. N. G.; OLIVEIRA, Jayr F. Estudo dirigido de Algoritmos. 11. ed. São Paulo: Érica, 2007. p.1-18.

96

MARCONI, Marina de Andrade; LAKATOS, Eva Maria. Técnicas de Pesquisa: planejamento e execução de pesquisas, amostragens e técnicas de pesquisa, elaboração, análise e interpretação de dados. 7. ed. – 2. reimpr. São Paulo: Atlas, 2009. Cap. 1, Pesquisa. p. 1-26. MIRANDA, Elisangela M. de. Uma Ferramenta de Apoio ao Processo de Aprendizagem de Algoritmos. Dissertação de Mestrado, Programa de Pós-Graduação em Ciência da Computação, Universidade Federal de Santa Catarina, Florianópolis, 2004. NETO, Carlos de S. S.; GOMES JÚNIOR, Daniel Lima. Compilador UFMA-CP : uma ferramenta de apoio para o ensino básico de lógica de programação. Jornada de Informática do Maranhão, 2008. PARR, Terence. The Definitive ANTLR Reference: Building Domain-Specific Languages. EUA: Pragmatic Programmer, 2007. PESSOA, Marília; KRITZ, Sônia; PAIVA, Leonardo. Construção de algoritmos. Rio de Janeiro: Senac, 2004. p. 23-44. PRICE, Ana M. A.; TOSCANI, Simão S. Implementação de linguagens de programação: Compiladores. 2. ed. Porto Alegre: Sagra Luzzato, 2001 (Série Livros Didáticos 9). RODRIGUES Jr., Methanias C.. Experiências Positivas para o Ensino de Algoritmos. In.: IV ERBASE – IV Escola Regional de Computação Bahia-Sergipe, Feira de Santana - Bahia, 2004. Disponível em: http://www.uefs.br/erbase2004/documentos/weibase/Weibase2004Artigo001.pdf. Acesso em: 07 abr. 2010.

97

APÊNDICES

98

Apêndice 1 – Arquivo de gramática Portugol.g – arquivo que contém todas as regras dos comandos em português estruturado utilizados pelo interpretador JPortugol. grammar Portugol; options { ASTLabelType = CommonTree; output = AST; backtrack = true; } tokens{

PROGRAMA = 'PROGRAMA'; DECL_ALGORITMO = 'DECL_ALGORITMO'; VAR = 'VAR';

VAR_VETOR = 'VAR_VETOR'; VAR_MATRIZ = 'VAR_MATRIZ'; CONST = 'CONST'; ENTRADA = 'ENTRADA'; SAIDA = 'SAIDA'; ATRIB = 'ATRIB'; COMANDO_SE = 'COMANDO_SE';

COMANDO_PARA = 'COMANDO_PARA'; COMANDO_PASSO = 'COMANDO_PASSO'; COMANDO_ENQUANTO = 'COMANDO_ENQUANTO'; COMANDO_REPITA = 'COMANDO_REPITA'; COMANDO_PARE = 'COMANDO_PARE'; FUNCAO_ABS = 'FUNCAO_ABS';

FUNCAO_FRAC ='FUNCAO_FRAC'; FUNCAO_TRUNC = 'FUNCAO_TRUNC'; FUNCAO_RAIZ = 'FUNCAO_RAIZ';

FUNCAO_SEN = 'FUNCAO_SEN'; FUNCAO_COS = 'FUNCAO_COS';

FUNCAO_TAN = 'FUNCAO_TAN'; FUNCAO_MAIUSC = 'FUNCAO_MAIUSC';

FUNCAO_MINUSC = 'FUNCAO_MINUSC'; FUNCAO_COMPR = 'FUNCAO_COMPR';

} // Esse é o package do analisador sintático @parser::header { package edu.univas.tcc.language.parserlexer;

99

} // Este é o package do analisador léxico @lexer::header { package edu.univas.tcc.language.parserlexer; } @lexer::members { public ArrayList<String> _errosLexicos = new ArrayList<String>(); public String getErrorMessage(RecognitionException e, String[] tokenNames) { String msg = super.getErrorMessage(e, tokenNames); int linha = 0; int coluna = 0; if ( e instanceof NoViableAltException ) { NoViableAltException nvae = (NoViableAltException)e; coluna = nvae.charPositionInLine+1; linha = nvae.line; msg= "Linha:" + linha + ":"+coluna + " " + msg.replace("no viable alternative at character", "Caracter"); msg +=" inválido para a linguagem. - [Erro Léxico]"; } _errosLexicos.add(msg); return msg; } public ArrayList<String> getErrorsLexicos() { return _errosLexicos; } } @members { public static final String _BLOCO_DECL_ALG = " [Bloco: Declaração de Algoritmo]"; public static final String _BLOCO_DECL_CONST = " [Bloco: Declaração de Constantes]"; public static final String _BLOCO_DECL_VAR = " [Bloco: Declaração de Variáveis]"; public static final String _BLOCO_CORPO_PROG = " [Bloco: Corpo do Programa]"; public static final String _BLOCO_LEIA = " [Bloco: Comando leia]"; public static final String _BLOCO_ESCREVA = " [Bloco: Comando escreva]"; public static final String _BLOCO_ATRIB = " [Bloco: Corpo de Atribuição]";

100

public static final String _BLOCO_SELECAO_SE = " [Bloco: Estrutura de Seleção - se entao / senao]"; public static final String _BLOCO_REPETICAO_ENQUANTO = " [Bloco: Estrutura de Repetição - enquanto...faca]"; public static final String _BLOCO_REPETICAO_PARA = " [Bloco: Estrutura de Repetição - para...faca]"; public static final String _BLOCO_PASSO = " [Comando passo - Bloco: Estrutura de Repetição - para...faca]"; public static final String _BLOCO_REPETICAO_REPITA = " [Bloco: Estrutura de Repetição - repita...ate]"; public static final String _BLOCO_PARE = " [Comando pare - Bloco: Estrutura de Repetição]" ; public Stack paraphrases = new Stack(); public ArrayList<String> _errosSintaticos = new ArrayList<String>(); public String getErrorMessage(RecognitionException e, String[] tokenNames) { String msg = super.getErrorMessage(e, tokenNames); int linha = e.token.getLine(); int coluna = e.token.getCharPositionInLine() + 1; String paraphrase = null; if(paraphrases.size()>0){ paraphrase = (String)paraphrases.peek(); } if ( e instanceof MismatchedTokenException ) { MismatchedTokenException mte = (MismatchedTokenException)e; msg = "Linha:" + linha + ":"+coluna + " Encontrado \" " +e.token.getText()+" \" tem esperado "+ tokenNames[mte.expecting] + "\""; } else if ( e instanceof NoViableAltException ) { NoViableAltException nvae = (NoViableAltException)e; msg = "Linha:" + linha + ":"+coluna + " Alternativa inviável para \""+ e.token.getText() + "\" "; } else if ( e instanceof EarlyExitException ) { EarlyExitException eee = (EarlyExitException)e; msg = "Linha:" + linha + ":"+coluna + " Loop incompleto. É necessário pelo menos um comando antes de \""+e.token.getText() + "\""; } else if ( e instanceof MismatchedNotSetException ) { MismatchedNotSetException mse = (MismatchedNotSetException)e; msg = "Linha:" + linha + ":"+coluna + " Encontrado "+ e.token.getText()+" esperado por \""+ mse.expecting + "\""; } else if ( e instanceof MismatchedSetException ) { MismatchedSetException mse = (MismatchedSetException)e;

101

msg = "Linha:" + linha + ":"+coluna + " Encontrado "+ e.token.getText()+" esperado por \""+ mse.expecting + "\""; } else if ( e instanceof MismatchedRangeException ) { MismatchedRangeException mre = (MismatchedRangeException)e; msg = "Linha:" + linha + ":"+coluna + " Encontrado "+ e.token.getText()+" esperado na faixa de "+ tokenNames[mre.a]+".."+tokenNames[mre.b]; } else { msg = super.getErrorMessage(e, tokenNames); } if (paraphrase != null){ msg = msg+ " "+paraphrase+ " - [Erro Sintático]"; } _errosSintaticos.add(msg); return msg; } public ArrayList<String> getErrorsSintaticos() { return _errosSintaticos; } } //tokens TIPO_INTEIRO :'inteiro'; TIPO_REAL :'real'; TIPO_LOGICO :'logico'; TIPO_LITERAL :'literal'; ALGORITMO :'algoritmo'; TIPO_CONSTANTE :'constantes'; TIPO_VARIAVEIS :'variaveis'; VETOR :'vetor'; MATRIZ :'matriz'; INICIO :'inicio'; FIM :'fim'; LEIA :'leia'; ESCREVA :'escreva'; SE :'se'; ENTAO :'entao'; SENAO :'senao'; FIM_SE :'fim_se'; ENQUANTO :'enquanto';

102

FACA :'faca'; FIM_ENQUANTO :'fim_enquanto'; PARA :'para'; DE :'de'; PASSO :'passo'; FIM_PARA :'fim_para'; REPITA :'repita'; ATE :'ate'; PARE :'pare'; //funções pré-definidas para inteiros e reais T_ABS :'abs'; T_FRAC :'frac'; T_TRUNC :'trunc'; T_RAIZ :'raiz'; T_SEN :'sen'; T_COS :'cos'; T_TAN :'tan'; //funções pré-definidas para literais T_MAIUSC :'maiusc'; T_MINUSC :'minusc'; T_COMPR :'compr'; ABRE_PARENTESES :'('; FECHA_PARENTESES :')'; ABRE_COLCHETE :'['; FECHA_COLCHETE :']'; PONTO :'.'; PONTO_VIRGULA :';'; VIRGULA :','; DOIS_PONTOS :':'; ATRIBUICAO :'<-'; E :'e'; OU :'ou'; NÃO :'nao'; ADICAO :'+'; SUBTRACAO :'-'; MULTIPLICACAO :'*'; DIVISAO :'/'; RESTO :'resto'; POTENCIACAO :'**'; DIV_INTEIRA :'div';

103

MAIOR :'>'; MENOR :'<'; IGUAL :'='; DIFERENTE :'<>'; MAIOR_IGUAL :'>='; MENOR_IGUAL :'<='; fragment DIGITO :'0'..'9'; fragment LETRA_MIN :'a'..'z'; fragment LETRA_MAI :'A'..'Z'; fragment UNDERLINE :'_'; INTEIRO :DIGITO+; REAL :DIGITO+ | (DIGITO+ '.' (DIGITO)*); LITERAL :'"' (~('\r' | '\n' | '"'))* '"'?; LOGICO :'verdadeiro' | 'falso'; CONSTANTE :(UNDERLINE | LETRA_MAI) (LETRA_MAI | UNDERLINE | INTEIRO )*; IDENTIFICADOR :(UNDERLINE | LETRA_MIN) (LETRA_MIN | UNDERLINE | INTEIRO )*; COMENTARIOS :'//' ~('\n'|'\r')* '\r'? '\n' {$channel=HIDDEN;} |'/*' ( options {greedy=false;} : . )* '*/' {$channel=HIDDEN;}; EB :('p\r\n' | '\r' | '\n' | '\t' | '\f' | ' ') { skip(); }; //Aqui começa a análise sintática programa : declaracao_algoritmo (declaracao_constante)? (declaracao_variavel)? corpo_programa EOF ->^(PROGRAMA declaracao_algoritmo (declaracao_constante)? (declaracao_variavel)? corpo_programa EOF); declaracao_tipo_primitivo :TIPO_INTEIRO | TIPO_REAL |TIPO_LOGICO | TIPO_LITERAL; tipo_dado :INTEIRO | REAL | LOGICO | LITERAL; declaracao_algoritmo @init {paraphrases.push(_BLOCO_DECL_ALG);} @after{paraphrases.pop();} : ALGORITMO IDENTIFICADOR PONTO_VIRGULA ->^(DECL_ALGORITMO ALGORITMO IDENTIFICADOR); declaracao_constante @init {paraphrases.push(_BLOCO_DECL_CONST);} @after{paraphrases.pop();}

104

: TIPO_CONSTANTE (CONSTANTE DOIS_PONTOS declaracao_tipo_primitivo IGUAL tipo_dado PONTO_VIRGULA)+ ->^(CONST CONSTANTE declaracao_tipo_primitivo tipo_dado)+; declaracao_variavel_simples: IDENTIFICADOR (VIRGULA IDENTIFICADOR)* DOIS_PONTOS declaracao_tipo_primitivo -> ^(VAR IDENTIFICADOR declaracao_tipo_primitivo)+; declaracao_vetor:IDENTIFICADOR (VIRGULA IDENTIFICADOR)* DOIS_PONTOS VETOR ABRE_COLCHETE INTEIRO FECHA_COLCHETE DE declaracao_tipo_primitivo -> ^(VAR_VETOR IDENTIFICADOR declaracao_tipo_primitivo INTEIRO)+; declaracao_matriz:IDENTIFICADOR (VIRGULA IDENTIFICADOR)* DOIS_PONTOS MATRIZ ABRE_COLCHETE INTEIRO VIRGULA INTEIRO FECHA_COLCHETE DE declaracao_tipo_primitivo -> ^(VAR_MATRIZ IDENTIFICADOR declaracao_tipo_primitivo INTEIRO INTEIRO)+; declaracao_variavel @init {paraphrases.push(_BLOCO_DECL_VAR);} @after{paraphrases.pop();} : TIPO_VARIAVEIS! ((declaracao_variavel_simples | declaracao_vetor | declaracao_matriz) PONTO_VIRGULA!)+; corpo_programa @init {paraphrases.push(_BLOCO_CORPO_PROG);} @after{paraphrases.pop();} : INICIO lista_comandos FIM PONTO!; lista_comandos: comando+; comando :comando_entrada |comando_saida | comando_atribuicao |comando_se | comando_enquanto |comando_para |comando_repita |comando_pare; indice : (IDENTIFICADOR | INTEIRO) ((ADICAO|SUBTRACAO)^ (IDENTIFICADOR | INTEIRO))?; entradas :IDENTIFICADOR |IDENTIFICADOR^ ABRE_COLCHETE indice FECHA_COLCHETE |IDENTIFICADOR^ ABRE_COLCHETE indice VIRGULA! indice FECHA_COLCHETE; comando_entrada @init {paraphrases.push(_BLOCO_LEIA);} @after{paraphrases.pop();}

105

:LEIA ABRE_PARENTESES (entradas) (VIRGULA (entradas))* FECHA_PARENTESES PONTO_VIRGULA ->^(ENTRADA entradas)+; comando_saida @init {paraphrases.push(_BLOCO_ESCREVA);} @after{paraphrases.pop();} :ESCREVA ABRE_PARENTESES expressao (VIRGULA expressao)* FECHA_PARENTESES PONTO_VIRGULA -> ^(SAIDA expressao (expressao)*); atribuicoes :IDENTIFICADOR ATRIBUICAO expressao PONTO_VIRGULA! |IDENTIFICADOR^ ABRE_COLCHETE indice FECHA_COLCHETE ATRIBUICAO expressao PONTO_VIRGULA! |IDENTIFICADOR^ ABRE_COLCHETE indice VIRGULA! indice FECHA_COLCHETE ATRIBUICAO expressao PONTO_VIRGULA!; comando_atribuicao @init {paraphrases.push(_BLOCO_ATRIB);} @after{paraphrases.pop();} :atribuicoes ->^(ATRIB atribuicoes); comando_se @init {paraphrases.push(_BLOCO_SELECAO_SE);} @after{paraphrases.pop();} : SE expressao_logica ENTAO lista_comandos (SENAO lista_comandos )? FIM_SE PONTO_VIRGULA -> ^(COMANDO_SE SE expressao_logica ENTAO lista_comandos (SENAO lista_comandos)? FIM_SE); comando_enquanto @init {paraphrases.push(_BLOCO_REPETICAO_ENQUANTO);} @after{paraphrases.pop();} : ENQUANTO expressao_logica FACA lista_comandos FIM_ENQUANTO PONTO_VIRGULA -> ^(COMANDO_ENQUANTO ENQUANTO expressao_logica FACA lista_comandos FIM_ENQUANTO); comando_para @init {paraphrases.push(_BLOCO_REPETICAO_PARA);} @after{paraphrases.pop();} : PARA IDENTIFICADOR DE expressao ATE expressao (passo)? FACA lista_comandos FIM_PARA PONTO_VIRGULA -> ^(COMANDO_PARA PARA IDENTIFICADOR expressao expressao (passo)? FACA lista_comandos FIM_PARA); incremento_decremento: ADICAO|SUBTRACAO;

106

passo @init {paraphrases.push(_BLOCO_PASSO);} @after{paraphrases.pop();} :PASSO incremento_decremento INTEIRO-> ^(COMANDO_PASSO incremento_decremento INTEIRO); comando_repita @init {paraphrases.push(_BLOCO_REPETICAO_REPITA);} @after{paraphrases.pop();} : REPITA lista_comandos ATE expressao_logica PONTO_VIRGULA -> ^(COMANDO_REPITA REPITA lista_comandos ATE expressao_logica); comando_pare @init {paraphrases.push(_BLOCO_PARE);} @after{paraphrases.pop();} : PARE PONTO_VIRGULA -> ^(COMANDO_PARE PARE); tipo_dado_funcao_inteiro_real: ((incremento_decremento)? INTEIRO | REAL) | IDENTIFICADOR | CONSTANTE; tipo_dado_funcao_real: ((incremento_decremento)? REAL) | IDENTIFICADOR | CONSTANTE; tipo_dado_funcao_literal: LITERAL | IDENTIFICADOR | CONSTANTE; abs :T_ABS ABRE_PARENTESES tipo_dado_funcao_inteiro_real FECHA_PARENTESES -> ^(FUNCAO_ABS tipo_dado_funcao_inteiro_real ); raiz :T_RAIZ ABRE_PARENTESES tipo_dado_funcao_inteiro_real FECHA_PARENTESES -> ^(FUNCAO_RAIZ tipo_dado_funcao_inteiro_real ); frac :T_FRAC ABRE_PARENTESES tipo_dado_funcao_real FECHA_PARENTESES -> ^(FUNCAO_FRAC tipo_dado_funcao_real); trunc :T_TRUNC ABRE_PARENTESES tipo_dado_funcao_real FECHA_PARENTESES -> ^(FUNCAO_TRUNC tipo_dado_funcao_real); sen :T_SEN ABRE_PARENTESES tipo_dado_funcao_inteiro_real FECHA_PARENTESES -> ^(FUNCAO_SEN tipo_dado_funcao_inteiro_real); cos

107

:T_COS ABRE_PARENTESES tipo_dado_funcao_inteiro_real FECHA_PARENTESES -> ^(FUNCAO_COS tipo_dado_funcao_inteiro_real); tan :T_TAN ABRE_PARENTESES tipo_dado_funcao_inteiro_real FECHA_PARENTESES -> ^(FUNCAO_TAN tipo_dado_funcao_inteiro_real ); maiusc :T_MAIUSC ABRE_PARENTESES tipo_dado_funcao_literal FECHA_PARENTESES -> ^(FUNCAO_MAIUSC tipo_dado_funcao_literal); minusc :T_MINUSC ABRE_PARENTESES tipo_dado_funcao_literal FECHA_PARENTESES -> ^(FUNCAO_MINUSC tipo_dado_funcao_literal); compr :T_COMPR ABRE_PARENTESES tipo_dado_funcao_literal FECHA_PARENTESES -> ^(FUNCAO_COMPR tipo_dado_funcao_literal ); funcoes_definidas : abs | frac | trunc | raiz | sen | cos | tan | maiusc | minusc | compr ; operadores_aritmeticos: MULTIPLICACAO | DIVISAO | RESTO| POTENCIACAO | DIV_INTEIRA; operadores_relacionais: MAIOR | MENOR | IGUAL | DIFERENTE | MAIOR_IGUAL | MENOR_IGUAL; expressao_logica :(ABRE_PARENTESES!) expressao (FECHA_PARENTESES!) ((E | OU) (ABRE_PARENTESES!) expressao (FECHA_PARENTESES!))* |NAO (ABRE_PARENTESES!) expressao (FECHA_PARENTESES!); expressao :numexpr (operadores_relacionais^ numexpr)* |LOGICO; numexpr :termo ((ADICAO^ | SUBTRACAO^) termo)* ; termo :unario (operadores_aritmeticos^ termo)* ; unario :(ADICAO^ | SUBTRACAO^)? fator; tipo_identificador :IDENTIFICADOR | CONSTANTE

108

| IDENTIFICADOR^ ABRE_COLCHETE indice FECHA_COLCHETE | IDENTIFICADOR^ ABRE_COLCHETE indice VIRGULA indice FECHA_COLCHETE ; fator :(tipo_identificador | tipo_dado | funcoes_definidas | (ABRE_PARENTESES!) expressao (FECHA_PARENTESES!)); Informação importante sobre o método getErrorMessage na classe PortugolParser: O método foi alterado, para interagir com a classe MensagemErroSintatico, que trata os erros sintáticos com mensagens mais adequadas a casa exceção. public String getErrorMessage(RecognitionException e, String[] tokenNames) { String msg = super.getErrorMessage(e, tokenNames); int linha = e.token.getLine(); int coluna = e.token.getCharPositionInLine() + 1; String paraphrase = null; if(paraphrases.size()>0){ paraphrase = (String)paraphrases.peek(); } if ( e instanceof MismatchedTokenException ) { MismatchedTokenException mte = (MismatchedTokenException)e; msg = "Linha:" + linha + ":"+coluna + " Encontrado \"" +e.token.getText()+"\" tem esperado \""+ MensagemErroSintatico. exceptionMismatchedTokenException(tokenNames[mte.expecting], this, paraphrase)+"\""; } else if ( e instanceof NoViableAltException ) { NoViableAltException nvae = (NoViableAltException)e; msg = "Linha:" + linha + ":"+coluna + MensagemErroSintatico.exceptionNoViableAltException(e.token.getText(), this, paraphrase); }else if ( e instanceof EarlyExitException ) { EarlyExitException eee = (EarlyExitException)e; msg = "Linha:" + linha + ":"+coluna + MensagemErroSintatico.exceptionEarlyExitException(e.token.getText(), this, paraphrase); } else if ( e instanceof MismatchedNotSetException ) { MismatchedNotSetException mse = (MismatchedNotSetException)e; msg = "Linha:" + linha + ":"+coluna + " Encontrado \""+ e.token.getText()+"\" esperado por "+ mse.expecting; } else if ( e instanceof MismatchedSetException ) { MismatchedSetException mse = (MismatchedSetException)e; String esperado = null; if(mse.expecting != null){ esperado = mse.expecting.toString(); } msg = "Linha:" + linha + ":"+coluna + MensagemErroSintatico.exceptionMismatchedSetException(e.token.getText(), esperado, this, paraphrase); } else if ( e instanceof MismatchedRangeException ) { MismatchedRangeException mre = (MismatchedRangeException)e; msg = "Linha:" + linha + ":"+coluna + " Encontrado \""+ e.token.getText()+"\" esperado na faixa de \""+ tokenNames[mre.a]+".."+tokenNames[mre.b]+"\"";

109

} else { msg = super.getErrorMessage(e, tokenNames); } if (paraphrase != null){ msg = msg+ " "+paraphrase+ " - [Erro Sintático]"; } _errosSintaticos.add(msg); return msg; }

110

Apêndice 2 – Fluxos de evento dos casos de uso específicos do interpretador

Fluxos de eventos em forma de tabela – JPortugol

Nome do Caso de Uso: Verificar Algoritmo Ator Principal: Usuário Atores Secundários: Pré-condições: Estar com a tela do interpretador ativa Pós-condições:

Fluxo Principal Ações do Ator Respostas do Sistema

01 – Cria um arquivo através do Menu Arquivo / Novo, podendo ser vazio ou no padrão Alg, ou através da tecla de atalho Ctrl+N ou ainda pelo clique no 1º botão da barra de opções rápidas. Também possível abrir um código existente, no mesmo Menu Arquivo / Abrir.

02 – Habilita a área de digitação do editor com o arquivo criado no padrão.

03 - Digita o código do algoritmo. 04 – Acessa o menu Algoritmos e clica na opção verificar, ou clica no 3º botão da barra de opções rápidas ou pela tecla de atalho F2.

05 – Verifica a sintaxe do código digitado. 06 – Apresenta o resultado da verificação ao usuário.

07 – Verifica o resultado da verificação.

08 – Espera por uma nova ação do usuário.

Fluxo Alternativo 1 01 - No item 01 do fluxo principal o ator não cria um arquivo e acessa o item 04 do fluxo principal.

02 - Uma mensagem de atenção é informada que precisa de um código para verificar.

03 – Executa o item 01 do fluxo principal. 04 - Retorna ao item seguinte do fluxo principal.

Fluxo Alternativo 2 01 – No item 03 do fluxo principal não digita o código e executa o item 04 do fluxo principal

02 – Executa o item 02 do fluxo alternativo 1.

03 – Digita-se o código. 04 – Retorna ao item seguinte do fluxo principal.

Fluxo Alternativo 3 01 - No item 07 do fluxo principal a aba de erro(s) foi atualizada com erro(s) encontrado(s). Usuário seleciona o erro, analisa e corrige-o(s). 02 – Executa o item 04 do fluxo principal.

03 - Retorna ao item seguinte do fluxo principal.

111


Nome do Caso de Uso: Executar Algoritmo Ator Principal: Usuário Atores Secundários:

Pré-condições: Estar com a tela do interpretador ativa e ter criado o arquivo com o algoritmo ou aberto um código existente.

Pós-condições: Fluxo Principal

Ações do Ator Respostas do Sistema 01 – Acessa o menu Algoritmos e clica na opção Executar, ou clica no 4º botão da barra de opções rápidas ou pela tecla de atalho F3.

02 – Habilita a opção Parar execução e desabilita as demais referentes a verificação e execução. 03 – Inicia a verificação através do item 05 do fluxo principal do caso de uso Verificar Algoritmo. 04 – Inicia a verificação da semântica do código de algoritmo. 05 – Processa o resultado encontrado no item anterior. 06 – Atualiza o console e inicia a interação com o usuário.

07 – Realiza a(s) entrada(s) de dado(s), se não houver, direciona ao item 09 do fluxo principal.

08 – Processa a(s) entrada(s) de dado(s). 09 – Apresenta mensagem de execução com sucesso. 10 – Desabilita a opção parar execução e habilita as demais opções referentes a verificação e execução do algoritmo 11 – Espera por uma nova ação do usuário.

Fluxo Alternativo 1 01 – Assim que executa o item 02 do fluxo principal o usuário clica em Parar execução.

02 - Executa o fluxo principal do caso de uso Parar Execução.

Fluxo Alternativo 2 01 - No item 03 do fluxo principal foi (ram) encontrado(s) erro(s) de sintaxe. Usuário corrige o(s) erro(s). 02 – Executa o item 01 do fluxo principal.


112

Fluxo Alternativo 3 01 – No item 05 do fluxo principal foi (ram) encontrado(s) erro(s) de semântica. Usuário corrige o(s) erro(s). 02 – Executa o item 01 do fluxo principal.


Fluxo Alternativo 4 01 – No item 07 do fluxo usuário digitou uma entrada inválida.

02 – Mensagem de erro é apresentada no console. 03 - Executa o fluxo principal do caso de uso Parar Execução.

04 – Executa o item 01 do fluxo principal. 05 – Retorna ao item seguinte do fluxo principal.


Nome do Caso de Uso: Iniciar Executar Passo a Passo Ator Principal: Usuário Atores Secundários:

Pré-condições: Estar com a tela do interpretador ativa e ter criado o arquivo com o algoritmo ou aberto um código existente.


Ações do Ator Respostas do Sistema 01 – Acessa o menu Algoritmos e clica na opção Iniciar Passo a Passo, ou clica no 5º botão da barra de opções rápidas ou pela tecla de atalho F4.

02 – Habilita as opões Próximo Passo e Parar execução e desabilita as demais referentes a verificação e execução. 03 – Inicia a verificação através do item 05 do fluxo principal do caso de uso Verificar Algoritmo. 04 – Inicia a verificação da semântica da primeira linha do código de algoritmo. 05 – Processa o resultado encontrado no item anterior. 06 – Atualiza o console e a área de memória e inicia a interação com o usuário.


08 – Processa a(s) entrada(s) de dado(s). 09 – Espera pela ação do usuário para

113

executar a próxima linha.











Nome do Caso de Uso: Executar Próximo Passo Ator Principal: Usuário Atores Secundários:

Pré-condições: Ter realizado a ação Iniciar Executar Passo a Passo


Ações do Ator Respostas do Sistema 01 – Acessa o menu Algoritmos e clica na opção Próximo Passo, ou clica no 6º botão da barra de opções rápidas ou pela tecla de atalho F5.

02 – Seleciona no código a próxima linha a ser processada. 03 – Inicia a verificação da semântica da linha selecionada no código de algoritmo. 04 – Processa o resultado encontrado no item anterior.

114

05 – Atualiza o console e a área de memória e inicia a interação com o usuário.


07 – Processa a(s) entrada(s) de dado(s). 08 – Espera pela ação do usuário para executar a próxima linha, caso ainda tenha ou finaliza a execução apresentando mensagem de execução com sucesso. 09 – Desabilita as opções parar execução e próximo passo e habilita as demais opções referentes a verificação e execução do algoritmo 10 – Espera por uma nova ação do usuário.










115


Nome do Caso de Uso: Parar Execução Ator Principal: Usuário Atores Secundários:

Pré-condições: Estar com a tela do interpretador ativa e ter iniciado a execução do algoritmo.


Ações do Ator Respostas do Sistema 01 – Acessa o menu Algoritmos e clica na opção Parar Execução, ou clica no 7º botão da barra de opções rápidas ou pela tecla de atalho F6.

02 – Interrompe a execução 03 – Desabilita a opção parar execução e habilita as demais opções referentes a verificação e execução do algoritmo 04 – Espera por uma nova ação do usuário.

116

Apêndice 3 – Diagramas de classes das classes da análise semântica Interação das classes TabelaSimbolo, TipoSimbolo, Simbolo, SimboloVetor e SimboloMatriz

117

Interação das classes de BI com a semântica de DeclaracaoVariavel, SeEntao, Atribuicao, Escreva e Leia.

118

Interação das classes BI com as estruturas de repetição: ParaFaca, RepitaAte e EnquantoFaca.

119

Apêndice 4 – Questionário sobre a utilização da ferramenta JPortugol Quanto à ergonomia: 1 – O software JPortugol apresenta uma interface amigável? ( ) Sim ( )Não 2 – Os ícones são auto-explicativos? ( ) Sim ( ) Não 3 – As mensagens apresentadas no console e em aba (erro e/ou alerta) estão em uma linguagem de fácil compreensão? ( ) Sim ( ) Não Quanto aos algoritmos desenvolvidos: 1 – A linguagem portugol (português estruturado) varia de um autor para outro. A que foi utilizada gerou dúvidas? ( ) Sim ( ) Não Crítica:______________________________________________________________ 2 – Se ocorreram erros na fase de verificação ou execução, esses foram mais pela: ( ) Sintaxe – utilização de um comando errado (Fase: verificar) ( ) Execução – valores atribuídos incorretos, variáveis usadas que não foram declaradas, etc. (Fase: execução) 3 - Verificação do Código: Poder verificar a sintaxe de um algoritmo, antes de implementá-lo em uma linguagem de programação, fica mais clara a utilização dos comandos e o que a falta de um ‘;’, por exemplo, pode representar? ( ) Indiferente ( )Pouco ( )Muito 4 - Execução do código Poder executar um algoritmo, antes de implementá-lo em uma linguagem de programação, melhora o raciocínio lógico para desenvolver programas mais complexos com testes das várias possibilidades existentes? ( ) Indiferente ( )Pouco ( )Muito Feedback 1 - Quanto à aprendizagem de algoritmos, depois de testar uma ferramenta com essa finalidade, o que prefere: ( ) testar os algoritmos no papel mesmo ( teste de mesa ) ( ) testar o algoritmo através de uma linguagem de programação ( ) testar o algoritmo através de um software. Ex: JPortugol 2 - De um modo geral, a utilização do JPortugol ajudou a evoluir o raciocínio lógico? ( ) Indiferente ( )Pouco ( )Muito

120

O questionário foi aplicado no INPETTECC para alunos do 1º ano do curso de

Técnico em Informática, depois de testarem a ferramenta JPortugol.

Os alunos tiveram informação do funcionamento como também um arquivo de

ajuda sobre a linguagem, disponível na própria ferramenta. Os algoritmos testados

foram para calcular a média de números digitados pelo usuário, fatorial, vetor, entre

outros. Os resultados serão apresentados em forma de gráfico.

Quanto a ergonomia: Questão 1, 2 e 3

Quanto aos algoritmos desenvolvidos: Questão 1 Questão 2

Questão 3 Questão 4

121

Feedback: Questão 1

Questão 2

122

ANEXOS

123

Anexo 1 – Telas do sistema WebPortugol

Acesso on-line da ferramenta WebPortugol, através do site:

http://siaiacad17.univali.br/webportugol/index.html

É necessário fazer um cadastro.

Último acesso de teste: 18/09/2010

125

Anexo 2 – Telas do compilador UFMA-CP v.3.1

UFMA-CP [ Compilador Portugol ] http://www.gia.deinf.ufma.br/cp/index.php - 15/04/2010 17:40 Ajuda Home Instalação

Descrição Compilador desenvolvido por alunos do curso de Ciência da Computação da Universidade federal do Maranhão para programação em portugol (português estruturado) sob orientação do professor Carlos de Salles Soares Neto, com extensão e aprimoramento nas disciplinas de Projeto de compiladores (orientação dos professores Luciano Reis Coutinho e Carlos de Salles Soares Neto) e na disciplina de Tópicos Avançados: Padrões de Projeto(orientação do professor Alexandre Cesar Tavares Vidal). Motivação e objetivo Como passamos por maus bocados (fazendo o portugol na mão), esperamos que esta ferramenta possa ajudar a melhorar o ensino para alunos iniciantes em programação. Requerimentos Como este programa foi feito em Java, é necessário a instalação da maquina virtual (versao 1.5 ou superior). Para isso, basta fazer o download no site oficial da Sun clicando aqui. O que o UFMA-CP faz? Este software realiza análises dos códigos-fonte de acordo com as especificações do português estruturado e ainda faz a tradução do portugol para o C++ e pode ainda gerar o código alvo (.exe) utilizando um compilador de C++ (gcc por exemplo). Downloads Sistema Operacional Download Tamanho Formato Link

• Windows/Linux UFMA-CP (compilador portugol) + Manual 1.234 KB .zip

126

• Windows Versão completa (UFMA-CP + gcc + exemplos + manual) 18.859 KB .zip

• Windows GCC (compilador c++) 17.610 KB

.zip

• Windws/Linux Arquivos Fontes 2.292 KB .zip

• Ver Documentação (JavaDoc)

Desenvolvedores Daniel Lima Gomes Júnior - [email protected] Leandro Sousa Marques - [email protected] Ulysses Santos Sousa - [email protected]

129

Anexo 3 – Telas do projeto AMBAP

Download do Projeto AMBAP

Acesso: Dezembro/2009

http://www.ufal.br/tci/ambap/

131

Anexo 4 – Telas do Portugol Viana v2.3

Download da ferramenta Portugol IDE 2.3


http://www.dei.estt.ipt.pt/portugol/

Versão Atual 2.3 e está em desenvolvimento a 3.0

133

Anexo 5 - Telas do interpretador Hall

Download do interpretador de algoritmos Hall.

Acesso: 06/07/2010

http://www.paim.pro.br/downloads/down.htm

135

Anexo 6 – Telas do interpretador VisuAlg 2.0

Download do programa VisuAlg 2.0 desenvolvido pela empresa Apoio Informática.


http://www.apoioinformatica.inf.br/visualg/setupv2.exe

137

Anexo 7 – Telas do interpretador Happy Portugol 0.5

Disponibilizado no site ALICE – Ambiente Visual para Ensino de Algoritmos, para os

alunos da UNIVALI. Acesso é restrito e o download foi feito através de uma conta de

usuário padrão disponibilizada pelo aluno que está dando continuidade ao projeto

WebPortugol, também do núcleo de desenvolvimento UNIVALI. Acesso:

Dezembro/2009 http://siaiacad17.univali.br/Alice/login.jsp

139

TERMO DE REALIZAÇÃO DE REVISÃO DE LÍNGUA PORTUGUESA

Eu, Cibele Gonzales Lopes professora de Língua Portuguesa, graduada pela

Faculdade de Filosofia, Ciências e Letras Eugênio Pacelli informo ter realizado a

revisão de Língua Portuguesa do Trabalho de Conclusão de Curso da aluna Andréia

Cristina dos Santos Gusmão do curso de Sistemas de Informação da UNIVÁS-Fafiep.

Informo, ainda, que o trabalho encontra-se em conformidade com as normas cultas da

língua.

Pouso Alegre, 16/11/2010

______________________________________________

Assinatura da revisora

140

UNIVERSIDADE DO VALE DO SAPUCAÍ – UNIVAS POUSO ALEGRE MG

COMITÊ DE ÉTICA EM PESQUISA

ACORDO ENTRE AS PARTES ENVOLVIDAS NA PESQUISA

Título do projeto: JPORTUGOL: UMA FERRAMENTA DE AUXÍLIO À

APRENDIZAGEM DE ALGORITMOS.

Caro Diretor,

Estou realizando um projeto universitário e gostaria de convidá-lo a colaborar

com ele, disponibilizando o laboratório de informática do curso de Técnico em

Informática do INPETTECC, onde os alunos do 1º Ano testarão a ferramenta JPortugol.

Seguem abaixo os esclarecimentos necessários:

O objetivo desse projeto é auxiliar na aprendizagem de algoritmos, de forma

prática através de um software interpretador, capaz de executar códigos de algoritmos

escritos em português estruturado. É possível verificar se sintaxicamente o código é

válido como também simular sua execução em modo normal como também passo a

passo, como se fosse um teste de mesa, sendo possível acompanhar a criação das

variáveis e seus valores, caso exista declaração de variável.

É um software que poderá ser utilizado na disciplina de Algoritmos tanto em

cursos técnicos quanto universitário para alunos iniciantes.

A pesquisadora compromete a prestar qualquer tipo de esclarecimento aos

participantes antes e durante o estudo, sempre que for solicitada. É importante ressaltar

que a colaboração com este estudo NÃO resultará em qualquer tipo de despesa ou

prejuízo para o participante, o qual estará ainda contribuindo para a melhoria da

qualidade dos testes de algoritmos.

Os resultados em andamento e finais referentes a esta pesquisa serão divulgados

como trabalho de conclusão de curso (TCC) do curso de Sistemas de Informação da

pesquisadora.

141

UNIVERSIDADE DO VALE DO SAPUCAÍ – UNIVAS POUSO ALEGRE MG

CONSENTIMENTO LIVRE E ESCLARECIDO

De acordo com a descrição da pesquisa e dos compromissos firmados pela

pesquisadora Andréia Cristina dos Santos Gusmão, eu, Elton Rodrigo Silveira de Souza,

RG M-9.236.337 SSP/MG, diretor do INPETTEC,

declaro que os objetivos e detalhes desse estudo foram-me completamente explicados,

conforme seu texto descritivo. Entendendo que não sou obrigado a participar do estudo

e que posso descontinuar minha participação ou de algum aluno envolvido, a qualquer

momento, sem ser em nada prejudicado, assumo aqui minha concordância e assumo

ainda que permito a divulgação de seus resultados da forma acima especificada.

Entretanto, declaro que minha concordância está condicionada aos seguintes requisitos:

a) Anonimamente, isto é, que a divulgação dos resultados seja feita sem mencionar o

nome do participante ( x );

b) Sem anonimato ( );

c) que tenha acesso aos dados coletados ( );

d) que tenha acesso aos produtos finais da análise e da sua interpretação antes de sua

divulgação pública ( );

e) que, caso necessário, minha reação diante dessas interpretações sejam incorporadas

antes de sua divulgação pública ( ).

Pouso Alegre, 16 de Novembro de 2010

____________________________________

Diretor do INPETTECC

jportugol: uma ferramenta de auxÍlio À … · tema compilador. ideia que surgiu no ... conhecer,...

Documents