protÓtipo de uma ferramenta de apoio ao ensino …siaibib01.univali.br/pdf/juliano de souza...
TRANSCRIPT
UNIVERSIDADE DO VALE DO ITAJAÍ
Juliano de Souza Gaspar
PROTÓTIPO DE UMA FERRAMENTA DE APOIO AO ENSINO DE LINGUAGENS LIVRE DE CONTEXTO
São José 2006
JULIANO DE SOUZA GASPAR
PROTÓTIPO DE UMA FERRAMENTA DE APOIO AO ENSINO DE LINGUAGENS LIVRE DE CONTEXTO
Trabalho de Conclusão de Curso apresentado à banca examinadora do Curso de Ciência da Computação na Universidade do Vale do Itajaí - UNIVALI, Centro de Educação São José, como requisito parcial para obtenção do título de Bacharel em Ciência da Computação. Prof. M. Eng. Alessandro Mueller.
São José 2006
JULIANO DE SOUZA GASPAR
PROTÓTIPO DE UMA FERRAMENTA DE APOIO AO
ENSINO DE LINGUAGENS LIVRE DE CONTEXTO
Este Trabalho de Conclusão de Curso foi julgado adequado para obtenção do título de
Bacharel em Ciência da Computação e aprovado pelo Curso de Ciência da Computação, da
Universidade do Vale do Itajaí (SC), Centro de Educação São José.
São José, 14 de Dezembro de 2006.
Apresentada à Banca Examinadora formada pelos professores:
Prof. M.Eng. Alessandro Mueller.
UNIVALI – Campus São José
Orientador
Prof. Esp. Alecir Pedro da Cunha, membro da banca examinadora
Prof. Dr. Márcio Matias, membro da banca examinadora
ii
AGRADECIMENTOS
A DEUS por tudo que me foi proporcionado todos os dias que me levou à conclusão
desta etapa em minha vida;
Ao professor Alessandro Mueller pela amizade, pelo apoio e orientação me auxiliando
na elaboração deste trabalho;
A professora Fernanda Cunha pelo voto de confiança;
Aos professores Alecir Pedro da Cunha e Márcio Matias, membros da banca, pelas
sugestões e reconhecimento;
Ao Celio Melim Júnior, pela compreensão, pelo apoio e pelo voto de confiança
durante toda a minha trajetória universitária.
Aos amigos e colegas pelo apoio e compreensão durante este ano;
A minha família pela força, compreensão e apoio nesta jornada.
iii
RESUMO
A Teoria de Linguagens Formais estabelece a base para a definição de linguagens de
programação e para a construção de compiladores. As Linguagens Formais possuem um
conjunto de formalismos que podem ser utilizados na especificação e no reconhecimento da
estrutura sintática de uma linguagem descrita por uma Gramática Livre de Contexto. As
Gramáticas Livre de Contexto constituem um dispositivo formal gerador de sentenças de uma
Linguagem Livre de Contexto e formam a base para realizar a análise sintática das linguagens
de programação. Tendo em vista os diversos métodos de análise sintática e a exigência de que
as gramáticas satisfaçam determinadas condições para que os algoritmos reconhecedores de
linguagens possam ser aplicados, as Gramáticas Livre de Contexto podem ser transformadas
em gramáticas equivalentes, sem reduzir o seu poder de geração. Este trabalho procura
contribuir para o estudo da Teoria de Linguagens Formais com a construção de um protótipo
de uma ferramenta de apoio ao ensino dos formalismos de Linguagens Livre de Contexto,
permitindo a construção de algoritmos de simplificação e de transformação de Gramáticas
Livre de Contexto e a análise sintática de sentenças a partir da aplicação de reconhecedores
sintáticos. A ferramenta será utilizada na disciplina de Linguagens Formais e Compiladores
dos cursos de Ciência da Computação e Engenharia de Computação da Universidade do Vale
do Itajaí – UNIVALI, campus São José, complementando as discussões promovidas sem sala
de aula e auxiliando na aprendizagem dos formalismos de Linguagens Livre de Contexto.
Palavras Chaves: Linguagem Livre de Contexto, Gramática Livre de Contexto, análise
sintática
iv
ABSTRACT
The Theory of Formal Languages establishes the basis for the definition of programming
languages and for the construction of compilers. The Formal Languages possess a set of
formalism that can be used in the specification and recognition of syntactic structure of a
described language for a Context Free Grammar. The Context Free Grammars constitute a
formal sentence generator device of Context Free Language and form the basis to carry out
the programming languages syntactic analysis. Considering the various methods of syntactic
analysis and the requirement that the grammars satisfy definitive conditions so that the
algorithms recognizers of languages can be applied, the Context Free Grammars can be
transformed into equivalents grammatics, without reducing its power of generation. This work
aims to contribute for the study of Formal Languages Theory with the construction of a
support tool prototype to the education of Context Free Languages formalisms, allowing the
construction of algorithms simplification and the transformation of Context Free Grammars
and syntactic analysis of sentences from the application of syntactic recognizers. The tool will
be used in disciplines such as Formal Languages and Compilers of the courses of Computer
Science and Computer Engineering in Universidade do Vale do Itajaí - UNIVALI, campus
São José, complementing the quarrels promoted without classroom and assisting in the
learning of Context Free Languages formalisms.
v
SUMÁRIO
1 INTRODUÇÃO ........................................................................................... 1
1.1 CONTEXTUALIZAÇÃO ....................................................................................................1
1.2 PROBLEMA ........................................................................................................................3
1.3 OBJETIVOS.........................................................................................................................4
1.3.1 Objetivo geral ...............................................................................................................4
1.3.2 Objetivos específicos....................................................................................................4
1.3.3 Escopo e delimitação do trabalho.................................................................................5
1.4 RESULTADOS ESPERADOS ............................................................................................5
1.5 JUSTIFICATIVA .................................................................................................................5
1.6 ASPECTOS METODOLÓGICOS.......................................................................................6
1.6.1 Metodologia .................................................................................................................6
1.7 ESTRUTURA DO TRABALHO .........................................................................................7
2 O COMPUTADOR NO PROCESSO ENSINO-APRENDIZAGEM .... 8
2.1 APRENDIZAGEM EM AMBIENTES VIRTUALIZADOS...............................................8
2.2 IHC – INTERAÇÃO HUMANO COMPUTADOR ............................................................9
2.3 ERGONOMIA....................................................................................................................10
2.3.1 Usabilidade.................................................................................................................11
2.3.2 Guias e Critérios Ergonômicos para o Desenvolvimento de Interfaces.....................11
3 GRAMÁTICA ........................................................................................... 13
3.1 DEFINIÇÃO DE UMA GRAMÁTICA.............................................................................14
3.2 NOTAÇÃO DE UMA GRAMÁTICA...............................................................................15
3.2.1 Representação Formal de Gramática..........................................................................15
3.2.2 Representação Backus-Naur Form (BNF) .................................................................15
3.2.3 Diagrama de Sintaxe ..................................................................................................16
3.3 HIERARQUIA DAS GRAMÁTICAS...............................................................................17
3.3.3 Gramáticas Livre de Contexto ou Tipo 2 ...................................................................18
3.3.4 Gramáticas Regulares ou Tipo 3 ................................................................................18
3.4 EQUIVALÊNCIA ENTRE GRAMÁTICAS.....................................................................19
3.5 DERIVAÇÃO E REDUÇÃO DE GRAMÁTICAS ...........................................................19
vi
4 GRAMÁTICA LIVRE DE CONTEXTO ............................................... 21
4.1 ÁRVORE DE DERIVAÇÃO.............................................................................................21
4.2 DERIVAÇÃO MAIS À ESQUERDA E MAIS À DIREITA ............................................22
4.3 AMBIGÜIDADE................................................................................................................23
4.4 SIMPLIFICAÇÃO..............................................................................................................23
4.4.1 Símbolos Inúteis .........................................................................................................23
4.4.2 Produções Vazias .......................................................................................................25
4.4.3 Produções Simples .....................................................................................................26
4.4.4 Recursão à Esquerda ..................................................................................................27
4.4.5 Não Determinismo à Esquerda...................................................................................28
4.5 FORMAS NORMAIS ........................................................................................................29
4.5.1 Forma Normal de Chomsky .......................................................................................29
4.5.2 Forma Normal de Greibach........................................................................................30
4.6 AUTÔMATO COM PILHA ..............................................................................................32
4.6.1 Definição Formal de um Autômato com Pilha...........................................................34
4.6.2 Notação gráfica para Autômatos com Pilha ...............................................................35
5 ANÁLISE SINTÁTICA............................................................................ 37
5.1 PARSE ASCENDENTE E DESCENDENTE ....................................................................37
5.2 CONJUNTOS FIRST E FOLLOW .....................................................................................38
5.2.1 First.............................................................................................................................39
5.2.2 Follow.........................................................................................................................39
5.3 CLASSES DE ANALISADORES .....................................................................................39
5.3.1 Analisadores Ascendentes..........................................................................................40 5.3.1.1 Algoritmo Shift-Reduce ....................................................................................................................... 41 5.3.1.2 Analisadores LR................................................................................................................................... 41 5.3.1.3 Analisador SLR(1) ............................................................................................................................... 45 5.3.1.4 Analisador LR(1).................................................................................................................................. 49 5.3.1.5 Analisador LALR(1) ............................................................................................................................ 52 5.3.1.6 Algoritmo Coke-Younger-Kasami ....................................................................................................... 54 5.3.2 Analisadores Descendentes ........................................................................................55 5.3.2.1 Analisador Recursivo ........................................................................................................................... 56 5.3.2.2 Analisador Preditivo LL(1) .................................................................................................................. 57
6 DEFINIÇÕES DO PROJETO................................................................. 62
6.1 ANÁLISE DE REQUISITOS PRELIMINARES ..............................................................62
vii
6.2 DEFINIÇÕES DE PROJETO ............................................................................................63
6.3 CASOS DE USO PRINCIPAIS .........................................................................................64
6.3.1 Caso de Uso 01 – Visualizar Teoria...........................................................................65
6.3.2 Caso de Uso 02 – Abrir Gramática ............................................................................65
6.3.3 Caso de Uso 03 – Realizar Derivações ......................................................................66
6.3.4 Caso de Uso 04 – Realizar Simplificações.................................................................66
6.3.5 Caso de Uso 05 – Converter GLC para FNC .............................................................67
6.3.6 Caso de Uso 06 – Criar Autômato com Pilha ............................................................67
6.3.7 Caso de Uso 07 – Reconhecer Sentença pelo PDA....................................................68
6.3.8 Caso de Uso 08 – Criar Analisador Preditivo LL(1)..................................................69
6.3.9 Caso de Uso 09 – Reconhecer Sentença pelo LL(1) ..................................................69
6.4 REGRAS DE NEGÓCIO ...................................................................................................70
6.5 DIAGRAMAS DE CLASSES............................................................................................71
6.6 PRINCIPAIS INTERFACES DO PROTÓTIPO ...............................................................74
7 CONCLUSÃO ........................................................................................... 77
7.1 RECOMENDAÇÕES FUTURAS .....................................................................................78
REFERÊNCIAS BIBLIOGRÁFICAS ............................................................ 79
viii
1 INTRODUÇÃO
1.1 CONTEXTUALIZAÇÃO
As tecnologias da informação e comunicação vem sendo crescentemente aplicadas à educação
presencial e à distância. Segundo Silva (1998), software aplicativos e educacionais,
multimídias, hipermídias, Internet, videoconferência, teleconferência, Realidade Virtual, são
alguns dos produtos tecnológicos de rápida evolução e complexidade colocados em destaque
na utilização pedagógica.
Neste sentido, segundo Netto (2004, p. 23) os objetivos de ergonomistas e educadores se
assemelham, visto que os primeiros buscam adaptar o trabalho, no caso informatizado, ao ser
humano e os últimos buscam adaptar os meios didáticos para obter satisfação e produtividade
dos alunos na aprendizagem de um conteúdo ou habilidade.
O objeto de estudo deste trabalho, além dos aspectos ergonômicos, são as Linguagens Livre
de Contexto, as quais serão as bases para o desenvolvimento de um protótipo de uma
ferramenta de apoio ao ensino.
A Teoria de Linguagens Formais1 é a base para a definição das linguagens de programação e
para projetos de compiladores. As Linguagens Formais2 possuem um conjunto de
formalismos que podem ser utilizados na especificação e reconhecimento de sentenças de
uma linguagem.
1 É o estudo de modelos matemáticos que possibilitam a especificação e o reconhecimento de linguagens, suas
classificações, estruturas, propriedades, características e inter-relacionamentos (FURTADO, 2006, p. 6). 2 São linguagens que podem ser representadas de maneira finita e precisa através de dispositivos formais ou
modelos matemáticos (FURTADO 2006, p. 5).
2
De acordo com o lingüista Noam Chomsky (1956) apud Menezes(2000, p.153), as linguagens
podem ser classificadas de acordo com seu formalismo, assim, hierarquizadas (Figura 1) em
Linguagens Regulares, Linguagens Livre de Contexto, Linguagens Sensíveis ao Contexto e
Linguagens Enumeráveis Recursivamente ou Irrestritas, em ordem crescente de abrangência e
complexidade.
Figura 1 – Hierarquia Gramatical de Chomsky.
Fonte: Menezes 2000, p. 17
A sintaxe de uma linguagem de programação é normalmente dada pelas regras gramaticais
que a descrevem, de maneira similar à forma como as estruturas léxicas são reconhecidas pelo
analisador léxico com o uso de expressões regulares e autômatos finitos.
Cada linguagem de programação possui regras próprias que descrevem a estrutura sintática de
seus respectivos programas. A sintaxe das construções de uma linguagem de programação
pode ser descrita pelas Gramáticas Livre de Contexto3, formalismo gerador de sentenças de
uma Linguagem Livre de Contexto. Segundo Price (2001, p.30), as Gramáticas Livre de
Contexto, popularizadas pela notação BNF (Backus Naur Form), formam a base para a
análise sintática das linguagens de programação, pois permitem descrever a maioria das
linguagens de programação usadas atualmente.
A análise sintática determina a sintaxe ou estrutura de um programa. Segundo Louden (2004,
p.95), uma Gramática Livre de Contexto utiliza convenções para nomes e operações similares
às usadas por expressões ou definições regulares. A maior diferença é que as regras de uma
Gramática Livre de Contexto são recursivas. Desta forma, as estruturas de dados utilizadas
para representação da sintaxe de uma linguagem, utilizando uma Gramática Livre de
Contexto, precisam ser recursivas. Assim, os algoritmos utilizados para o reconhecimento da
classe de estruturas reconhecíveis por Gramáticas Livre de Contexto utilizam ativações
recursivas ou uma pilha de análise sintática para gerenciar explicitamente a recursividade.
3
1.2 PROBLEMA
Como há diversos métodos de análise sintática4 e cada um deles exige que as gramáticas
atendam características específicas para serem aplicadas no desenvolvimento de algoritmos
para reconhecedores de linguagens e na prova de teoremas, as Gramáticas Livre de Contexto
podem ser transformadas, por meio de algoritmos, para gramáticas equivalentes, geradoras de
sentenças da mesma linguagem. Assim, é possível simplificar certas gramáticas sem reduzir o
poder de geração das Gramáticas Livre de Contexto.
Uma Gramática Livre de Contexto não simplificada pode apresentar símbolos a partir dos
quais nenhuma sentença será reconhecida ou produções que simplesmente substituem um
símbolo por outro e, conseqüentemente, não adicionam qualquer informação de geração de
sentenças e na sua aceitação como uma sentença válida de uma Linguagem Livre de
Contexto.
No entanto, segundo Menezes (2000, p.97), não é qualquer seqüência de simplificações de
uma gramática que permite atingir os resultados desejados. Por exemplo, em uma gramática
sem símbolos inúteis, mas com produções simples, o algoritmo para excluir este tipo de
produção pode gerar símbolos inúteis. Para evitar este problema, caso os algoritmos sejam
combinados, existe uma seqüência de simplificações a ser seguida.
No desenvolvimento de algoritmos como os reconhecedores de linguagens e na prova de
teoremas, as Gramáticas Livre de Contexto usualmente devem estar dispostas nas formas
normais5. Alguns analisadores sintáticos exigem que a gramática seja determinística6 e que
não possua recursão à esquerda. A recursão à esquerda em uma produção ocorre quando um
símbolo produz ele mesmo, de forma direta ou indireta, como o símbolo mais à esquerda de
uma sub-sentença.
3 Gramáticas onde as regras de produções são da forma A produz α, onde A é uma variável não-terminal e α é
sentença formada por terminais e/ou não-terminais, ou ainda pela sentença vazia (RANGEL 2000, p. 2). 4 Destacam-se os algoritmos de Cocke-Younger-Kasami, LL(1), LALR(1) e SLR(1) (Louden 2004, p.95). 5 São formas que estabelecem restrições rígidas na definição das produções sem reduzir o poder de geração da
gramática (Menezes 2000, p.97). 6 Gramáticas sem produções cujo lado direito inicie com o mesmo conjunto de símbolos ou com símbolos que
derivam seqüências que iniciem com o mesmo conjunto de símbolos (Furtado 2006, p.30).
4
O reconhecimento de sentenças de uma Linguagem Livre de Contexto pode ser feito por meio
de Autômatos de Pilha. Um Autômato de Pilha é uma máquina abstrata não-determinística7
semelhante ao Autômato Finito, munido de uma pilha como memória auxiliar para armazenar
símbolos reconhecedores. A facilidade de não-determinismo é importante e necessária porque
aumenta o poder computacional dos Autômatos de Pilha, permitindo reconhecer a classe das
Linguagens Livre de Contexto.
Além dos Autômatos de Pilha, a análise sintática pode envolver a escolha entre diversos
métodos distintos de verificação de sintaxe de uma sentença, cada um apresentando
características e requisitos particulares para a aplicação. Segundo Louden (2004, p.95),
existem duas categorias fundamentais de analisadores sintáticos, os ascendentes e os
descendentes, os quais diferem no modo de realizar o reconhecimento de sentenças de uma
Linguagem Livre de Contexto.
1.3 OBJETIVOS
1.3.1 Objetivo geral
Desenvolver um protótipo de uma ferramenta de apoio ao ensino de Linguagens Livre de
Contexto.
1.3.2 Objetivos específicos
• Pesquisar os formalismos geradores e reconhecedores de sentenças de uma Linguagem
Livre de Contexto;
• Realizar o levantamento dos algoritmos de simplificações e transformações de uma
Gramática Livre de Contexto;
• Pesquisar os algoritmos de análise sintática de sentenças de uma Linguagem Livre de
Contexto;
• Definir os critérios ergonômicos para a construção da interface;
7 Algoritmo reconhecedor de sentenças, incluindo sentenças que possuem mais de uma transição para uma
entrada (Menezes 2000, p.10).
5
• Realizar o design e a implementação do protótipo da ferramenta.
1.3.3 Escopo e delimitação do trabalho
Este trabalho procura contribuir com a elaboração de uma ferramenta que permita a
construção de algoritmos de simplificação e transformação de uma Gramática Livre de
Contexto e realizar a análise sintática de uma determinada sentença a partir de uma gramática
proposta. O reconhecimento de sentenças de uma Linguagem Livre de Contexto será
realizado a partir de Autômatos de Pilha e algoritmos de análise sintática ascendente e
descendente.
Não pertence ao escopo deste trabalho verificar se a gramática a ser simplificada,
transformada ou utilizada na análise sintática é ou não uma Gramática Livre de Contexto.
1.4 RESULTADOS ESPERADOS
• Assistir aos alunos da disciplina de Linguagens Formais e Compiladores no estudo de
formalismos de Linguagens Livre de Contexto;
• Servir de apoio nas disciplinas de Linguagens Formais e Compiladores dos cursos de
Ciência da Computação e Engenharia de Computação da Universidade do Vale do Itajaí –
UNIVALI, campus São José, complementando discussões e exercícios resolvidos em sala
de aula.
1.5 JUSTIFICATIVA
Para certas classes de gramáticas é possível construir automaticamente um analisador
sintático que verifique se determinado programa está sintaticamente correto. Segundo Aho et
al (1995, p.72), “o processo de construção do analisador pode revelar ambigüidades sintáticas
bem como outras construções difíceis de se analisar gramaticalmente, as quais poderiam, de
outra forma, seguir indetectadas na fase de projeto inicial de uma linguagem e de seu
compilador”.
A aplicação de certos algoritmos de análise sintática estabelecem relações sobre a gramática
que descreve a Linguagem Livre de Contexto de um programa. Assim, para que um método
6
em particular possa ser usado na construção de um analisador sintático, a Gramática Livre de
Contexto deve satisfazer determinadas condições. Como exemplos de simplificações que
devem ser feitas nas gramáticas utilizadas por um analisador sintático tem-se: exclusão de
produções vazias, eliminação de símbolos inúteis, eliminar não-determinísmo e eliminar
recursão à esquerda. Outras categorias de algoritmos de análise sintática podem exigir que
suas Gramáticas Livre de Contexto se apresentem em uma forma específica, conhecida como
forma normal.
Este trabalho procura contribuir para o estudo da Teoria de Linguagens Formais, pela
elaboração de uma ferramenta que permita a construção de algoritmos de simplificação e
transformação de uma Gramática Livre de Contexto e a análise sintática de uma determinada
sentença a partir da aplicação de um conjunto de métodos de análise sintática. A ferramenta
será utilizada na disciplina de Linguagens Formais e Compiladores dos cursos de Ciência da
Computação e Engenharia de Computação da Universidade do Vale do Itajaí – UNIVALI,
campus São José, auxiliando a aprendizagem de Linguagens Livre de Contexto.
1.6 ASPECTOS METODOLÓGICOS
1.6.1 Metodologia
Nas áreas tecnológicas a existência de um método aplicável às necessidades de pesquisa e
desenvolvimento é fundamental para a obtenção de novos produtos e processos. Segundo
Jung (2006), “Uma pesquisa que utiliza conhecimentos básicos, tecnologias existentes,
conhecimentos tecnológicos e que tenha como objeto um novo produto ou processo é
caracterizado como tecnológica”. Assim, o trabalho proposto pode ser classificado como uma
pesquisa aplicada e tecnológica, visto que o mesmo propõe o desenvolvimento de uma
ferramenta educacional, que possa auxiliar o processo de ensino aprendizagem da disciplina
de Linguagens Formais e Compiladores.
Tendo em vista que o desenvolvimento deste trabalho não requer o uso de métodos e técnicas
estatísticas como amostragem probabilística, amostragem não-probabilística entre outras, o
mesmo pode ser classificado como uma pesquisa qualitativa. A análise de seus dados será
feita de forma indutiva, fazendo com que o processo e seu significado sejam os focos
principais de abordagem.
7
Considerando os objetivos definidos no trabalho, a pesquisa exploratória foi a que se mostrou
mais adequada para o seu desenvolvimento. Segundo Gil (2002, p.144), a pesquisa
exploratória visa proporcionar maior familiaridade com o problema, visando torná-lo
explícito, ela envolve o levantamento bibliográfico e a análise de exemplos que estimulem a
compreensão. Assume, em geral, as formas de pesquisas bibliográficas e de estudos de caso.
1.7 ESTRUTURA DO TRABALHO
No capítulo 1 é apresentada uma introdução deste Trabalho de Conclusão de Curso,
detalhando o problema proposto, os objetivos gerais e específicos, bem como a metodologia e
plano de trabalho para o desenvolvimento do mesmo.
O capítulo 2 aborda o aprendizado auxiliado por computador, as interações homem-
computador e técnicas e recomendações ergonômicas para otimizar a usabilidade de
softwares.
No capítulo 3 é apresenta a definição de uma gramática, suas formas de representação,
hierarquias, equivalência e as operações de substituição em gramáticas.
O capítulo 4 aborda de forma mais detalhada as Gramáticas Livre de Contexto, apresentando
os conceitos de árvore de derivação e formas de derivação, ambigüidade, simplificações,
Formas Normais e o Autômato de Pilha.
No capítulo 5 é apresentando a definição de parse, conjuntos first e follow, tabelas de análise
sintáticas e as classes de analisadores ascendentes e descendentes.
O capítulo 6 apresenta os critérios ergonômicos, a guia de estilos, os requisitos preliminares,
os casos de usos e as telas da ferramenta proposta.
No capítulo 7 apresenta a conclusão deste trabalho bem como recomendações para trabalhos
futuros.
2 O COMPUTADOR NO PROCESSO ENSINO-APRENDIZAGEM
A informática está propiciando grandes mudanças e flexibilidades no processo de ensino e
aprendizagem. Atualmente, segundo Valente (1993), diversos tipos de abordagens de ensino
podem ser realizadas pelo emprego sistemático da informática, devido aos inúmeros
programas desenvolvidos para auxiliar no processo de aprendizagem.
A idéia do ensino pelo computador permitiu a elaboração de outras abordagens, onde o
computador é usado como ferramenta no auxílio de resolução de problemas, na produção de
textos, na manipulação de dados e no controle de processos em tempo real.
A disseminação de programas educacionais nas escolas, segundo Valente (1993), permitiu
grande produção e uma diversificação dos programas educacionais tais como tutoriais,
programas de demonstração, exercício e prática, avaliação do aprendizado, jogos
educacionais e simulação.
A função educacional é de criar condições de aprendizagem e o computador pode ser
considerado o facilitador do processo de desenvolvimento intelectual do aluno. Com a grande
quantidade de informações que o mundo contemporâneo disponibiliza a todo momento, os
alunos passam a substituir a memorização da informação pela busca e uso da informação.
Essas mudanças podem ser introduzidas através do computador.
2.1 APRENDIZAGEM EM AMBIENTES VIRTUALIZADOS
Com o desenvolvimento dos recursos computacionais é possível integrar textos, imagens de
vídeo, som, animação, assim como a interligação da informação de forma não linear,
implementando o conceito de multimídia e hipermídia. Segundo Silva (1998), com todos os
recursos apresentados, o computador pode ser considerado um dos recursos educacionais
mais efetivos da atualidade.
9
Segundo Lollini (1991), o uso do computador no processo de ensino-aprendizagem apresenta
características psicopedagógicas e técnicas que favorecem o aprendizado. Visto que o
computador é considerado uma máquina que inicia uma situação de aprendizagem sem
oferecer determinados bloqueios característicos dos seres humanos. É uma máquina capaz de
repetir infinitas vezes, e ao mesmo tempo, aceitar perguntas como também atividades na hora
em que o aluno necessitar. Esta máquina não possui respostas emotivas a problemas de
caráter cognitivo8, caracterizando-se como atraente para o aluno.
Segundo Netto (2004, p.22), a otimização dos fatores de aprendizagem nos programas de
ensino com base tecnológicas tende a permitir um melhor aproveitamento das capacidades de
aprendizagem dos estudantes.
2.2 IHC – INTERAÇÃO HUMANO COMPUTADOR
Visando tornar a interação com o usuário mais natural e menos hostil, as interfaces atuais são
constituídas, entre outros itens, por elementos gráficos, onde imagens representam dados e
tarefas disponíveis são manipuladas diretamente pelo usuário.
A Interação Humano Computador, IHC, é uma área que visa essencialmente facilitar a
interação do homem com o computador, com o objetivo de melhorar o seu uso, deixando os
softwares mais amigáveis e mais atrativos.
Segundo Preece (2005, p.29) a interdisciplinaridade mais conhecida é o IHC, que se preocupa
com o design, a avaliação e a implementação de sistemas computacionais interativos para o
uso humano. Assim, muitos projetistas têm buscado utilizar instrumentos da ergonomia para a
tarefa de desenvolver soluções mais adequadas às necessidades dos usuários.
O conteúdo do IHC inclui o produto, a interface, o processo, a metodologia e as técnicas
usadas dentro de um ciclo de desenvolvimento de software, segundo Netto (2004, p.71). O
IHC envolve a integração de conhecimentos de diferentes áreas sociais, humanas e
tecnológicas, tais como, psicologia cognitiva, filosofia, sociologia, design, ergonomia,
8 O termo cognitivo refere-se ao conhecimento, sendo que a psicologia cognitiva envolve o estudo das bases do conhecimento humano. Muitos deles de fundamental importância para a educação como: aprendizagem, memória, linguagem, percepção, sensação, raciocínio, pensamento e interação.
10
engenharia, inteligência artificial, ciências da computação, entre outras, afirma Preece (2005,
p. 29).
A qualidade da interação usuário-computador pode ser referida por usabilidade proporcionada
pela interface de um sistema de computação. O desenvolvimento de métodos e práticas de
engenharia que garantem um eficiente IHC tem por objetivo apresentar técnicas e métodos
que podem se utilizados sistematicamente para assegurar um alto grau de usabilidade na
interface final de programas de computador.
2.3 ERGONOMIA
Os esforços do homem em adaptar ferramentas, armas e utensílios às suas necessidades e
características marcam o advento da ergonomia.
Segundo a Associação Brasileira de Ergonomia, Abergo, “a ergonomia é uma disciplina
científica relacionada ao entendimento das interações entre os seres humanos e outros
elementos ou sistemas, e à aplicação de teorias, princípios, dados e métodos a projetos a fim
de otimizar o bem estar humano e o desempenho global do sistema”.
O atendimento aos requisitos ergonômicos possibilita maximizar o conforto, a satisfação e o
bem-estar, bem como garantir a segurança, otimizando o desempenho das tarefas e o
rendimento do trabalho e a produtividade do sistema homem-máquina.
A área de estudos da ergonomia de software interessa ao mesmo tempo à utilidade e à
usabilidade, ou seja, adequação à tarefa desejada e a facilidade de uso, dos softwares, de
modo a favorecer a adequação dos mesmos, às tarefas e objetivos de interação do usuário.
Determinar a qualidade ergonômica de uma interface não é tarefa fácil, visto que, esta tarefa
envolve diversos domínios do comportamento humano, correspondentes aos diversos
processos mentais de tratamento da informação.
Visando reduzir a complexidade das definições de conceitos para a especificação e avaliação
de interfaces, Scapin (1993) apud Silva (1998), sugere alguns princípios a serem observados
no processo de concepção de interfaces, destacando os que são primordiais observar: as
características dos usuários e a tarefa de interação.
11
2.3.1 Usabilidade
Ao fazer referência à questão da qualidade da relação entre sistemas computacionais e
usuários, faz-se associação automaticamente à questão da usabilidade. A usabilidade trata do
relacionamento do usuário com o sistema e a interface é um dos fatores essenciais para a
qualidade de softwares, pois é por meio dela que os usuários podem interagir com o
computador, permitindo que sejam realizadas as tarefas da melhor maneira possível.
Segundo Preece (2005, p.34) a usabilidade é geralmente considerada como o fator que
assegura que os produtos são fáceis de usar, eficientes e agradáveis, do ponto de vista do
usuário. Essas características implicam em otimizar as interações estabelecidas pelas pessoas
com produtos interativos, permitindo que realizem suas atividades.
Segundo Souza et al (1999) apud Netto (2004, p.77), a usabilidade depende dos seguintes
aspectos: facilidade de aprendizado do sistema, facilidade de uso, satisfação do usuário,
flexibilidade do sistema e produtividade.
Ainda segundo Souza et al (1999) apud Netto (2004, p.77), é necessário que o projetista de
sistemas determine quais dos aspectos acima têm prioridade para o sistema e o usuário, tendo
em vista o alto custo para cuidar de todos os aspectos de modo satisfatório.
2.3.2 Guias e Critérios Ergonômicos para o Desenvolvimento de Interfaces
O interesse na utilização de regras de ergonomia em todas as fases de um projeto de software,
originou-se da necessidade de se evitar erros grosseiros de concepção e facilitar as tomadas de
decisões dos projetistas e avaliadores, de forma a ganhar tempo e assegurar uma maior
coerência e homogeneidade possível.
Estas regras, segundo Silva (1998), em geral propostos por pesquisadores da área de
ergonomia, servem como suporte para desenvolver sistemas de computadores mais
ergonômicos tais como: guia de recomendações, guias de estilos, critérios ergonômicos, entre
outros.
Segundo Preece (2005, p.286) as guias de recomendações e de estilos, os padrões de design e
os critérios ergonômicos existem para ajudar os projetistas de softwares a criar interfaces
melhores a partir da experiências de outros especialistas.
12
Algumas recomendações estão em um nível bastante detalhado e são denominadas regras de
design, ao passo que outras são bastante abstratas, exigindo uma interpretação antes de ser
aplicadas, sendo denominadas princípios de design.
As Guias de Estilos consistem em coleções de regras de design específicas. São utilizadas
para assegurar uma experiência visual consistente em um conjunto de aplicações.
Comumente, as guias de estilos são personalizadas por empresas, visando proporcionar uma
imagem particular a corporação.
Os critérios ergonômicos são uma ferramenta desenvolvida por D. Scapin e Bastien (1993),
do Institut National de Recherche en Informatique et en Automatique (INRIA), da França,
constituindo-se em um conjunto de princípios ergonômicos a serem respeitados. São eles: a
compatibilidade, a homogeneidade, a concisão, a flexibilidade, o feedback, a carga
informacional, o controle explícito e a gestão de erros.
Segundo Silva (1998), esses critérios são subdivididos em 18 sub-critérios de modo a
minimizar a ambigüidade na identificação e classificação das qualidades e problemas
ergonômicos do software interativo.
13
3 GRAMÁTICA
Seria muito cômodo para os programadores se a comunicação entre homem e máquina
pudesse ser feita diretamente em linguagem natural. No entanto, apesar dos avanços
tecnológicos na área, esta meta ainda não pode ser considerada economicamente viável. Os
programas seriam de custo proibitivo se toda a generalidade das linguagens naturais se
mantivesse nas linguagens de programação.
Desta forma, para uma correta compreensão e interpretação das linguagens de programação é
importante que estas sejam descritas de forma completa e sem ambigüidades, utilizando
notações matemáticas formais e de menor complexidade do que os modelos gerais elaborados
por estudiosos de linguagens naturais.
Uma das maneiras utilizadas para formalizar linguagens de programação é especificar regras
para as construções que compõem a linguagem. Ao conjunto de regras de formação utilizadas
para definir de maneira rigorosa uma linguagem específica dá-se o nome de gramática.
Uma gramática serve para definir qual o subconjunto de sentenças que faz parte de uma
determinada linguagem. É um dispositivo formal para especificar uma linguagem
potencialmente infinita de uma forma finita, definindo uma estrutura sobre um alfabeto9 de
forma a permitir que apenas determinadas combinações de símbolos sejam consideradas
sentenças10. Assim, pode-se considerar uma gramática como sendo um sistema gerador de
linguagens. Segundo Almeida (2006, p.18), a idéia original de gramática vem do estudo das
linguagens naturais e suas definições são essencialmente devidas ao lingüista Noam
Chomsky. Fundamentalmente, uma gramática é composta por regras de produção por meio
9 Conjunto finito, não vazio, de símbolos, definidos para uma linguagem (MENEZES 2000, p.62). 10 Seqüências finitas de símbolos do alfabeto. Uma sentença é dita vazia, representada por ε, quando não é
constituída por nenhum símbolo (MENEZES 2000, p.63).
14
das quais é possível obter todos os elementos da linguagem a partir de um símbolo inicial,
usando as regras para produzir os elementos.
3.1 DEFINIÇÃO DE UMA GRAMÁTICA
A notação formal de uma gramática G é definida por uma quádrupla G = (N, T, P, S). Onde
Furtado (2006, p.8) define:
N – Símbolos Não-Terminais: conjunto finito de símbolos denominados não-terminais, ou seja, são os símbolos utilizados na descrição da linguagem.
T – Símbolos Terminais: conjunto finito de símbolos denominados terminais. São os símbolos da linguagem propriamente ditos, ou seja, os símbolos que podem ser usados na formação das sentenças da linguagem.
P – Regras de Produção: conjunto finito de pares (α, β) denominados regras de produção ou regras gramaticais. Relacionam os símbolos terminais e não-terminais, e significa que α é definido por β, ou ainda que α produz β.
S – Símbolo Inicial: símbolo inicial de uma gramática é o não-terminal a partir do qual as sentenças de uma linguagem serão geradas.
As regras de produção de uma gramática são representadas por α → β ou α ::= β, onde α e β
são sentenças sobre um alfabeto, sendo que α envolve pelo menos um símbolo pertencente a
N. O significado de uma regra de produção α → β é α pode ser substituído por β.
Uma seqüência de regras de produção com o mesmo componente do lado esquerdo, pode ser
abreviada como uma única regra de produção, utilizando o símbolo “ | ” para separar cada
elemento do lado direito da regra. Seja uma gramática G = ({S, D}, {0, 1, 2, 3}, P, S), onde,
P = {S → D, D → 0 , D → 1, D → 2, D → 3}, as regras de produções P podem ser
representadas da forma P = {S → D, D → 0 | 1 | 2 | 3}.
Para facilitar a compreensão das expressões, Menezes (2000, p68) adota as seguintes
convenções:
N = {A, B, C, ... T} Letras maiúsculas do início do alfabeto para símbolos não-terminais
T = {a, b, c, ... t} Letras minúsculas do início do alfabeto para símbolos terminais
15
T*11 = {u, v, ... z} Letras minúsculas do fim do alfabeto para seqüências de terminais
( N ∪ T )* = {α, β, γ, ...} Letras gregas para seqüências de símbolos não-terminais e terminais
N ∪ T = {U, V, ... Z} Letras maiúsculas do fim do alfabeto para um símbolo terminal ou não-terminal
3.2 NOTAÇÃO DE UMA GRAMÁTICA
Existem diversas formas de representar uma gramática, dentre as quais destacam-se a notação
formal de gramática, Backus-Naur Form (BNF) e diagramas de sintaxe.
3.2.1 Representação Formal de Gramática
A definição formal de uma linguagem consiste de um conjunto de definições que especificam
as seqüências de símbolos que formam sentenças válidas na linguagem.
A gramática subseqüente exemplifica a notação formal de gramáticas.
S → begin A end
A → B | B ; A
B → identificador := C
C → D + D | D – D | D
D → identificador | constante_inteira | constante_real
3.2.2 Representação Backus-Naur Form (BNF)
A Forma de Backus-Naur foi desenvolvida em esforços de pesquisa paralelos por dois
pesquisadores: John Backus e Noam Chomsky. A nova notação foi ligeiramente alterada um
pouco mais tarde para se descrever a linguagem ALGOL-60 por Peter Naur. O método
revisado passou a ser conhecido como Forma Backus-Naur ou, simplesmente, BNF.
Uma gramática BNF é composta por um conjunto finito de regras que definem a estrutura
válida da seqüência dos símbolos que constituem as sentenças de uma linguagem. Símbolos
não-terminais são delimitados por colchetes angulares, < e >, e o símbolo ::= é usado com o
sentido de "é definido por", unindo o lado esquerdo ao direito da regra.
Segundo Menezes (2000, p. 70)11 significa que pode ocorrer zero ou mais ocorrências do símbolo.
16
A notação BNF também introduz um conjunto de operadores destinados a simplificar a
representação das regras da gramática que envolvam alternativas, repetições e combinações:
| ou Expressa em uma mesma regra, produções alternativas ? opcional Expressa zero ou uma ocorrência do símbolo especificado
( | ) fatoração Expressa a combinação de símbolos alternativos
* repetição Expressa 0 ou mais ocorrências do símbolo
{ || }* concatenação Expressa a repetição múltipla de símbolos concatenados.
A gramática BNF para o exemplo anterior corresponde a:
<programa> ::= begin <lista de comandos> end
<lista de comandos> ::= <comando> |
<comando> ; <lista de comandos>
<comando> ::= identificador := <expressão>
<expressão> ::= <ident_const> + <ident_const> |
<ident_const> - <ident_const> |
<ident_const>
<ident_const> ::= identificador |
constante_inteira | constante_real
3.2.3 Diagrama de Sintaxe
Um diagrama de sintaxe ou grafo de sintaxe é um grafo direcionado contendo dois tipos de
vértices. Vértices retangulares representam não-terminais e vértices em elipses são usados
para representar os terminais. Setas indicam a seqüência de expansão de um símbolo não-
terminal.
Esta notação tem o mesmo poder de expressão de BNF, porém define uma representação
visual para as regras de uma gramática. A Figura 2 apresenta alguns exemplos de regras
descritas para a BNF expressa pelos de diagramas de sintaxe.
Figura 2 - Exemplos de Regras para BNF expressas por diagrama de sintaxe.
17
O diagrama de sintaxe apresentado na Figura 3 corresponde ao exemplo usado na descrição
da gramática BNF.
Figura 3 – Diagrama de Sintaxe.
Além destas três notações apresentadas, pode-se citar a notação de Wirth, as expressões
regulares estendidas, as gramáticas de dois níveis, entre outras, como alternativas a serem
usadas na especificação de linguagens de programação.
3.3 HIERARQUIA DAS GRAMÁTICAS
Segundo Almeida (2005, p.17), toda gramática gera uma linguagem única, mas a mesma
linguagem pode ser gerada por muitas gramáticas diferentes. Assim, pode-se classificar as
gramáticas de acordo com o tipo de linguagens que são geradas por elas, ou seja, conforme as
restrições impostas às regras de derivação.
18
De acordo com a hierarquia gramatical de Chomsky, existem quatro tipos de gramáticas,
identificadas pelos tipos de 0 a 3. Nesta hierarquia, as gramáticas classificam-se em:
3.3.1 Gramáticas sem Restrição ou Irrestrita ou Tipo 0
As regras de uma gramática de tipo 0 são regras da forma α → β, com α e β quaisquer.
3.3.2 Gramáticas Sensíveis ao Contexto ou Tipo 1
As gramáticas de tipo 1 são as gramáticas com regras da forma α → β, onde α e β são
sentenças formadas por símbolos terminais e não-terminais, com α envolvendo pelo menos
um símbolo não-terminal, em que se exige |α| ≤ |β|. A exceção fica por conta da regra S → ε,
se S não aparecer do lado direito de nenhuma regra. São chamadas de sensíveis ao contexto
por permitirem regras da forma α A γ → α β γ, por meio das quais A pode ser reescrito como
β, dependendo do contexto em que A aparecer (α à esquerda, γ à direita).
3.3.3 Gramáticas Livre de Contexto ou Tipo 2
As gramáticas de tipo 2 são as gramáticas com regras da forma A → β, onde A é um símbolo
não-terminal e β é uma seqüência qualquer de (N ∪ T)*, possivelmente vazia. São chamadas
de livre de contexto porque uma regra A → β indica que o não-terminal A independentemente
do contexto em que estiver inserido pode ser substituído por β.
3.3.4 Gramáticas Regulares ou Tipo 3
As gramáticas de tipo 3 são chamadas regulares pela simplicidade da estrutura de suas
linguagens, garantida pelos rígidos formatos de suas regras. Admitem regras nos formatos:
A → a B, onde A e B são não-terminais e a é um terminal ou
A → B a, onde A e B são não-terminais e a é um terminal;
A → a, onde A é um não-terminal e a é um terminal;
A → ε, onde A é um não-terminal.
As linguagens geradas por gramáticas dos tipos 0 e 1 são reconhecidas por máquinas de
Turing, as linguagens geradas por gramáticas do tipo 2 por autômatos de pilha e as linguagens
geradas por gramáticas do tipo 3 por autômatos finitos.
As linguagens do tipo 3 são também de tipos 2, 1 ou 0 (Figura 4). As linguagens do tipo 2 são
também dos tipos 1 e 0. As linguagens do tipo 1 são também do tipo 0.
19
Figura 4 – Hierarquia Gramatical de Chomsky.
Fonte: Menezes 2000, p. 17
Se uma linguagem tem uma gramática de tipo 0, ela é uma linguagem de tipo 0 ou Irrestrita
(LI); se tiver uma gramática tipo 1, ela é uma linguagem tipo 1 ou Sensível ao Contexto
(LSC); Caso tenha uma gramática de tipo 2, ela é uma linguagem tipo 2 ou Livre de Contexto
(LLC); Se tiver uma gramática tipo 3, ela é uma linguagem tipo 3 ou Regular (LR).
Segundo Menezes (2005, p.196), as linguagens geradas por gramáticas do tipo 2 ou
Linguagens Livre de Contexto são as mais adequadas para representar linguagens de
programação por facilitarem o reconhecimento de elementos da linguagem sem ter que
pesquisar o contexto em que estes elementos estão inseridos.
3.4 EQUIVALÊNCIA ENTRE GRAMÁTICAS
Duas gramáticas G1 e G2 são chamadas de equivalentes (G1 ≡ G2), se ambas definem a mesma
linguagem L(G1) = L(G2). Ou seja, as duas gramáticas, de uma forma diferente, geram
exatamente as mesmas sentenças.
A equivalência entre duas gramáticas G1 e G2 pode ser observada no exemplo a seguir:
G1 = ({S, T}, {a, b}, P, S) G2 = ({S, A, B}, {a, b}, P, S)
P = S → aTa | bTb P = S → aA | bB
T → aT | bT | ε A → aA | bA | a
B → aB | bB | b
3.5 DERIVAÇÃO E REDUÇÃO DE GRAMÁTICAS
Derivação e Redução são operações de substituição efetuadas de acordo com as regras de
produção de uma gramática, sendo representadas pelos símbolos ⇒ e ⇐, respectivamente.
20
Uma derivação em uma sentença é a substituição de uma parte desta por um outro conjunto de
símbolos, de acordo com suas produções. A forma como as derivações podem ocorrer em
uma gramática é definida por suas produções, no sentido símbolo inicial → sentença. A
redução é a operação que consiste na substituição de uma sentença ou parte dela, por outra, de
acordo com as produções da gramática, no sentido sentença → símbolo inicial.
Segundo Menezes (2000, p.24), sucessivos passos de derivação são definidos da seguinte
forma:
⇒* zero ou mais passos de derivações sucessivos;
⇒+ um ou mais passos de derivações sucessivos;
⇒i exatos i passos de derivações sucessivos, onde i é um número natural.
Considerando a gramática
1 <exp> ::= <exp> <op> <exp>
2 <exp> ::= ( <exp> )
3 <exp> ::= n
4 <op> ::= +
5 <op> ::= -
6 <op> ::= *
e realizando derivações a partir do símbolo inicial desta gramática, pode-se obter, por
exemplo, a expressão aritmética “(12 – 5) * 6”, que corresponde a sentença correta “(n - n) *
n”. A seqüência das regras, indicadas pelo índice sobrescrito após a seta, usadas em cada
passo da derivação pode ser demostrada em
<exp> →1 <exp> <op> <exp> →3 <exp> <op> n →6
<exp> * n →2 ( <exp> ) * n →1 (<exp> <op> <exp>) * n →3
(<exp> <op> n) * n →5 (<exp> - n) * n →3 (n - n) * n
Segundo Aho et al (1995, p.75), a derivação é a operação adequada para a geração de
sentenças, enquanto que a redução é a operação adequada ao reconhecimento de sentenças.
4 GRAMÁTICA LIVRE DE CONTEXTO
A classe das Linguagens Livre de Contexto, geradas pelas gramáticas livre de contexto e
reconhecidas por autômatos de pilha, contém propriamente a classe das Linguagens
Regulares. Segundo Menezes (2000, p.85) seu estudo é de fundamental importância na
informática; pois especificam adequadamente as estruturas sintáticas das linguagens de
programação, tais como parênteses balanceados, construções aninhadas, entre outras, típicas
das linguagens de programação.
Assim, dentre os quatro tipos de gramáticas apresentadas na Hierarquia de Chomsky, as
gramáticas livre de contexto são as mais importantes na área de compiladores e linguagens de
programação, pelo fato de especificarem eficientemente as construções sintáticas usuais.
Segundo Aho et al, (1995, p.74), a Gramática Livre de Contexto (GLC) é uma especificação
para a estrutura sintática de uma linguagem de programação. Essa especificação é similar à
especificação da estrutura léxica de uma linguagem por expressões regulares, exceto por
utilizar regras recursivas.
Uma Gramática Livre de Contexto é uma gramática definida por uma quádrupla G = (N, T, P,
S), com a restrição de que qualquer regra de produção de P é da forma A → α, onde A é um
símbolo não-terminal de N e α é uma sentença de (N ∪ T)*. Portanto, uma GLC é uma
gramática onde o lado esquerdo das produções contém exatamente um não-terminal.
4.1 ÁRVORE DE DERIVAÇÃO
A árvore de derivação ou árvore sintática é uma representação gráfica para as derivações nas
Gramáticas Livre de Contexto. Por meio da árvore de derivação tem-se representada
explicitamente a estrutura hierárquica que está implícita na linguagem. Cada nó interior da
árvore é rotulado por algum não-terminal da gramática ao passo que os nós-folhas são
22
rotulados por terminais, ou não-terminais, caso se trate de uma árvore parcial. A Figura 5
apresenta a árvore de derivação da expressão “(n – n) * n”.
Figura 5 – Árvore de Derivação.
A profundidade da árvore de derivação é o comprimento do maior caminho entre a raiz e um
nó terminal. O limite de uma árvore de derivação é a seqüência formada pela concatenação,
da esquerda para a direita, das folhas da árvore de derivação.
4.2 DERIVAÇÃO MAIS À ESQUERDA E MAIS À DIREITA
Uma derivação é chamada de mais à esquerda quando o símbolo substituído for o não-
terminal mais à esquerda da forma sentencial. Na derivação mais à direita, o símbolo
substituído é o não-terminal mais à direita.
As derivações mais à esquerda e mais à direita para a sentença “(n – n) * n”, usando a
gramática definida em 2.5 seria:
Derivação mais à esquerda Derivação mais à direita
<exp>⇒ <exp> <op> <exp> <exp>⇒ <exp> <op> <exp>
⇒ (<exp>) <op> <exp> ⇒ <exp> <op> n
⇒ (<exp> <op> <exp>) <op> <exp> ⇒ <exp> * n
⇒ (n <op> <exp>) <op> <exp> ⇒ (<exp>) * n
⇒ (n - <exp>) <op> <exp> ⇒ (<exp> <op> <exp>) * n
⇒ (n - n) <op> <exp> ⇒ (<exp> <op> n) * n
⇒ (n - n) * <exp> ⇒ (<exp> - n) * n
⇒ (n - n) * n ⇒ (n - n) * n
23
4.3 AMBIGÜIDADE
Visto que os compiladores decidem qual código gerar para uma instrução analisando sua
árvore sintática, se uma estrutura de linguagem tiver mais de uma árvore sintática, a estrutura
da mesma não poderá ser determinado de maneira única.
Uma Gramática Livre de Contexto G = (N, T, P, S) é ambígua se existir uma sentença que
possua duas ou mais árvores de derivação. A gramática da expressão aritmética “(n - n) * n”
anterior é ambígua, pois possui árvores sintáticas diferentes.
Em alguns casos é possível transformar uma gramática ambígua em uma gramática sem
ambigüidades. Entretanto, dada uma gramática qualquer não existe um algoritmo que indique
se a gramática é ambígua ou não.
4.4 SIMPLIFICAÇÃO
A simplificação de uma GLC tem por objetivo tornar a gramática mais simples ou de prepará-
la para posteriores aplicações, como a construção e otimização de algoritmos, na
demonstração de teoremas e na implementação de determinados métodos de análise sintática.
Qualquer que seja a transformação efetuada, a linguagem gerada deverá ser sempre a mesma,
não reduzindo assim o poder de expressão das Gramáticas Livre de Contexto. A simplificação
de uma GLC consiste em eliminar símbolos inúteis, produções vazias, produções simples,
recursão à esquerda, não determinismo à esquerda, entre outras.
4.4.1 Símbolos Inúteis
Um símbolo terminal ou não-terminal é inútil se ele não aparece na derivação de nenhuma
sentença em uma Gramática Livre de Contexto. Considera-se uma regra inútil as que contêm
símbolos inúteis. Se o símbolo inicial for um símbolo inútil, a linguagem gerada pela
gramática é vazia.
Um símbolo inútil pode ser:
• infértil: aquele que não gera nenhuma sentença de símbolos terminais;
• inalcançável: aquele que não aparece em nenhuma forma sentencial da gramática.
24
O processo para eliminar símbolos inúteis de uma gramática pode ser divido em dois passos
distintos: primeiro determinar os símbolos férteis e assim poder eliminar os inférteis e,
segundo determinar os símbolos alcançáveis para poder eliminar os inalcançáveis.
Algoritmo para eliminação de símbolos inúteis, proposto por Furtado (2006, p.27):
Entrada: uma GLC G = (N, T, P, S)
Saída: uma GLC G = (N', T', P', S') sem símbolos inúteis
1º Passo: eliminar os símbolos inférteis:
i ← 0
N [i] ← { }
REPITA
i ← i + 1
N [i] ← N [i - 1] ∪ {A | A → α ∈ P, α ∈ (N [i - 1] ∪ T)*}
ATÉ N [i] = N [i - 1]
N1 ← N [i]
Após executar este passo, têm-se os seguintes conjuntos:
N1 que possui apenas os símbolos não-terminais férteis;
P1 que possui as mesmas regras de produção de P, exceto aquelas cujos
símbolos não-terminais não pertencem a N1.
2º Passo: eliminar os símbolos inalcançáveis:
i ← 0
T [i] ← { }
N [i] ← {S}
REPITA
i ← i + 1
N [i] ← N [i - 1] ∪ {X | A → α X β ∈ P1, α e β ∈ (N 1 ∪ T)*,
A ∈ N [i - 1]}
T [i] ← T [i - 1] ∪ {x | A → α x β ∈ P1, α e β ∈ (N 1 ∪ T)*,
A ∈ N [i - 1]}
ATÉ (N [i] = N [i - 1]) E (T [i] = T [i - 1])
N' ← N 1 ∩ N [i]
T' ← T ∩ T [i]
S' ← S
Após executar o segundo passo temos:
N’ é o conjunto de símbolos não-terminais férteis e alcançáveis;
T’ é o conjunto de símbolos terminais alcançáveis;
P’ possui as mesmas regras de produção de P1, exceto aquelas cujos
símbolos não pertencem a N' ∪ T'.
25
Exemplificando a aplicação do algoritmo para a gramática G = ({S, A, B, C, D}, {a, b, c, d},
P, S), tem-se:
P: S → a A
A → a | b B
B → b | d D
C → c C | c
D → d D
1º Passo:
N0 = ∅
N1 = {A, B, C}
N2 = {S, A, B, C}
N3 = {S, A, B, C} = N2 (conjunto de símbolos férteis)
Nesse ponto tem-se uma gramática sem símbolo infértil:
G’ = ({S, A, B, C}, {a, b, c}, P’, S), onde:
P’: S → a A
A → a | b B
B → b
C → c C | c
2º Passo:
V0 = {S}
V1 = {S, a, A}
V2 = {S, a, A, b, B}
V3 = {S, a, A, b, B} = V2 (conjunto de símbolos alcançáveis)
Nesse ponto tem-se uma gramática sem símbolos inúteis:
G’ = ( {S, A, B}, {a, b}, P’’, S ), onde:
P’’: S → a A
A → a | b B
B → b
4.4.2 Produções Vazias
As produções vazias, também chamadas de ε–produções, são produções que derivam
diretamente ou indiretamente ε. Uma GLC é dita ε-livre quando não possui ε-produções ou
quando possui uma única ε-produção, S → ε, onde S é o símbolo inicial da gramática e S não
aparece do lado direito de nenhuma regra de produção. Este tipo de produção é aceita em
gramáticas livre de contexto exatamente pelo fato de existir um algoritmo que transforma a
gramática, tornando-a livre do ε.
26
Segundo Menezes (2000, p.94), o algoritmo é dividido em três passos: inicialmente se
constrói o conjunto dos não-terminais que derivam, direta ou indiretamente ε, chamados de ε-
não-terminais; em seguida, de posse desse conjunto, elimina-se os ε-não-terminais das demais
produções; por fim, se a sentença vazia pertence à linguagem, então é incluída uma produção
para gerar a sentença vazia.
Algoritmo para exclusão de produções vazias, proposto por Furtado (2006, p.28):
Entrada: uma GLC G = (N, T, P, S)
Saída: uma GLC G = (N', T', P', S') sem produções vazias
1º Passo: montar conjunto Nε, conjunto dos ε–não-terminais: Nε = {A | A → ε);
REPITA
Nε = Nε ∪ {X | X → X1 ... Xn ∈ P tal que X1 ... Xn ∈ Nε}
ATÉ que o cardinal de Nε não aumente;
2º Passo: Eliminar os ε-não-terminais das demais produções: REPITA
para toda A → α ∈ P’ e X ∈ Nε tal que α = α1Xα2 e α1α2 ≠ ε
faça P’ = P’ ∪ {A → α1α2}
ATÉ que o cardinal de P’ não aumente;
A gramática resultante desta etapa é G = (N’, T’, P’, S), onde:
P’ = {A → α | α ≠ ε};
3º Passo: Incluir a geração da sentença vazia, se necessário: Se S ∈ Nε, então
adicionar a P’ as seguintes produções: S’ → S e S’ → ε
incluir S’ em N’ (N’ = N ∪ {S’})
caso contrário, faça N’ = N e S’ = S.
A gramática resultante desta etapa é G = (N’, T’, P’, S’).
4.4.3 Produções Simples
Segundo Menezes (2000, p.96), uma produção da forma A → B não adiciona informação
alguma em termos de geração de sentenças, a não ser que o símbolo não-terminal A pode ser
substituído pelo não-terminal B. Neste caso, se B → α, a produção A → B pode ser
substituída por A → α.
O caso especial onde A → A é chamado de produção circular. Estas produções podem ser
eliminadas diretamente, sem nenhum prejuízo para a gramática. O algoritmo de retirada das
produções simples requer que a gramática não possua produções circulares.
27
Algoritmo para exclusão de produções simples, proposto por Furtado (2006, p.29):
Entrada: uma GLC G = (N, T, P, S) sem produções circulares
Saída: uma GLC G = (N, T, P’, S) sem produções simples
1º Passo: Para toda A ∈ N faça:
NA := {B | A →* B, com B ∈ N};
Fim Para
P’ := ∅;
2º Passo: Para toda produção B → α ∈ P faça:
Se B → α não é uma produção simples, então:
P’ := P’ ∪ {A → α | B ∈ NA};
Fim Se
Fim Para
Exemplificando o algoritmo, para a gramática G = ({S, A }, {a, b}, P, S), tem-se:
P: S → b S | A
A → a A | a
Solução:
Ns = {A} NA = { }
P’: S → b S | a A | a
A → a A | a
4.4.4 Recursão à Esquerda
Segundo Aho et al, (1995, p.79), uma gramática é recursiva à esquerda se possui um não-
terminal A tal que exista uma derivação A ⇒+ Aα para uma cadeia α. Ou seja, uma variável
deriva ela mesma, de forma direta ou indireta. A eliminação da recursão à esquerda faz-se
necessária em diversas situações, como no desenvolvimento de algoritmos reconhecedores e
métodos de análise sintática top-down.
As gramáticas subseqüentes são exemplos de gramáticas com recursão à esquerda direta e
indireta:
G1 recursão à esquerda direta
S → S a | b G2 recursão à esquerda indireta
S → A b | B c
A → S a | a
B → b B | ε
Algoritmo para eliminação da recursão à esquerda:
28
Entrada: uma GLC G = (N, T, P, S) sem produções circulares
Saída: uma GLC G = (N, T, P’ ,S) sem recursão à esquerda
1º Passo: eliminar a recursão à esquerda direta, substituindo as
regras de produção na forma
A → A α1 | ... | A αn | β1 | ... | βm,
onde nenhum βi começa com A por
A → β1 A' | ... | βm A'
A' → α1 A' | ... | αn A' | ε, onde A' é um novo não-terminal
2º Passo: eliminar a recursão à esquerda indireta, ordenando os não-
terminais de G em uma ordem qualquer (A1, ... An)
Para i de 1 até n faça
Para j de 1 até i - 1 faça
substituir as regras de produção na forma Ai → Aj γ por
Ai → α1 γ | ... | αk γ, onde α1 ... αk são os lados direitos
das regras de produção Aj, ou seja, AJ → α1 | ... | αk
Fim para
eliminar as recursões à esquerda diretas das Ai produções
aplicando o 1º Passo.
Fim para
4.4.5 Não Determinismo à Esquerda
Uma GLC é determinística, ou fatorada, se não possui não determinismo à esquerda. Ou seja,
não possui produções cujo lado direito inicie com o mesmo conjunto de símbolos ou com
símbolos que derivam seqüências que iniciem com o mesmo conjunto de símbolos.
Na seqüência um exemplo de GLC não fatorada e a GLC fatorada equivalente.
G1 não fatorada
A → a B | a C | d A
B → b B | b
C → c C | c
G2 fatorada ≡ G1 A → a A' | d A
A' → B | C
B → b B’
B’ → B | ε C → c C’
C’ → C | ε
29
Algoritmo para eliminação do não determinismo à esquerda:
Entrada: uma GLC G = (N, T, P, S)
Saída: uma GLC G = (N, T, P', S) fatorada
1º Passo: eliminar não determinismo direto, substituindo as regras de
produção na forma
A → α β | α γ por
A → α A'
A' → β | γ
2º Passo: eliminar não determinismo indireto, transformando em não
determinismo direto por meio de derivações sucessivas e
então aplicar o 1º Passo. P' possui as regras de produção
anteriormente especificadas que não possuem não
determinismo e as regras de produção modificadas pela
aplicação do algoritmo.
Dependendo das características da gramática, o não determinismo à esquerda pode não ser
eliminado.
Segundo Menezes (2000, p.97), é importante salientar que não é qualquer seqüência de
simplificação de gramática que atinge os resultados desejados. Por exemplo, em uma
gramática sem símbolos inúteis, mas com produções simples, o algoritmo para excluir este
tipo de produção pode gerar símbolos inúteis. Portanto, caso os algoritmos sejam combinados,
a seguinte seqüência de simplificação é recomendada é exclusão de produções vazias,
exclusão de produções simples e por último exclusão e símbolos inúteis.
4.5 FORMAS NORMAIS
As formas normais são aplicadas principalmente no desenvolvimento de algoritmos
reconhecedores de linguagens e na prova de teoremas. Segundo Menezes (2000, p.97), as
formas normais estabelecem restrições rígidas na definição das produções, sem reduzir o
poder de geração das Gramáticas Livre de Contexto.
4.5.1 Forma Normal de Chomsky
Segundo Menezes (2000, p.98), uma GLC é dita na Forma Normal de Chomsky (FNC) se ela
não possuí símbolos inúteis, se é ε-Livre e todas as suas produções, exceto S → ε, são da
forma: A → BC ou A → a, onde A, B e C são não-terminais e a é um terminal.
30
O algoritmo a seguir transforma uma GLC qualquer, ε-Livre, em uma GLC na Forma Normal
de Chomsky, proposto por Menezes (2000, p.99):
Entrada: G = (N, T, P, S)
Saída: G3 = (N3, T1, P3, S)
1º Passo: Simplificação da Gramática
Os algoritmos para simplificar produções vazias, produções da
forma A → B e símbolos inúteis, devem ser aplicados conforme
mostrado no capítulo 3.5.
Como resultado das simplificações temos G1 = N1, T1, P1, S).
2º Passo: Transformação do lado direito das produções de comprimento
maior ou igual a dois.
N2 = N1; P2 = P1;
Para toda A → X1X2 ... Xn ∈ P2 tal que n ≥ 2 faça
Se para r ∈ {1, ... , n}, Xr é um símbolo terminal então (suponha Xr = a)
N2 = N2 ∪ {Ca};
substitui a pela variável Ca em A → X1X2 ... Xn P2;
P2 = P2 ∪ {Ca → a}; Fim se Fim para A gramática resultante deste passo é G2 = (N2, T1, P2, S)
3º Passo: Transformação do lado direito das produções de comprimento
maior ou igual a três, em produções com exatamente duas
variáveis.
N3 = N2; P3 = P2;
Para toda A → B1BB2 ... Bn ∈ P3 tal que n ≥ 3 faça
P3 = P3 – {A → B1BB2 ... Bn};
N3 = N3 ∪ {D1, ..., Dn-2};
P3 = P3 ∪ {A → B1D1, D1 → B2D2,..., Dn-3 → Bn-2Dn-2, Dn-2 → BBn-1BnB }; Fim para A gramática resultante deste passo é G3 = (N3, T1, P3, S)
4.5.2 Forma Normal de Greibach
Segundo Menezes (2000, p.100), uma GLC é dita na Forma Normal de Greibach (FNG) se ela
é ε-Livre e todas as suas produções, exceto S → ε, são da forma A → aα, onde A é um
símbolo não-terminal e a é um terminal e α é uma sentença de não-terminais.
O algoritmo a seguir transforma uma GLC qualquer, ε-Livre, em uma GLC na FNG.
31
Entrada: G = (N, T, P, S) Saída: G4 = (N3, T1, P4, S)
1º Passo: Simplificação da Gramática
Os algoritmos para simplificar produções vazias, produções da
forma A → B e símbolos inúteis, devem ser aplicados conforme
mostrado no capítulo 3.5.
Como resultado das simplificações temos G1 = N1, T1, P1, S).
2º Passo: Renomeação dos não-terminais em uma ordem crescente.
N2 = {A1, A2, ..., Nn} é N1 onde os não-terminais são renomeados; P2 é P1 renomeando os símbolos não-terminais nas produções; A gramática resultante deste passo é G2 = (N2, T1, P2, S)
3º e 4º Passo: Transformação de produções para a forma Ar → Asα, onde
r ≤ s e exclusão das recursões da forma Ar → Arα.
P3 = P2; Para r variando de 1 até n faça Para s variando de 1 até r-1 faça
Para toda Ar → Arα ∈ P3 faça excluir Ar → Arα de P3; Para toda As → β ∈ P3 faça P3 = P3 ∪ {Ar → βα} Fim para Fim para Fim para (fim do 3º passo)
Para toda Ar → Arα ∈ P3 faça
excluir Ar → Arα de P3; N3 = N3 ∪ {Br}; P3 = P3 ∪ {Br → α} ∪ {Br → αBBr}; Fim para
Para toda Ar → φ ∈ P3 tal que φ não inicia por Ar e alguma Ar → Arα foi excluída faça P3 = P3 ∪ {Ar → φBBr}; Fim para Fim para
A gramática resultante do 3º e 4º passo é G3 = (N3, T1, P3, S)
5º Passo: Um terminal no início do lado direito de cada produção.
P4 = P3;
Para r variando de n-1 até 1 e toda Ar → Asα ∈ P4 faça excluir Ar → Asα de P4; Para toda As → β de P4 faça P4 = P4 ∪ {Ar → βα}; Fim para Fim para Também é necessário garantir que as produções relativas aos
símbolos não-terminais auxiliares Br iniciam por um terminal do
lado direito:
32
Para toda Br → Asβr faça
excluir Br → Asβr de P4;
Para toda As → aα faça P4 = P4 ∪ {Br → aαBB
r}; Fim para Fim para
A gramática resultante desse passo é G4 = (N3, T1, P4, S)
E as produções da forma A → aα onde α é composta por símbolos
não-terminais.
As gramáticas na forma normal tendem a ter um maior número de produções, estas são no
entanto mais simples, na sua forma, do que as produções numa gramática equivalente que não
esteja na forma normal.
4.6 AUTÔMATO COM PILHA
As Linguagens Livre de Contexto têm um tipo de autômato que as define, chamado autômato
com pilha. Segundo Hopcroft (2002, p.234), este autômato é uma extensão do autômato
finito12, onde existe uma pilha para manter o controle necessário para o gerenciamento de
Linguagens Livre de Contexto.
A presença de uma pilha significa que, diferente do autômato finito, o autômato com pilha
pode memorizar uma quantidade infinita de informações. Entretanto, o autômato com pilha só
pode acessar as informações de sua pilha pelo método de último a entrar, primeiro a sair.
Um autômato com pilha, também conhecido como Push Down Automata ou PDA, é um
dispositivo não-determinístico reconhecedor de Linguagens Livre de Contexto que possui
basicamente quatro partes em sua estrutura geral, conforme apresentado por Menezes(2000,
p.105):
• Fita – Dispositivo de entrada que contém a informação a ser processada. Dividida em
células onde cada uma armazena um símbolo, pertencente ao alfabeto de entrada;
12 Um autômato finito é um dispositivo reconhecedor de uma determinada linguagem regular. Pode ser visto como uma máquina composta, basicamente, de três partes, uma fita, uma unidade de controle e uma função de transição. A aplicação típica de autômatos finitos é na construção de analisadores léxicos para linguagens computacionais (Almeida 2006, p.27).
33
• Pilha – Memória auxiliar que pode ser usada livremente para leitura e gravação; Dividida
em células onde cada um armazena um símbolo do alfabeto auxiliar. Em estrutura do tipo
pilha, a leitura e a gravação é sempre realizada na mesma extremidade, denominada topo.
Seu tamanho é infinito, sendo que seu valor inicial é vazio;
• Unidade de Controle – Indica o estado corrente da máquina. Apresenta um número finito e
predefinido de estados, possuindo uma cabeça de fita e uma cabeça de pilha, definidas
por:
o Cabeça da Fita – É uma unidade exclusivamente de leitura. Realiza a leitura,
acessando um a célula por vez e movimentando-se sempre para a direita;
o Cabeça da Pilha – É uma unidade de leitura e gravação. Realiza a gravação movendo-
se para à esquerda, ou para cima, podendo armazenar uma palavra composta por mais
de um símbolo, em uma mesma operação. Realiza a leitura movendo-se para direita, ou
para baixo, excluindo o símbolo lido. Está sempre posicionada no topo da pilha e
acessa um símbolo de cada vez.
• Função de Transição – Comanda a leitura da fita, leitura e gravação da pilha e define o
estado da máquina, conforme mostrado na Figura 6. Analisando o estado corrente, o
símbolo lido da fita e símbolo lido da pilha, determina o novo estado e a palavra a ser
gravada na pilha. Podendo realizar um movimento vazio, ao realizar a leitura do símbolo
ε, permitindo mudar de estado sem ler da fita. O símbolo ε na gravação indica que
nenhuma gravação é realizada na pilha e também não realiza movimento da cabeça. A
omissão do parâmetro de leitura, indicado por “?”, representa o teste de pilha vazia ou
toda palavra de entrada lida.
Figura 6 – Representação da Função de Transição.
Fonte: Furtado 2006, p. 34
34
A Figura 7 ilustra os movimentos do autômato de pilha que ocorrem pela função de
mapeamento. A partir do estado atual, do próximo símbolo da entrada e do topo da pilha, se
obtém o próximo estado e os símbolos que serão empilhados no lugar do anterior. O símbolo
da entrada é consumido no processo e o último símbolo gravado é o primeiro a ser lido. A
base da pilha é fixa e define seu início e o topo é variável e define a posição do último
símbolo gravado. No caso de a transição possuir ε como símbolo da entrada, esta transição
pode ocorrer com qualquer que seja o símbolo da entrada, sem consumi-lo.
Figura 7 – Estrutura do Tipo Pilha.
Fonte: Menezes 2000, p. 105
Segundo Menezes (2000, p.106), o autômato com pilha possui duas definições que diferem no
critério de parada do autômato:
• o valor inicial da pilha é vazio e o autômato pára aceitando a linguagem ao atingir um
estado final;
• a pilha contém, inicialmente, um símbolo especial denominado símbolo inicial da pilha.
Não existem estados finais e o autômato pára, aceitando a linguagem, quando a pilha
estiver vazia.
Apesar de diferentes, as duas definições são equivalente e aceitas universalmente, possuindo
o mesmo poder computacional.
4.6.1 Definição Formal de um Autômato com Pilha
O autômato com pilha envolve sete componentes e pode ser especificado segundo Hopcroft
(2002, p.237), como:
P = (Q, Σ, Γ, δ, q0, Z0, F), onde:
Q conjunto de estados possíveis do autômato o qual é finito;
Σ alfabeto de símbolos de entrada;
Γ alfabeto de pilha finito, ou seja, o conjunto de símbolos permitidos de serem inseridos na pilha;
35
δ função programa ou função de transição, que controla as transições de estado e a pilha δ: Q x (Σ ∪ {ε, ?}) x (V ∪ {ε, ?}) → 2QxV*;
q0 estado inicial do autômato tal que q0 é elemento de Q;
Z0 o símbolo de inicial;
F conjunto de estados de aceitação ou estados finais, tal que F está contido em Q.
Exemplo de um PDA, proposto por Hopcroft (2002, p.238).
Dada a Linguagem Lwwr = {ww
r | w está em (0 + 1)*} pode-se descrever um PDA para a Lwwr como:
P = {(q0, q1, q2), (0, 1), (0, 1, Z0), δ, q0, Z0, (q2)}
4.6.2 Notação gráfica para Autômatos com Pilha
A função de transição de um PDA, representada por δ, pode ser ilustrada por um diagrama de
transição. Em geral, segundo Hopcroft (2002, p.239), um diagrama de transição para um PDA
constitui-se:
• dos nós, que correspondem aos estados do PDA;
• de uma seta identificada por início, que indica o estado inicial;
• de estados com círculos duplos, que indicam os estados de aceitação ou finais;
• de arcos, que correspondem às transições do PDA no sentido dado a seguir:
o um arco identificado por a, X / α do estado q para ao estado p significa que δ (q, a, X)
contém o par (p, α), talvez entre outros pares. Ou seja, o rótulo do arco informa que
entrada é usada e também fornece o topo da pilha antigo e o novo.
O diagrama não informa qual símbolo da pilha é o símbolo inicial. Convencionalmente, ele é
Z0, a menos que seja indicado outro.
A Figura 8 mostra um exemplo de representação gráfica do PDA para o exemplo apresentado
em 3.6.1, proposto por Hopcroft (2002, p.238).
36
Figura 8 - Representação gráfica de um PDA.
Fonte: Hopcroft 2002, p. 238
O fato do autômato com pilha ser não-determinístico é importante, pois aumenta o seu poder
computacional, o que permite reconhecer exatamente a Classe das Linguagens Livre de
Contexto. Assim, o autômato com pilha reconhece qualquer Linguagens Livre de Contexto,
com um único estado, ou três estados, dependendo da definição. Isto significa que a pilha é
suficiente como memória auxiliar, não sendo necessário empregar estados para memorizar as
informações passadas.
5 ANÁLISE SINTÁTICA
A análise sintática tem a função de verificar se a estrutura gramatical do programa está
correta. Segundo Price (2001, p.09), o analisador sintático, também chamado de parser,
identifica seqüências de símbolos que constituem estruturas sintáticas por meio de uma
varredura ou “parsing” dos tokens13 do programa fonte. O analisador sintático produz,
explicita ou implicitamente, uma estrutura em árvore, chamada de árvore de derivação, que
exibe a estrutura sintática do texto fonte, resultante da aplicação das regras gramaticais da
GLC da linguagem.
Outra função dos reconhecedores sintáticos é a detecção de erros de sintaxe, identificando
objetivamente a posição e o tipo de erro ocorrido. Mesmo que erros tenham sido encontrados,
o analisador sintático deve tentar recuperá-los, prosseguindo a análise do texto restante.
O processo de análise sintática, dos compiladores dirigidos pela sintaxe engloba funções
como a identificação de sentenças, detecção de erros de sintaxe, recuperação de erros,
correção de erros, ativação do analisador léxico, ativação de rotinas de análise de
dependências de contexto da linguagem, ativação de rotinas de análise semântica a partir da
árvore sintática e ativação de rotinas de síntese de código objeto.
5.1 PARSE ASCENDENTE E DESCENDENTE
O analisador sintático é um algoritmo que, recebendo como entrada uma sentença x, emite
como saída o parse de x (se x pertence à linguagem) ou um erro sintático, caso x não pertença
à linguagem. A análise sintática, ou parsing, é o efeito da execução do analisador sintático.
13 Os tokens são compostos pelo agrupamento de símbolos de uma linguagem e representam as menores unidades de informação que constituem a linguagem em questão. Os tokens são gerados pelo analisador léxico e
38
Assim, dada uma G = (N, T, P, S) com as produções de P numeradas de 1 a p e uma derivação
S →+ x, o parse de x em G é a seqüência formada pelo número das produções utilizadas na
derivação S →+ x .
O parse é classificado em:
• parse ascendente, ou bottom-up, é constituído pela seqüência invertida dos números das
produções utilizadas em S →DIR+ x, onde →DIR denota a derivação mais à direita.
• parse descendente, ou top-down, é constituído pela seqüência dos números das produções
utilizadas em S →ESQ+ x, onde →ESQ denota a derivação mais à esquerda.
Dada a Gramática Livre de Contexto
E → E + T 1
| T 2
T → T * F 3
| F 4
F → ( E ) 5
| id 6
os parses ascendentes e descendentes para a sentença “id * id” são:
• parse ascendente:
E ⇒DIR+ x = 64632, ou seja, E →2 T →3 T * F →6 T * id →4 F * id →6 id * id
• parse descendente:
E ⇒ESQ+ x = 23466, ou seja, E →2 T →3 T * F →4 F * F →6 id * F →6 id * id
5.2 CONJUNTOS FIRST E FOLLOW
Alguns analisadores sintáticos utilizam a tabela de análise preditiva para realizar o processo
de validação de uma linguagem. Esta tabela é construída a partir das funções First e Follow
associadas à gramática.
podem ser basicamente das categorias: palavras reservadas, identificadores, símbolos especiais, constantes numéricas, constantes literais e comentários (Rangel 2006, p.4.1).
39
5.2.1 First
O conjunto First de um símbolo de uma gramática é o conjunto de todos os símbolos que
podem precedê-lo em uma sentença. Para First(α), segundo Price (2001, p.48), se α é uma
seqüência de símbolos da gramática, então o conjunto First(α) é formado pelos terminais que
iniciam formas sentenciais derivadas a partir de α. Se α →* ε, então a sentença vazia também
faz parte do conjunto.
Algoritmo para calcular o conjunto First(X), segundo Price (2001, p.48):
Para computar o FIRST(X) para um símbolo X da gramática, aplicam-se as regras abaixo, até que não possa adicionar mais terminais ou ε ao conjunto em questão. 1) Se a é terminal, então FIRST(a) = { a }. 2) Se X → ε é uma produção, então adicione ε a FIRST(X). 3) Se X → Y1Y2...Yk é uma produção e, para algum i, todos Y1, Y2, ...Yi-1 derivam ε, então FIRST(Yi) está em FIRST(X). Se todo Yj(j = 1, 2, ... k) deriva ε, então ε está em FIRST(X).
5.2.2 Follow
O conjunto Follow de um símbolo é o conjunto dos símbolos que podem ser precedidos pelo
símbolo não-terminal em questão. Segundo Price (2001, p.48), o conjunto Follow(A), sendo
A um não-terminal, é o conjunto de terminais a que podem aparecer imediatamente à direita
de A em alguma forma sentencial. Ou seja, o conjunto de terminais a tal que existe uma
derivação da forma S → * αAaβ, para α e β quaisquer.
Algoritmo para calcular o conjunto Follow(X) , segundo Price (2001, p.48):
Para computar o FOLLOW(X), aplicam-se as regras abaixo até que não possa adicionar mais símbolos ao conjunto. 1) Se S é o símbolo inicial da gramática e $ é o marcador de fim de sentença, então $ está em FOLLOW(S). 2) Se existe produção do tipo A → αXβ, então todos os terminais de FIRST(β) fazem parte de FOLLOW(X). 3) Se existe produção do tipo A → αX, ou A → αXβ, sendo que β →* ε , então todos os terminais que estiverem em FOLLOW(A) fazem parte de FOLLOW(X).
5.3 CLASSES DE ANALISADORES
Existem duas classes fundamentais de analisadores sintáticos, definidas em função da
estratégia utilizada na análise. Os analisadores ascendentes procuram chegar ao símbolo
inicial da gramática a partir da sentença a ser analisada, olhando a sentença ou parte dela para
decidir qual produção será utilizada na redução; os analisadores descendentes procuram
40
chegar à sentença a partir do símbolo inicial da gramática, olhando a sentença ou parte dela
para decidir que produção deverá ser usada na derivação. Assim, a análise sintática pode ser:
• Top-Down ou Descendente
• Bottom-Up ou Ascendente
Na análise descendente, a árvore de derivação é construída a partir do símbolo inicial da
gramática, pro meio de derivações. Já a análise ascendente monta a árvore de derivação a
partir dos tokens, chegando até o símbolo inicial por meio de reduções.
5.3.1 Analisadores Ascendentes
Os algoritmos de análise sintática ascendente são, de maneira geral, mais poderosos que os
descendentes, afirma Louden (2004, p.199). Por exemplo a recursão a esquerda não é um
problema para a análise sintática ascendente, ao contrário dá análise descendente. Assim, as
construções requeridas pelos algoritmos de análise sintática ascendentes são mais complexas.
A idéia deste tipo de análise sintática é construir a árvore de derivação a partir de suas folhas.
O processo de reconhecimento consiste em transferir símbolos da sentença de entrada para
uma pilha de análise sintática, até que se tenha o lado direito de uma produção. Quando isso
ocorrer, esse lado direito é substituído pelo símbolo do lado esquerdo da produção. O
processo segue até que a sentença chegue ao fim e reste apenas o símbolo inicial da gramática
na pilha, caso em que a sentença é aceita.
A classe de analisadores ascendentes determinísticos é composta por uma série de técnicas,
dentre as quais se destacam duas famílias de técnicas:
• Analisadores de Precedência - estes analisadores baseiam-se no algoritmo Shift-Reduce,
acrescido de relações de precedência entre os símbolos da gramática, relações estas que
definem, de forma determinística a ação a ser efetuada em uma dada situação.
• Analisadores LR (Left to Right) - esta família de analisadores é uma evolução natural do
algoritmo geral Shift-Reduce. A diferença fundamental é que as operações shift e reduce
são realizadas sempre deterministicamente, com base no estado corrente da análise e nas
propriedades estruturais da gramática. Tem como principais técnicas os métodos SLR(1),
LALR(1) e LR(1).
41
5.3.1.1 Algoritmo Shift-Reduce
A formulação dos algoritmos de análise sintática ascendente baseia-se em um algoritmo
primitivo denominado Algoritmo Geral Shift-Reduce ou Avança-Reduz, que utiliza:
• uma pilha de análise sintática, inicialmente vazia;
• um buffer de entrada, contendo a sentença a ser analisada;
• uma GLC, com as produções numeradas de 1 à p;
• um procedimento de análise sintática, o qual consiste em transferir os símbolos da entrada,
um a um, para a pilha até que o conteúdo da pilha, ou parte dele, coincida com o lado
direito de uma produção. Quando isto ocorrer, o lado direito da produção deve ser
substituído pelo lado esquerdo da produção. Este processo deve ser repetido até que toda a
sentença de entrada tenha sido analisada.
Neste algoritmo, as reduções são prioritárias em relação as transferências. Se ao final do
processo a entrada estiver vazia e a pilha de análise sintática contiver apenas o símbolo inicial
da gramática, a sentença analisada estará sintaticamente correta.
Embora esta técnica de análise sintática possa ser aplicada a qualquer GLC, ela apresenta
algumas deficiências que inviabilizam seu uso na prática. São elas:
• requer muito tempo para análise;
• só detecta erro sintático após consumir toda a sentença a ser analisada e não identifica o
ponto onde ocorreu o erro;
• pode rejeitar sentenças corretas, pelo fato de que nem sempre que o lado direito de uma
produção aparece na pilha a ação correta é uma redução, fato este que caracteriza o não-
determinismo do método.
O problema do não-determinismo pode ser contornado usando-se a técnica de backtracking,
contudo, o uso desta técnica inviabiliza o método na prática, em função da complexidade de
tempo e espaço.
5.3.1.2 Analisadores LR
Segundo Rozenberg et al (1997, p.172), esta é a classe de analisadores sintáticos ascendentes
mais conhecida, eficiente e poderosa, do ponto de vista das estruturas que podem ser
reconhecidas por ela. Uma gramática que pode ser reconhecida por um analisador LR é
42
chamada de Gramática LR. As gramáticas LR são capazes de reconhecer praticamente todas
as estruturas sintáticas definidas por gramáticas livre de contexto não ambíguas.
A classe dos analisadores LR é formada por uma série de técnicas onde as principais são
SLR(1), LALR(1) e LR(1), em ordem crescente no sentido de força ou abrangência de GLC, e
complexidade de implementação. Os analisadores LR são assim denominados pelo fato de
analisarem a sentença de entrada da esquerda para a direita (Left-to-right) e construírem uma
derivação mais à direita (Rightmost derivation) na ordem inversa.
As principais razões da grande importância desta família de analisadores na teoria de parsing
e no desenvolvimento de compiladores são:
• analisam praticamente todas as construções sintáticas de linguagem de programação que
podem ser representadas de forma não ambígua por uma GLC;
• são mais gerais que os outros analisadores ascendentes e que a maioria dos descendentes
sem back-track;
• possuem a propriedade de detecção imediata de erros sintáticos e
• o tempo de análise é proporcional ao tamanho da sentença a ser analisada.
Em contrapartida, a complexidade de construção da tabela de análise sintática, bem como o
espaço requerido para seu armazenamento, pode ser destacado como um ponto negativo dos
analisadores LR.
Sob o ponto de vista lógico, um analisador LR consiste de um algoritmo de análise sintática,
padrão para todas as técnicas da classe e independente da gramática e uma tabela de análise
sintática, construída de forma especifica para cada técnica e para cada gramática. Segundo
Furtado (2006, p.48), pode-se dizer que um analisador LR compõe-se de:
• um algoritmo de análise sintática, padrão para todas as técnicas da família;
• uma tabela de análise sintática, específica para cada técnica e para cada gramática;
• uma pilha de estados ou pilha sintática, que conterá um histórico da análise efetuada, sendo
inicializada com o estado inicial da análise sintática.
• uma entrada que conterá a sentença a ser analisada, seguida por $, a marca de final de
sentença e
• uma GLC com as produções numeradas de 1 a p.
43
O algoritmo da Análise Sintática LR consiste em determinar Sm, o estado do topo da pilha, e
ai, o próximo símbolo da entrada, e com base nessas informações, consultar a tabela de
análise sintática para decidir a próxima ação a ser efetuada e efetuá-la. Segundo Almeida
(2006, p.61), esta ação poderá ser:
• Halt: Fim de análise. Indica que a análise sintática deve ser encerrada.
• Erro: Indica a ocorrência de um erro sintático. As rotinas de recuperação, se existirem,
deverão ser ativadas para que a situação de erro seja contornada e a análise possa
continuar; senão, a análise deve ser encerrada.
• Shift S: Significa o reconhecimento sintático do símbolo da entrada. O símbolo da entrada
deve ser retirado e o estado S, indicado na tabela de análise sintática, deverá ser
empilhado.
• Reduce R: Significa que uma redução pela produção número R deve ser efetuada. Deverão
ser retirados para a pilha sintática tantos estados quantos forem os símbolos do lado
direito da produção R e o símbolo do lado esquerdo dessa produção deverá ser tratado
como um símbolo de entrada na próxima ação do analisador.
O processo de determinar e efetuar as ações sintáticas deverá ser repetido até que a ação Halt
seja encontrada ou, para as implementações sem recuperação de erros, um erro seja detectado.
A tabela de análise sintática dos analisadores LR é dividida em duas partes:
• Tabela Action: contém as transições Shift, Reduce, Erro e Halt, com os símbolos terminais.
• Tabela Goto: contém as transições Goto e Erro, com os símbolos não-terminais. Um Goto
é um Shift especial sobre um símbolo não-terminal.
Um analisador LR é um par cujo primeiro elemento é o conteúdo da pilha sintática e o
segundo é a entrada a ser analisada. Por exemplo, a configuração (S0X1 S1X2 S2 ... Sm, ai ai+1
ai+2 ... an$), tem o seguinte significado: os primeiros i-1 símbolos da entrada já foram
analisados e a próxima ação a ser efetuada será determinada pelo estado Sm, topo da pilha, e
por ai, próximo símbolo da entrada. X1, X2, ..., XM só existem logicamente.
Algoritmo para Construção da Coleção LR(0), proposto por Furtado (2006, p.51). Inicialização
1º Numere as produções de G de 1 a p;
2º Aumente G com a produção S’ S$; S’ passará a ser o símbolo
inicial de G e $ será usado como marca de final de sentença)
44
3º Defina o núcleo do estado inicial (estado 0), como sendo o item
[0, 0], onde a produção no 0 é a produção incluída.
Construção dos Estados
1º Faça o Fechamento14 do núcleo;
2º Faça o Fechamento dos itens criados em a;
3º Determine o núcleo dos Estados Sucessores15;
4º Repita a, b e c para todos os núcleos criados, até que nenhum
Estado Sucessor novo seja criado e que todos os estados estejam
completos (isto é, todos os itens fechados).
Algoritmo para Análise LR, proposto por Aho et al (1995, p.96). Repita
Faça S ser o estado no topo da pilha
Faça a ser o próximo símbolo da entrada
Se Ação[S, a] = empilhar S’ Então
Empilhar S’
Fim Se
Senão
Se Ação[S, a] = reduzir P Então
Seja P a produção A ::= β
Desempilhar |β| estados da pilha
Seja S’ o estado agora no topo da pilha
Empilhar Desvio[S’, A]
Fim Se
Senão
Se Ação[S, a] = Aceitar Então
Parar análise
Fim Se
Senão
Erro
Fim Se
Fim Repita
14 Se um determinado item contém a “marca” na frente de um não-terminal A, o fechamento deste item será o próprio item mais o conjunto de itens [i, 0] existentes, onde i é o número de uma produção cujo lado esquerdo é o não-terminal A. Se a “marca” precede um símbolo terminal ou se o item é completo, o fechamento será o próprio item. 15 São os estados alcançados por meio da movimentação da “marca” sobre um determinado símbolo. O núcleo do estado sucessor será formado pelo conjunto de itens resultantes da movimentação acima referida. Não existe estado sucessor relativo ao item [0, 1] (≡ S’ S, $), uma vez que este item indica o final da análise.
45
5.3.1.3 Analisador SLR(1)
Este método é o mais simples de todos os analisadores LR. Gera tabelas compactas e o
processo de geração também é simples, porém falha em reconhecer certas estruturas que as
outras técnicas reconhecem, afirma Louden (2004, p.212).
A construção deste analisador se baseia em itens. Um item A → a•b indica a possibilidade de
que, no ponto atual em que se encontra a análise:
• a regra A → ab foi usada na derivação da cadeia de entrada;
• os símbolos terminais derivados de a já foram encontrados;
• falta encontrar os símbolos terminais derivados de b.
Assim o ponto (•) indica o progresso da análise. Por exemplo, nos casos extremos, A → •g
indica o início da busca por um g, e A → g• indica o fim da busca por um g, ou seja, o
momento em que a redução de g para A pode ser executada.
Num dado momento, várias possibilidades precisam ser consideradas, e, por essa razão,
representa-se um estado do processo de análise por um conjunto de itens. O estado inicial do
processo de análise tem um item inicial S' → •S, proveniente da inclusão de uma nova regra
inicial S’ → S, e pode ser entendido como estar faltando encontrar um S. De acordo com as
regras da gramática, é necessário acrescentar a cada estado as possibilidades correspondentes.
Assim, quando um estado contém um item A → a•Bb, itens correspondentes às regras de B
devem ser acrescentados, para dirigir a busca por B.
Esses são os itens da forma B → •g, para todas as regras B → g de B. O processo, repetido
enquanto for necessário, é denominado o fechamento do estado. Assim, o estado inicial é o
fechamento de { S' → •S }.
Pode-se então definir que:
• Item LR: é uma produção com um ponto em alguma posição do lado direito. Este ponto é
uma indicação de até aonde a produção já foi analisada. Uma produção como A → abc
geraria quatro itens:
A •abc A a•bc A ab•c A abc• Já a produção A → ε gera apenas o item A → •.
46
• Função Fechamento(I): Seja I um conjunto de itens LR, o fechamento(I) é calculado da
seguinte forma:
Todo item de I pertence ao fechamento(I).
Se A → α•Xβ está no conjunto fechamento(I), e X → γ é uma
produção, então adicione X → •γ ao fechamento(I).
Estas regras devem ser repetidas até que não seja mais feita
nenhuma alteração a fechamento(I).
O algoritmo proposto por Aho et al (1995, p.97), para determinar a função fechamento. função fechamento(I); Início J := I; Repetir
Para cada item A → α•Bβ em J e cada produção B → γ de G tal
que B → •γ não esteja em J Faça
incluir B → •γaJ Até que não possam ser adicionados mais itens a J; retornar J Fim
• Função Desvio: Segundo Aho et al (1995, p.98), uma outra função útil é a função desvio(I,
X), onde I é o conjunto de itens e X um símbolo gramatical. Essa função é definida como
o fechamento do conjunto de todos os itens A → αX•β tais que A → α•Xβ esteja em I.
Assim, se I for o conjunto de itens válidos para algum prefixo viável γ, então desvio(I, X)
será o conjunto de itens válidos para o prefixo viável γX.
Uma coleção de Itens LR é chamada de Coleção Canônica LR. Esta coleção providencia a
base para a construção de analisadores SLR(1). Para a construção de uma Coleção Canônica
LR para uma gramática define-se uma gramática aumentada e as funções de fechamento e
desvio.
Algoritmo para construção de uma Coleção Canônica LR, proposto Aho et al (1995, p.98).
Dada uma Coleção Canônica C:
C := {fechamento({S’ → •S})}
Repita
Para cada conjunto de itens I em C e cada símbolo gramatical X
Tal que desvio(I, X) não seja vazio e não esteja em C Faça
Incluir desvio(I, X) a C;
Até que não haja mais conjuntos de itens a serem incluídos a C;
Fim
47
5.3.1.3.1 Tabela de Análise Sintática SLR
Algoritmo para construir a tabela de análise sintática SLR proposto por Aho et al (1995,
p.98).
Entrada: Coleção Canônica de itens LR C de G’
Saída: Tabela de análise sintática SLR para G’
Seja C = {I0, I1, ..., In}. Os estados do analisador são 0, 1,..., n.
A linha i da tabela é construída a partir do conjunto Ii, como segue:
As ações do analisador para o estado i são determinadas usando as
regras:
Se desvia(Ii, a) = Ij, então Faça
AÇÃO[i, a] = empilha(j)
Se A α• está em Ii, então
Para todo a em Follow(A), Faça
AÇÃO[i, a] = reduz(n), sendo n o numero da produção A α•
Se S’ S• está em Ii, então Faça
AÇÃO[i, $] = aceita.
Se for gerado algum conflito, significa que a gramática não é SLR
As transições para o estado i são construídas da forma seguinte:
Se desvia(Ii, A) = Ij, então
TRANSIÇÃO[i, A] = j.
As posições não definidas na tabela constituem estados de erro.
5.3.1.3.2 Exemplo da aplicação do Analisador SLR(1):
Exemplo proposto por Rangel(2000, p.24), dada a gramática SLR(1) formada pelas seguintes
regras de produção:
E → E + T | T T → T ∗ F | F F → (E) | a
A gramática aumentada é
0. S' → E 1. E → E + T 2. E → T 3. T → T ∗ F 4. T → F 5. F → (E) 6. F → a
S' → •E E → E + T → T ∗ •F F → (•E) S' → E• E → •T T → T ∗ F• F → (E•)
E → •E E → T• T → •F F → (E)•
48
E → E• + T T → •T ∗ F T → F• F → •a E → E + •T T → T• ∗ F F → •(E) F → a•
Quadro 1 – Itens da gramática aumentada.
Como o estado inicial é o fechamento de {S' • E}, deve-se acrescentar os seguintes itens, ao estado inicial:
{S'→•E, E→•E+T, E→•T, T→•T∗F, T→•F, F→•(E), F→•a}
7. T→T∗•F F→•(E) F→•a 8. F→(E•) E→E•+T
0. S'→•E E→•E+T E→•T T→•T∗F T→•F F→•(E) F→•a
4. F→(•E) E→•E+T E→•T T→•T∗F T→•F F→•(E) F→•a
9. E→E+T• T→T•∗F
5. F→a• 1. S'→E• E→E•+T
10. T→T∗F•
2. E→T• T→T•∗F 3. T→F•
6. E→E+•T T→•T∗F T→•F F→•(E) F→•a
11. F→(E)•
Quadro 2 – Coleção completa de estados.
E T F ( a + * ) $ 0 1 2 3 4 5 - - - - 1 - - - - - 6 - - - 2 - - - - - - 7 - - 3 - - - - - - - - - 4 8 2 3 4 5 - - - - 5 - - - - - - - - - 6 - 9 3 4 5 - - - - 7 - - 10 4 5 - - - - 8 - - - - - 6 - 11 - 9 - - - - - - 7 - - 10 - - - - - - - - - 11 - - - - - - - - -
Quadro 3 – Transição entre os estados.
E T F ( a + ∗ ) $ 0 1 2 3 4 5 - - - - 1 - - - - - 6 - - r0 2 - - - - - r2 7 r2 r2 3 - - - - - r4 r4 r4 r4 4 8 2 3 4 5 - - - - 5 - - - - - r6 r6 r6 r6 6 - 9 3 4 5 - - - - 7 - - 10 4 5 - - - - 8 - - - - - 6 - 11 - 9 - - - - - r1 7 r1 r1
10 - - - - - r3 r3 r3 r3 11 - - - - - r5 r5 r5 r5
Quadro 4 – Tabela de ações. As configurações sucessivas da análise da sentença (a+a)∗a, são:
Pilha Entrada Ação 0 (a+a)∗a empilhar: 4
0 ( 4 a+a)∗a empilhar: 5
49
0 ( 4 a 5 +a)∗a reduzir: 6
0 ( 4 F 3 +a)∗a reduzir: 4
0 ( 4 T 2 +a)∗a reduzir: 2
0 ( 4 E 8 +a)∗a empilhar: 6
0 ( 4 E 8 + 6 a)∗a empilhar: 5
0 ( 4 E 8 + 6 a 5 )∗a reduzir: 6
0 ( 4 E 8 + 6 F 3 )∗a reduzir: 4
0 ( 4 E 8 + 6 T 9 )∗a reduzir: 1
0 ( 4 E 8 )∗a empilhar: 11
0 ( 4 E 8 ) 11 ∗a reduzir: 5
0 F 3 ∗a reduzir: 4
0 T 2 ∗a empilhar: 7
0 T 2 ∗ 7 a empilhar: 5
0 T 2 ∗ 7 a 5 ε reduzir: 6
0 T 2 ∗ 7 F 10 ε reduzir: 3
0 T 2 ε reduzir: 2
0 E 1 ε reduzir: 0 (aceitar)
Quadro 5 – Tabela de ações da sentença (a+a)∗a.
5.3.1.4 Analisador LR(1)
No método LR(1) original, também conhecido como LR(1) canônico, a decisão sobre os
símbolos de lookahead que permitem as reduções pelas várias regras é feita com um cuidado
maior do que no SLR(1). No caso SLR(1), uma redução por uma regra A → β é feita para
todos os símbolos de Follow(A). Isso significa que, num dado estado, podem estar sendo
levados em consideração símbolos de lookahead16 que foram introduzidas por regras da
gramática que não interferem nesse estado, ou seja, símbolos que não podem aparecer nessa
posição em nenhuma cadeia correta que leve ao estado considerado.
No analisador LR(1), os símbolos que podem ocorrer como lookaheads são calculados para
cada caso, permitindo ao analisador LR(1) um maior controle sobre as reduções, o que faz
com que algumas gramáticas que não são SLR(1) sejam LR(1).
Para calcular os lookaheads admissíveis, usa-se uma definição de item com mais informação:
um item LR(1) é da forma [A → α•β, u], onde u é um símbolo terminal. O $ é tratado como
um símbolo terminal. Na realidade, a teoria define um item LR(k) e u é uma sentença com k
símbolos; nesse caso, k=1 e u é uma sentença de um símbolo. Os itens usados na construção
do analisador SLR(1) são itens LR(0), com a notação simplificada: em vez de [A → α•β, ε],
16 O símbolo lookahead corresponde ao token no topo da pilha, ou seja, o próximo token a ser analisado.
50
escreve-se apenas A → α•β. Na prática, valores de k maiores que 1 não são usados porque a
tabela de ações teria n*k colunas, onde n é o número de símbolos da gramática.
Regras para construção da coleção dos estados LR(1), proposto por Aho et al (1995, p.95).
• Ο fechamento de um estado q é feito acrescentando ao estado q, para cada item [A
→ α•Bβ, u] pertencente a q, todos os itens da forma [B → •γ, v], onde B → γ é uma regra
de B, e v ∈ First(βu). Como antes, o processo deve ser repetido enquanto novos itens
forem sendo acrescentados. Sendo que os símbolos v ∈ First(βu) são aqueles que podem
ocorrer depois de B, supondo que u ocorreu depois de A, e que a regra A → αBβ foi
usada.
• Α transição entre estados é definida da seguinte maneira: se um estado q tem um ou mais
itens da forma [A → α•Xβ, u], o estado δ(p,X), alcançado com o símbolo X a partir de p é
obtido pelo fechamento do conjunto de itens da forma [A → αX•β, u], obtidos a partir de
todos os itens com X depois do ponto em q.
• Ο estado inicial 0 é construído pelo fechamento do conjunto { [S' → •S, $] }.
• Α coleção de estados do analisador SLR(1) é obtida a partir do estado inicial 0, pro meio de
todas as transições possíveis.
Os empilhamentos são feitos obedecendo à tabela de transições. As reduções são feitas de
acordo com os símbolos constantes dos itens completos correspondentes às reduções, isto é,
se um estado tem um item [B → γ•, v], então a esse estado, quando o primeiro símbolo da
entrada é v, corresponde a ação de redução pela regra B → γ.
Os algoritmos para construção das funções de fechamento(I), desvio(I, X), elaboração dos
conjuntos de itens LR(1) e respectiva tabela de análise sintática LR(1), propostos por Aho et
al (1995, p.100), são apresentados na seqüência.
Entrada: Uma gramática aumentada G’
Saída: Os conjuntos de itens LR(1), que são os conjuntos de itens
válidos para um ou mais prefixos viáveis de G’.
função fechamento(I); início Repetir
Para cada item [A → α•Bβ, a] em I e cada produção B → γ de G’ e cada terminal b em First(βa) tal
51
que [B → •γ, b] não esteja em I Faça incluir [B → •γ, b] em I; Até que não possam ser adicionados mais itens a I; retornar I Fim função desvio(I, X); início
seja J o conjunto de itens [A → αX•β, a] tais que [A → α•Xβ, a] esteja em I; retornar fechamento(I); Fim procedimento itens(G’); início
C := {fechamento({[S’ → •S, $]})}; Repita Para cada conjunto de itens I em C e cada símbolo gramatical X Tal que desvio(I, X) não seja vazio e não esteja em C Faça Incluir desvio(I, X) a C; Até que não haja mais conjuntos de itens a serem incluídos a C;Fim
5.3.1.4.1 Tabela de Análise Sintática LR(1)
Algoritmo para construção da tabela de análise sintática LR(1).
Entrada: Uma gramática aumentada G’
Saída: As funções sintáticas canônicas LR ação e desvio para G’
Construir C = {I0, I1, ..., In}, a coleção de conjuntos de itens de G’; O estado i do analisador sintático é construído a partir de Ii. As ações sintáticas para o estado i são determinadas como se segue:
Se [A → α•aβ, b] estiver em Ii e desvio(Ii, a) = Ij, então Faça ação[i, a] igual a “empilhar j” Aqui, a é exigido ser um terminal
Se [A → α•a] estiver em Ii, A ≠ S’, então Faça ação[i, a] igual a “reduzir A → α” Se [S’ → S•, $] estiver em Ii, então Faça ação[i, $] igual a “aceitar” Se um conflito resultar das regras acima então, a gramática não é considerada LR(1) e o algoritmo falha. As transições desvio para o estado i são determinadas como se segue:
Se desvio(Ii, A) = Ij, então Faça
desvio[i, a] = j
Todas as entradas não definidas pelas regras 2 e 3 são
consideradas erros;
O estado inicial do analisador sintático é aquele construído a
partir do conjunto contendo o item [S’ → •S, $].
5.3.1.4.2 Exemplo da aplicação do Analisador LR(1):
52
Exemplo proposto por Louden (2004, p.220), dada a gramática LR(1) formada pelas seguintes
regras de produção: A → (A) | a
A gramática aumentada e os respectivos estados são:
6. A → a•,)
0. A' → •A,$ A→ •(A),$ A→ •a,$
3. A → a•,$
7. A → (A)•,$ 1. A' → A•,$ 4. A → (A•),$ 8. A → (A•),) 2. A → (•A),$ A→ •(A),) A→ •a,)
5. A → (•A),) A→ •(A),) A→ •a,)
9. A → (A)•,)
Quadro 6 – Gramática aumentada e coleção completa de estados. O diagrama contendo todos os itens da gramática LR(1), para este exemplo, pode ser visto na Figura 9.
Figura 9 – Diagrama de itens LR(1).
Fonte: Louden 2004, p. 222
5.3.1.5 Analisador LALR(1)
O Analisador LALR(1) é uma técnica intermediária que possui um tamanho de tabela
equivalente à SLR, com a capacidade de reconhecer quase tudo que a LR(1) reconhece, ao
custo de um processo de geração mais complexo.
É mais difícil encontrar gramáticas SLR(1) do que gramáticas LR(1), para as linguagens de
programação usuais. Isto levou os pesquisadores a procurarem um método de análise que
calculasse os símbolos de lookahead, como é feito pelo LR(1), mas que levasse a um número
menor de estados, como o SLR(1). Esse método é o método LALR(1) popularizado pelo
gerador de Analisadores Sintáticos YACC. A idéia do método LALR(1) é simples, define-se
o núcleo de um conjunto de itens LR(1) como sendo o conjunto de itens LR(0) obtido
retirando todos os lookaheads de todos os itens.
Construa um analisador LR(1) e identifique todos os estados que têm o mesmo núcleo. Para cada grupo de estados LR(1) {p1, p2, ..., pn } que
53
têm o mesmo núcleo, construa um estado LALR(1) p pela união de todos
esses estados: p = p1 ∪ p2 ∪ ... ∪ pnO estado união p tem o mesmo núcleo que p1, p2, ..., pn. Feito isso, a função de transição LALR(1) pode ser construída:
Se p = p1 ∪ p2 ∪ ... ∪ pn, determine δ(p, X) da seguinte maneira: Escolha um dos estados pi que pertença a p e obtenha qi = δ(pi, X) Determine de qual estado laLR(1) q o estado qi faz parte
faça δ(p, X) = q Para determinar as reduções, a regra é a mesma do analisador LR(1):
Se um estado tem um item [B → γ•, v], então a esse estado, quando o primeiro símbolo da entrada é v corresponde a ação de redução pela
regra B → γ.
Pode-se também construir a coleção de estados LALR(1) para uma gramática, sem passar pela
coleção de estados LR(1). Primeiro, constrói-se os estados LR para a gramática e a
correspondente função de transição. Estes correspondem exatamente aos estados e as
transições do analisador SLR(1). Depois disso, acrescenta-se o item [S' → S, $] ao estado
inicial 0, e acrescenta-se o estado 0 à lista dos estados a serem tratados. Depois deve-se
acrescentar os lookaheads. Tratar um estado q significa:
• remover o estado q da lista;
• fazer o fechamento do estado q, propagando os lookaheads;
• para cada item [A → α•Xβ, u], verificar se no estado q' = δ(q, X) já se encontra o item [A
→ αX•β, u]. Se não for encontrado, o item é acrescentado, e se o estado q' não faz parte
da lista, é acrescentado à lista, para tratamento posterior.
Um estado pode ser tratado várias vezes. Em particular, durante o tratamento de um estado q
ele próprio pode ser re-incluído na lista. O processo continua até que a lista fique vazia, ou
seja, até que não haja mais nenhum estado para ser tratado.
5.3.1.5.1 Exemplo da aplicação do Analisador LALR(1): Exemplo proposto por Louden (2004, p.227), considerando a gramática apresentada em
4.3.1.4.2, cujo diagrama de itens é LR(1) é apresentado na Figura 9.
A identificação dos estados 2 e 5, 4 e 8, 7 e 9 e 3 e 6 dá o diagrama
de itens LALR(1) mostrado na Figura 10.
54
Figura 10 – Diagrama de itens LALR(1).
Fonte: Louden 2004, p. 227
5.3.1.6 Algoritmo Coke-Younger-Kasami
Segundo Menezes (2000, p.122), o algoritmo de Cocke-Younger-Kasami (CYK) foi
desenvolvido independentemente por Cocke, Younger e Kasami, em 1965. Faz parte da classe
de Analisadores Ascendentes, gerando bottom-up todas as árvores de derivação da entrada
com um tempo de processamento proporcional a |w|3. É construído sobre uma Gramática
Livre de Contexto na Forma Normal de Chomsky.
Esse algoritmo tem como premissa construir uma tabela triangular de derivação, mostrado na
Figura 11, sendo que cada célula representa o conjunto de raízes que pode gerar a
correspondente sub-árvore. O algoritmo de CYK é constituído por uma gramática GLC, na
Forma Normal de Chomsky, G = (N, T, P, S), onde T = {a1, a2, ..., at} e w = a1a2 ... an uma
entrada a ser verificada.
O Algoritmo de CYK é composto por duas etapas, onde Vrs representa as células de uma
tabela triangular de derivação.
Algoritmo de CYK, proposto por Menezes (2000, p.123):
Variáveis que geram diretamente terminais (A → a). Para r variando de 1 até n Faça Vr1 = {A | A → ar ∈ P} Produção que gera duas variáveis (A → BC). Para s variando de 2 até n Faça Para r variando de 1 até n - s + 1 Faça Vrs = ∅ Para k variando de 1 até s – 1 Faça Vrs = Vrs ∪ {A | A → BC ∈ P, B ∈ Vrk e C ∈ V(r+k)(s-k)} Fim Para Fim Para Fim Para
Considerações sobre o algoritmo:
• o limite de iteração para r é (n - s + 1), pois a tabela é triangular;
55
• os vértices Vrk e V(r+k)(s-k) são as raízes das sub-árvores de Vrs;
• se uma célula for vazia, significa que esta célula não gera qualquer sub-árvore.
Figura 11 – Tabela triangular de derivação.
Fonte: Menezes 2000, p. 123
Exemplo proposto por Menezes (2000, p.123) para a aplicação do algoritmo de CYK:
Considere a seguinte gramática G = ({S, A}, {a, b}, P, S), onde: P = S → AA | AS | b
A → SA | AS | a A tabela triangular de derivação para a palavra de entrada abaab é
ilustrada na Figura 12.
Figura 12 – Tabela triangular de derivação do exemplo.
Fonte: Menezes 2000, p. 124
Os métodos apresentados neste tópico são classificados como analisadores sintáticos
ascendentes porque ao analisar uma sentença, constroem suas respectivas árvores de
derivações de baixo para cima, ou seja, das folhas onde se encontra a respectiva sentença para
a raiz , onde se encontra o símbolo inicial.
5.3.2 Analisadores Descendentes
A análise descendente é feita analisando a sentença e tentando montar uma árvore de
derivação para ela. Para isso existem os analisadores com retrocesso, ou backtracking, e os
analisadores preditivos.
56
O primeiro caso sempre tenta, a partir do símbolo inicial da gramática, efetuar derivações à
esquerda e montar a árvore de derivação. No caso de não haver regra de derivação aplicável,
ele desfaz a última derivação e continua o processo. Se não houver possibilidade alguma de
continuar, a sentença é rejeitada. Quando toda a sentença tiver sido processada, sua arvore de
derivação está montada. Está técnica possui desvantagens como o excessivo tempo de
processamento e a eventual dificuldade de se desfazer uma derivação no meio do processo de
compilação. Os analisadores preditivos impõem uma série de restrições à gramática que eles
aceitam para que possam fazer a análise sem o retrocesso. No caso de não haver uma regra de
transição, a sentença pode ser rejeitada, pois com certeza não haverá outra derivação possível.
As gramáticas que se encaixam nestas restrições são chamadas de gramáticas LL17.
5.3.2.1 Analisador Recursivo
O Analisador Sintático Recursivo Descendente, ou simplesmente ASRD, é o mais simples dos
reconhecedores descendentes. Este analisador é construído como um conjunto de rotinas
representando cada não-terminal da gramática. Cada símbolo na sentença de entrada fará com
que o analisador decida entre chamar uma nova produção da gramática ou reconhecer o
terminal na cadeia de entrada. Cada símbolo na entrada pode fazer com que um ASRD,
reconheça o símbolo de entrada, chame uma rotina correspondente à produção identificada ou
acuse um erro.
O ASRD atua em conjunto com o analisador léxico de forma que a cada vez que um símbolo
na sentença de entrada é reconhecido o ASRD solicita ao analisador léxico que leia e
identifique o próximo token (símbolo). Se o processo retornar à rotina principal sem erros o
analisador reconhece a cadeia de símbolos entrada.
A principal desvantagem desta técnica é que ela não é geral. Os procedimentos são
específicos para cada gramática, e se for necessário alterar a gramática com a adição de uma
regra, por exemplo, fatalmente será preciso modificar o analisador. Além disso, o tempo de
análise é grande e existe a necessidade de uma linguagem que permita recursividade para sua
implementação.
17 Sub-tipo das Gramáticas Livre de Contexto, particularmente importantes para a implementação de parsers. A explicação de seus símbolos é L - Left-to-right scanning (varredura da esquerda para a direita) e L - Leftmost-derivation (derivação mais a esquerda) (Rangel, 2006, p.3.16).
57
Por outro lado, a principal vantagem desta técnica é a simplicidade de implementação e a
facilidade para inserir as diferentes funções do processo de compilação diretamente nos
procedimentos que realizam a análise sintática de cada não-terminal da gramática; contudo,
esta vantagem verifica-se apenas para gramáticas/linguagens pequenas e simples.
A estratégia de um Analisador Recursivo Descendente pode ser descrita como:
• Constrói-se um analisador léxico como uma função que retorna o próximo símbolo na
sentença de entrada (token), eliminando caracteres inúteis para a análise sintática como
brancos, comentários e caracteres de controle.
• Para cada não-terminal da gramática criar uma função, ou seja, um conjunto de
procedimentos, normalmente recursivos;
• Em cada função criada, percorrer o lado direito da regra da esquerda para direita com as
seguintes políticas:
o Se o próximo elemento do lado direito da regra é um terminal, testa se este se encontra
na entrada. Caso positivo consome o terminal, do contrário acusa erro: terminal
esperado.
o Se o próximo elemento do lado direito da regra é um não-terminal, chama a função
correspondente.
o Ao fim do processo, caso não haja erros, reconhece a cadeia de entrada.
Segundo Louden (2004, p.144), a idéia de um ASRD é extremamente simples. As regras de
produções de um não-terminal são vistas como definições de procedimentos para reconhecer
o não-terminal. O lado direito da regra de produção especifica a estrutura do código para esse
procedimento.
5.3.2.2 Analisador Preditivo LL(1)
A análise sintática preditiva não-recursiva é uma técnica de análise sintática top-down que
utiliza uma tabela para fazer o processo de reconhecimento. Também é um parser LL e por
isso simula uma derivação mais à esquerda a medida que varre a entrada também da esquerda
para a direita. Segundo Louden (2004, p.152), a análise sintática preditiva LL(1) utiliza uma
pilha em vez de ativações recursivas. Um parser preditivo do tipo LL(1) é constituído por:
• entrada, contém a sentença a ser analisada;
• pilha de análise sintática, usada para simular a recursividade. Prevê a parte da entrada que
está para ser analisada; é inicializada com $ e o símbolo inicial da gramática;
58
• tabela de análise sintática preditiva, contém as ações a serem efetuadas. É uma matriz
M[A, a], onde A ∈ N ∧ a ∈ T;
• algoritmo, um algoritmo de análise sintática.
O termo Preditivo deve-se ao fato de que a pilha sempre contém a descrição do restante da
sentença, se ela estiver correta, isto é, prevê a parte da sentença que deve estar na entrada para
que a sentença esteja correta.
Figura 13 - Estrutura de um Parser Preditivo.
Fonte: Furtado 2006, p. 44
O algoritmo do analisador preditivo (Figura 13) tem como função determinar a partir de X, o
elemento do topo da pilha, e de a, o próximo símbolo da entrada, a ação a ser executada, a
qual poderá ser:
• Se X = a = $, então, o analisador anuncia o final da análise.
• Se X = a ≠ $, então, o analisador retira X do topo da pilha e a da entrada. Esta ação
corresponde ao reconhecimento sintático de a.
• Se X ∈ T e X ≠ a, então, situação de erro: ‘X’ era o símbolo esperado. Neste caso, devem
ser ativados os procedimentos de recuperação de erro, caso existam, ou a análise sintática
deve ser encerrada, diagnosticando o erro encontrado.
• Se X ∈ N, então, o analisador consulta a tabela de análise sintática M[X, a], a qual poderá
conter o número de uma produção ou um indicativo de erro:
• Se M[X, a] contém o número de uma produção, e esta produção é X produz UVW, então X
que está no topo da pilha deve ser substituído por WVU, com U no topo;
59
• Se M[X, a] contém um indicativo de erro, então o analisador deve diagnosticar o erro
encontrado e ativar os procedimentos de recuperação de erros; em implementações sem
recuperação de erros a análise é encerrada.
Algoritmo de Análise Sintática Preditiva LL(1), proposto por Louden (2004, p.155).
Repita Se x é terminal ou $ então Se X = a então retira X do topo da pilha retira a da entrada Senão erro( ) Senão (* X é não terminal *) Se M(X, a) = X Y1 Y2 ... Yk então retira X da pilha coloca Yk Yk-1 ... Y2 Y1 na pilha (* deixando Y1 sempre no topo *) Senão erro( ) Até X = $ (* pilha vazia, análise concluída *)
5.3.2.2.1 Tabela de Análise Sintática LL(1)
Segundo Louden (2004, p.154), caso se tenha um não-terminal B no topo da pilha, a escolha
da regra gramatical para B a ser utilizada na substituição de B na pilha, pode ser expressa pela
construção de uma tabela de análise sintática LL(1).
A tabela de análise sintática LL(1) é essencialmente uma matriz bidimensional indexada por
não-terminais e terminais com escolhas de produções para utilização no passo apropriado da
análise, incluindo o $ para representar o final da entrada. Essa tabela é definida por M[N, T],
onde, N é o conjunto de não-terminais da gramática e T é o conjunto de terminais.
As células da tabela contêm as produções cujas derivações são aplicadas quando o terminal da
coluna está na entrada e o não-terminal da linha esta no topo da pilha.
Algoritmo para construção da tabela de análise sintática, proposto por Price (2001, p.50) .
Para cada produção A → α existente na linguagem Faça
Para cada terminal a de First(α),
adicione esta produção a M[A, a]
Se First(α) contém ε, então
Adicione esta produção a M[A, b], para cada b em Follow(A)
Fim para
Fim para
60
Segundo Price (2001, p.51), se, em cada entrada da tabela, existe apenas uma produção, então
á gramática que originou a tabela é dita ser do tipo LL(1). Isso significa que as sentenças
geradas pela gramática são passíveis de serem analisadas da esquerda para a direita (Left to
right), produzindo uma derivação mais à esquerda (Leftmost derivation), levando em conta
apenas um (1) símbolo da entrada.
O algoritmo anterior pode ser aplicado a qualquer gramática para produzir a tabela de análise.
Contudo, para certas gramáticas, a tabela resultante poderá ter entradas multiplamente
definidas. Isso ocorre para as gramáticas ambíguas e, conseqüentemente, essas gramáticas não
são do tipo LL(1). Portanto a tabela de análise sintática dos analisadores preditivos deve
possuir a propriedade de que, em cada entrada da tabela M exista no máximo uma produção,
pois isto viabiliza a análise determinística da sentença de entrada.
5.3.2.2.2 Exemplo da aplicação do Analisador Preditivo LL(1):
Dada a gramática LL(1) formada pelas seguintes regras de produção: 1. E → TE' 2. T → FT' 3. F → (E) 4. F → a 5. E' → +TE' 6. E' → ε 7. T' → ∗ FT' 8. T' → ε
Obtêm-se a seguinte tabela de análise sintática M:
( a * ) $ E 1 1 - - - - T 2 2 - - - - F 3 4 - - - - E' - - 5 - 6 6 T' - - 8 7 8 8
Quadro 7 – Tabela de análise sintática M.
Nessa tabela, a entrada M[A, a] correspondente ao não-terminal A e ao
terminal a tem o número da regra que deve ser usada para expansão de
A. As entradas indicadas por "-" correspondem a situações de erros,
isto é combinações que não podem ocorrer durante a análise de
sentenças da linguagem. Para analisar a sentença a+a∗a, tem-se as
seguintes configurações:
Pilha Entrada escolha da regra E a+a∗a M[E, a] = 1 TE' a+a∗a M[T, a] = 2 FT'E' a+a∗a M[F, a] = 4 aT'E' a+a∗a - T'E' +a∗a M[T', +] = 8 E' +a∗a M[E', +] = 5 +TE' +a∗a - TE' a∗a M[T, a] = 2 FT'E' a∗a M[F, a] = 4 aT'E' a∗a - T'E' ∗a M[T', ∗] = 7
61
∗FT'E' ∗a - FT'E' a M[F, a] = 4 aT'E' a - T'E' ε M[T', $] = 8 E' ε M[E', $] = 6 ε ε -
Quadro 8 – Tabela de análise sintática LL(1) para sentença “a+a*a”.
Os métodos apresentados neste tópico são classificados como analisadores sintáticos
descendentes porque ao analisar uma sentença, constroem suas respectivas árvores de
derivação de cima para baixo, ou seja, da raiz, do símbolo inicial, para as folhas, onde se
encontra a sentença.
6 DEFINIÇÕES DO PROJETO
6.1 ANÁLISE DE REQUISITOS PRELIMINARES
Tendo em vista o processo de ensino-aprendizagem relacionado ao estudo de formalismos de
Linguagens Livre de Contexto, os requisitos da ferramenta foram coletados e definidos por
uma equipe multidisciplinar formada por um professor de Linguagens Formais e
Compiladores, por um aluno que já cursou a respectiva disciplina e pelo analista de sistemas.
Para o protótipo da ferramenta foram levantados os seguintes requisitos:
• Apresentar um resumo da teoria ministrada;
• Apresentar exemplos;
• Realizar derivações de gramáticas livre de contexto;
• Realizar simplificações de gramáticas livre de contexto;
• Realizar conversões de gramáticas para a Forma Normal de Chomsky;
• Importar um autômato com pilha e validar sentenças dado o respectivo autômato;
• Realizar a análise preditiva LL(1) de uma sentença, dada uma gramática;
• Apresentar o conteúdo de forma seqüencial, fornecendo orientações e feedbacks ao aluno;
• Permitir que o aluno possa realizar experimentações e interações distintas e não
seqüenciais;
• Possuir interfaces padronizadas e com nomenclaturas utilizadas em sala de aula;
• Possuir elementos visuais que auxiliem o aluno no aprendizado do conteúdo, tais como
imagens, gráficos, ícones, instruções, entre outros.
• Ter coerência com as propostas pedagógicas do professor;
63
6.2 DEFINIÇÕES DE PROJETO
Visando assegurar a homogeneidade das interfaces e atendendo alguns dos requisitos
preliminare, foram definidas as seguintes recomendações e/ou regras de design para as
interfaces da ferramenta:
• A implementação será feita usando a ferramenta Borland Delphi 6.0. Além dos
componentes disponíveis da ferramenta, será usado o componente open-source
TFlatButton, cujo código fonte se encontra junto aos códigos da ferramenta;
• O conteúdo da ferramenta será apresentado em 6 módulos: Introdução à GLC, Árvore de
Derivações, Simplificações de Gramáticas, Formas Normais, Autômato com Pilha,
Analisadores Sintáticos.
• Conforme é apresentado na figura 14, cada módulo possui os seguintes elementos: título
do módulo, botão de informações, botão de fechar módulo, uma página para aplicação
prática da teoria e uma página com a teoria dos módulos e respectivos exemplos.
Figura 14 – Módulo Padrão
• As interfaces da ferramenta possuem predominantemente as seguintes características:
o Cor de fundo: $00EEECEA
o Cor de Painéis: $00F7F7F7
o Cor de Fontes: $005B5B5B
o Tipos de Fontes: MS Sans Serif e Arial Black
• A figura 15 mostra respectivamente os ícones pré-definidos para a ferramenta.
64
Figura 15 – Ícones Padrão
6.3 CASOS DE USO PRINCIPAIS
Foram definidos nove casos de uso principais para o desenvolvimento do protótipo da
ferramenta de apoio ao ensino de Linguagens Livre de Contexto, conforme apresentados na
figura 16.
ud Caso de Uso Principais
Name: Caso de Uso PrincipaisAuthor: GasparVersion: 1.0Created: 13/11/2006 22:09:47Updated: 14/11/2006 18:09:16
Usuário
Visualizar Teoria
Abrir Gramática
Realizar Deriv ações
Realizar Simplificações
Conv eter GLC para FNC
Criar Autômato com Pilha
Reconhecer Sentença pelo PDA
Criar Analisador Preditiv o LL(1)
Reconhecer Sentença pelo
LL(1)
Figura 16 – Diagrama de Casos de Usos Principais
65
6.3.1 Caso de Uso 01 – Visualizar Teoria
• Atores: Usuário
• Propósito: Permitir o usuário visualizar as teorias apresentadas pela ferramenta.
• Fluxo Principal:
1. O usuário escolhe o módulo referente à teoria que deseja visualizar;
2. O sistema abre o respectivo módulo;
3. O usuário clica no botão “Teorias e Exemplos”, figura 25;
4. O sistema apresenta a página com as respectivas teorias do módulo.
6.3.2 Caso de Uso 02 – Abrir Gramática
• Atores: Usuário
• Propósito: Permitir o usuário abrir um arquivo de texto contendo uma gramática ou
permitir que o mesmo digite uma gramática, verificar se a gramática está dentro das
regras.
• Fluxo Principal:
1. O usuário clica em “Abrir Gramática”, figura 23;
2. O sistema apresenta a tela para abrir o arquivo de texto que contenha a gramática;
3. O usuário seleciona o arquivo e clica em abrir;
4. O sistema abre o arquivo e mostra no campo entrada;
5. O usuário clica em “Verificar Gramática”, figura 23;
6. O sistema verifica se a gramática está digitada conforme as regras de negócio 1 à 7;
7. O sistema apresenta a mensagem de verificação concluída com sucesso;
8. O usuário clica em “Criar Gramática”, figura 23;
9. O sistema cria um objeto com a gramática verificada.
• Fluxos Alternativos:
1. Se o usuário preferir digitar a gramática:
1.1. O usuário digita no campo entrada a gramática;
1.2. Ir para o item 5 do fluxo principal.
7. Se foram encontrados inconformidades na gramática:
7.1. O sistema apresenta uma mensagem de erro contendo as linhas e respectivas
inconformidades encontradas;
7.2. O usuário corrige a gramática;
7.3. Voltar ao item 5 do fluxo principal.
66
6.3.3 Caso de Uso 03 – Realizar Derivações
• Atores: Usuário
• Propósito: Permitir o usuário visualizar a árvore de derivação de uma gramática;
• Fluxo Principal:
1. O usuário clica em Criar Gramática;
2. Executar Caso de Uso 02;
3. O sistema mostra a gramática criada em GLC Base;
4. O sistema apresenta a árvore de derivação da Gramática;
6.3.4 Caso de Uso 04 – Realizar Simplificações
• Atores: Usuário
• Propósito: Permitir o usuário realizar todas as simplificações à gramática automaticamente
ou em partes.
• Fluxo Principal:
1. O usuário clica em “Criar Gramática”, figura 24;
2. Executar Caso de Uso 02;
3. O sistema mostra a gramática criada em GLC Base;
4. O usuário define as opções de simplificações que deseja realizar;
5. O usuário clica em executar simplificações;
6. O sistema executa os respectivos algoritmos referentes as simplificações selecionadas
pelo usuários;
7. O sistema mostra a gramática simplificada;
8. O sistema habilita os botões “Ver Detalhes”, figura 24, de cada opção de simplificação
selecionada pelo usuário;
9. O usuário clica em salvar;
10. O sistema salva a gramática em um arquivo de arquivo;
• Fluxos Alternativos:
9.1. Se o usuário escolher uma das opções de ver os detalhes:
9.1.1. O usuário clica em “Ver Detalhes”;
9.1.2. O sistema mostra os detalhes do respectivo item de simplificação selecionado;
9.1.3. O usuário clica em retornar;
9.1.4. Voltar ao item 9 do fluxo principal.
9.2. Se o usuário escolher converter a gramática simplificada em GLC Base:
67
9.2.1. O usuário clica em “Converter em GLC Base”, figura 24;
9.2.2. O sistema converte a gramática simplificada na GLC Base;
9.2.3. Voltar ao item 9 do fluxo principal.
9.3. Se o usuário escolher fechar o módulo:
9.3.1. O usuário clica em fechar;
9.3.2. O sistema armazena a gramática base atual no módulo principal do sistema, e fecha
o módulo atual;
6.3.5 Caso de Uso 05 – Converter GLC para FNC
• Atores: Usuário
• Propósito: Permitir o usuário converter uma gramática para a Forma Normal de Chomsky.
• Fluxo Principal:
1. O usuário clica em Criar Gramática;
2. Executar Caso de Uso 02;
3. O sistema mostra a gramática criada em GLC Base;
4. O usuário clica em executar conversão;
5. O sistema executa os algoritmos de simplificações de gramática;
6. O sistema executa o respectivo algoritmo referente à conversão de gramáticas para a
Forma Normal de Chomsky;
7. O sistema mostra a gramática na Forma Normal de Chomsky;
8. O usuário clica em salvar;
9. O sistema salva a gramática em um arquivo de arquivo;
• Fluxos Alternativos:
4. Se o usuário desmarcar a opção de execução da simplificação antes da conversão:
4.1. O usuário desmarca “simplificar GLC antes de converter”;
4.2. O sistema emite uma mensagem avisando das conseqüências de não simplificar a
gramática antes da conversão;
4.3. Voltar ao item 4 do fluxo principal.
6.3.6 Caso de Uso 06 – Criar Autômato com Pilha
• Atores: Usuário
68
• Propósito: Permitir o usuário abrir um arquivo de texto contendo um autômato com pilha
ou permitir que o mesmo digite o autômato, verificar se o autômato está dentro das regras.
• Fluxo Principal:
1. O usuário clica em “Abrir Autômato”, figura 26;
2. O sistema apresenta a tela para abrir o arquivo de texto que contenha o Autômato;
3. O usuário seleciona o arquivo e clica em abrir;
4. O sistema abre o arquivo e mostra no campo entrada;
5. O usuário clica em “Atualizar Dados”, figura 26;
6. O sistema verifica se o Autômato está digitado conforme as regras de negócio 8 e 9;
7. O sistema apresenta a mensagem de verificação concluída com sucesso;
8. O usuário clica em “Criar Autômato com Pilha”, figura 26;
9. O sistema cria um objeto com o autômato verificado.
• Fluxos Alternativos:
1. Se o usuário preferir digitar o autômato:
1.1. O usuário digita no campo entrada o autômato;
1.2. Ir para o item 5 do fluxo principal.
7. Se foram encontrados inconformidades no autômato:
7.1. O sistema apresenta uma mensagem de erro contendo as linhas e respectivas
inconformidades encontradas;
7.2. O usuário corrige o autômato;
7.3. Voltar ao item 5 do fluxo principal.
6.3.7 Caso de Uso 07 – Reconhecer Sentença pelo PDA
• Atores: Usuário
• Propósito: Permitir o usuário entrar com uma sentença e realizar o reconhecimento dela
pelo autômato criado.
• Fluxo Principal:
1. O usuário digita a sentença;
2. O usuário clica em “Forma de Reconhecimento - completo”, figura 27;
3. O sistema realiza o reconhecimento da sentença, com base no autômato;
4. O sistema apresenta o reconhecimento da sentença;
• Fluxos Alternativos:
69
2. Se o usuário clicar em reconhecer sentença passo a passo:
2.1. O usuário clica em “Forma de Reconhecimento – passo”, figura 27;
2.2. O sistema realiza o reconhecimento de 1 caractere da sentença, e apresenta o gráfico
de transição da próxima sentença;
2.3. Volta para o item 2 do fluxo principal;
4. Se o sistema não reconhecer a sentença:
4.1. O sistema apresenta uma mensagem de que a sentença não é reconhecida pelo
autômato atual;
4.2. Volta para o item 1 do fluxo principal;
6.3.8 Caso de Uso 08 – Criar Analisador Preditivo LL(1)
• Atores: Usuário
• Propósito: Permitir o usuário criar um Analisador Preditivo LL(1) a partir de uma
gramática;
• Fluxo Principal:
1. O usuário clica em “Criar Gramática”,;
2. Executar Caso de Uso 02;
3. O sistema mostra a gramática criada em GLC Base;
4. O usuário clica em “Criar Analisador LL(1)”;
5. O sistema executa os respectivos algoritmos criando o conjunto first, follow e a tabela
de análise preditiva;
6. O sistema mostra os conjuntos e a respectiva tabela criada;
6.3.9 Caso de Uso 09 – Reconhecer Sentença pelo LL(1)
• Atores: Usuário
• Propósito: Permitir o usuário entrar com uma sentença e realizar o reconhecimento dela
pelo analisador LL(1).
• Fluxo Principal:
1. O usuário digita a sentença;
2. O usuário clica em Reconhecer Sentença;
3. O sistema realiza o reconhecimento da sentença, com base no analisador LL(1);
70
4. O sistema apresenta o reconhecimento da sentença;
• Fluxos Alternativos:
4. Se o sistema não reconhecer a sentença:
4.1. O sistema apresenta uma mensagem de que a sentença não é reconhecida pelo
analisador atual;
4.2. Volta para o item 1 do fluxo principal;
6.4 REGRAS DE NEGÓCIO
1. Os tokens devem ser separados por espaços;
2. Cada regra de produção deve estar em uma linha, portanto as regras não devem ser
finalizadas por símbolos especiais como “;” ou “.”;
3. O símbolo de atribuição é “::=”;
4. Cada regra de produção deve possuir um não-terminal, seguido do símbolo de
atribuição e uma seqüência de um ou mais tokens (não-terminais e/ou terminais);
5. O Não-Terminal deve ser composto por um token apenas;
6. A produção vazia ou epsilon deve ser representado pelo símbolo “ î ”;
7. Não devem ser usados mais de uma produção do mesmo não-terminal na mesma linha
separados por “|”.
8. No arquivo de importação do autômato com pilha, os estados, o alfabeto de entrada, o
alfabeto da pilha e as respectivas funções de transição devem ser separados apenas por
espaços. Cada um dos grupos dos respectivos elementos citados, devem estar em uma
linha, na seguinte seqüência: conjunto de estados, conjunto do alfabeto de entrada,
conjunto do alfabeto da pilha, símbolo inicial da pilha, conjunto de estados finais. Da 6ª
linha até o final do arquivo, devem estar as funções de transição, sendo que cada uma
delas, em uma linha;
9. No arquivo de importação as linhas com as funções de transição devem possuir o
seguinte formato: E1 SE TP E2 EP. Sendo que cada elemento significa: E1 – Estado
Atual, SE – Símbolo de Entrada, TP – Símbolo no Topo da Pilha, E2 – Novo Estado,
EP – Símbolos para empilhar.
71
6.5 DIAGRAMAS DE CLASSES
Os principais diagramas de classes do sistema foram agrupados em Classes Base da GLC,
Classes Simplificações, Classes Formas Normais, Classes PDA, Classes Analisador LL1.
Estes grupos de classes são apresentados nas figuras 17, 18, 19, 20 e 21, respectivamente.
cd Classes Base da GLC
TTokenG
+ Tipo: int+ Lexema: char
+ Create(char, int) : void
TProducao
+ Produz: char+ ListaTokens: TList
+ Create(TStringList, char) : void+ GetToken(char) : int
TRegra
+ NT: char+ ListaProducoes: TList
+ Create(char) : void+ AddProducao_str(TStringList, char) : void+ AddProducao(TProducao) : void+ FindProducao(char, int) : boolean
TGLC
+ SimboloInicial: char+ ListaNT: TStringList+ ListaRegras: TList
+ Create(char, TStringList, TStringList) : void+ AddRegra(TRegra) : void+ GetRegra(char) : TRegra+ ExcluirRegrasVazias() : void
Name: Classes Base da GLCAuthor: GasparVersion: 1.0Created: 13/10/2006 17:03:02Updated: 16/11/2006 10:27:21
* *
TfmCriarGLC
*
- gNomeArq_GLCini: char+ SimboloInicial: char+ ListaProducoes: TStringList+ ListaNT: TStringList+ ListaLog: TStringList
+ SalvarArquivo() : void+ SalvarComoArquivo() : void+ CriarListas() : void+ MostrarListas() : void
Figura 17 - Classes Base da GLC
72
cd Classes Base da GLC
TTokenG
+ Tipo: int+ Lexema: char
+ Create(char, int) : void
TProducao
+ Produz: char+ ListaTokens: TList
+ Create(TStringList, char) : void+ GetToken(char) : int
TRegra
+ NT: char+ ListaProducoes: TList
+ Create(char) : void+ AddProducao_str(TStringList, char) : void+ AddProducao(TProducao) : void+ FindProducao(char, int) : boolean
TGLC
+ SimboloInicial: char+ ListaNT: TStringList+ ListaRegras: TList
+ Create(char, TStringList, TStringList) : void+ AddRegra(TRegra) : void+ GetRegra(char) : TRegra+ ExcluirRegrasVazias() : void
Name: Classes Base da GLCAuthor: GasparVersion: 1.0Created: 13/10/2006 17:03:02Updated: 16/11/2006 10:27:21
* *
TfmCriarGLC
*
- gNomeArq_GLCini: char+ SimboloInicial: char+ ListaProducoes: TStringList+ ListaNT: TStringList+ ListaLog: TStringList
+ SalvarArquivo() : void+ SalvarComoArquivo() : void+ CriarListas() : void+ MostrarListas() : void
Figura 18 - Classes Simplificações
cd Classes Formas Normais
Name: Classes Formas NormaisAuthor: GasparVersion: 1.0Created: 16/11/2006 11:29:46Updated: 16/11/2006 14:33:11
TFormaNormalChomsky
+ ListaNT_FNC: TStringList+ GLC_FNC: TGLC+ ListaLog: TStringList
+ Create(TGLC) : void+ Criar_GLC_FNC(TGLC) : void+ BuscaTroca(char, char, char) : char+ BuscaProducao(TGLC, char, int, char) : boolean
TfmFormasNormais
+ GLC_Inicial: TGLC
+ CriarGLC_Inicial(char, TStringList, TTreeView) : void+ MostrarGLC_Treeview(TGLC, TTreeView) : void
:TGLC :TfmCriarGLC
Figura 19 - Classes Formas Normais
73
cd Classes PDA
Name: Classes PDAAuthor: GasparVersion: 1.0Created: 16/11/2006 09:23:30Updated: 16/11/2006 10:48:33
TTransicao TPDA
- ListaEstados: TStringList- ListaAEntrada: TStringList- ListaAPilha: TStringList- ListaEstadosFinais: TStringList- SimboloInicialPilha: char- ListaTransicoes: TStringList- Pilha: TStringList- Entrada: TStringList
- E1: char- SE: char- TP: char- E2: char- Empilhar: TStringList- Grafo: char
+ Create(char, char, char, char, TStringList) : void
+ Create(TStringList, char, TStringList, TStringList, TStringList) : void+ AddTransicao(TTransicao) : void+ AddEntrada(TStringList) : void
TfmCriarPDA
- gNomeArq_GLCini: char+ SimboloInicialPilha: char+ ListaEstados: TStringList+ ListaAEntrada: TStringList+ ListaAPilha: TStringList+ ListaEstadosFinaisPilha: TStringList+ ListaTransicoes: TStringList
+ SalvarArquivo() : void+ SalvarComoArquivo() : void+ CriarListas() : void+ MostrarListas() : void
Figura 20 - Classes PDA
cd Classes AnalisadorLL1
Name: Classes AnalisadorLL1Author: GasparVersion: 1.0Created: 16/11/2006 11:35:49Updated: 16/11/2006 14:33:38
TAnalisadorLL1
:TGLC :TfmCriarGLC
TfmAnalisadoresSintaticos- ListaFirst: TStringList- ListaFollow: TStringList- TabelaPreditiva: TStringList- Senteca: char
+ GLC_Inicial: TGLC
+ CriarGLC_Inicial(char, TStringList, TTreeView) : void+ MostrarGLC_Treeview(TGLC, TTreeView) : void
+ CriarListaFirst() : void+ CriarListaFollow() : void+ CriarTabelaPreditiva() : void+ VerificarSenteca() : void
Figura 21 - Classes Analisador LL1
74
6.6 PRINCIPAIS INTERFACES DO PROTÓTIPO
Algumas das principais interfaces da ferramenta são apresentadas na seqüência (figuras 22 a
27).
Figura 22 – Tela Principal
Figura 23 – Tela Criar GLC
75
Figura 24 – Tela Executar Simplificações
Figura 25 – Tela Teoria Simplificações
76
Figura 26 – Tela Criar Autômato com Pilha
Figura 27 – Tela Executar Autômato com Pilha
7 CONCLUSÃO
O uso do computador como uma ferramenta auxiliar no processo ensino-aprendizagem, tem
produzido um novo cenário em relação a forma de ensinar e de construir o conhecimento. Por
meio do computador o aluno passa a interagir com o conteúdo das disciplinas, estimulando o
aprendizado autônomo por meio de ferramentas que possibilitem a auto-aprendizagem.
A ferramenta foi implementada de forma a auxiliar o aluno no aprendizado da teoria de
Linguagens Formais. Através dela o aluno poderá aprender sobre derivações de gramáticas,
criando gramáticas e visualizando suas respectivas árvores sintáticas. Realizar conversões de
Gramáticas Livre de Contexto para a Forma Normal de Chomsky.
As simplificações de gramáticas foram amplamente exploradas na ferramenta, permitido o
aluno realizar transformações como eliminação de produções simples, produções vazias,
símbolos inúteis, recursão à esquerda e não-determinismo à esquerda. Ao realizar as
simplificações a ferramenta permite o aluno visualizar os detalhes de cada simplificação,
como tabelas temporárias ou ainda gramáticas intermediárias geradas com a aplicação dos
algoritmos de simplificação.
O Autômato com Pilha é outro assunto abordado pela ferramenta, permitindo ao aluno criar
ou importar um autômato e verificar se uma sentença é reconhecida pelo mesmo. Permite
ainda, o acompanhamento visual das transações possíveis por meio do gráfico do autômato.
A ferramenta apresenta ainda o Analisador Sintático LL(1), além de ter acesso ao teoria, o
aluno poderá criar um Analisador Sintático LL(1) a partir de uma GLC bem como visualizar
os conjuntos first e follow e a tabela de análise preditiva criados ao executar o algoritmo de
geração do Analisador Sintático LL(1).
Todos os assuntos abordados na ferramenta foram agrupados em módulos permitindo ao
aluno seguir a seqüência de assuntos apresentados na disciplina de Linguagens Formais e
Compiladores. Os módulos possuem parte da teoria apresentada em sala de aula pelo
78
professor, permitindo ao aluno um acesso rápido em caso de necessidade de consultas
referentes ao assunto. A ferramenta apresenta ainda, junto a teoria, exemplos dos respectivos
assuntos tratados em cada módulo.
A interface do protótipo da ferramenta foi desenhada buscando atender aos critérios de
usabilidade de Scapin, de forma a tornar atrativo e facilitar o estudo dos conteúdos das
Linguagens Livre de Contexto. Assim, a ferramenta procura promover o aprendizado, uma
vez que o usuário pode, além de ter acesso rápido à teoria e exemplos, executar os algoritmos,
fazer simulações e analisar as respostas apresentadas pela ferramenta, visando validar sua
especificação e com isso assimilar melhor os conceitos e métodos formais que compõem a
teoria das Linguagens Livre de Contexto, complementando as discussões em sala de aula.
Este trabalho, na forma de um protótipo, se apresentou adequado como uma ferramenta
acadêmica de apoio para o ensino e compreensão da teoria que envolve as Linguagens Livre
de Contexto. A expectativa é que a utilização sistêmica desse protótipo na disciplina de
Linguagens Formais e Compiladores dos cursos de Ciência da Computação e Engenharia de
Computação da Universidade do Vale do Itajaí – UNIVALI, campus São José, possa auxiliar,
eficientemente, na aprendizagem dos conceitos e formalismos das Linguagens Livre de
Contexto.
7.1 RECOMENDAÇÕES FUTURAS
A partir deste protótipo propõem-se que sejam desenvolvidos complementos aos módulos
existentes, e a criação de novos módulos. Na seqüência estão relacionados alguns assuntos
propostos para futuras implementações de novas versões da ferramenta:
• Forma Normal de Greibach;
• Algoritmo Geral Primitivo Shift-Reduce;
• Analisadores Sintáticos da família LR (LR(1), SLR(1), LALR(1));
• Algoritmo de Análise Sintática de Coke-Younger-Kasami.
REFERÊNCIAS BIBLIOGRÁFICAS
AHO, Alfred V.; SETHI, Ravi; ULLMAN, Jeffrey D. Compiladores, princípios, técnicas e ferramentas. Rio de Janeiro: Guanabara Koogan, 1995.
ALMEIDA, Pedro Q. de. Compiladores. Faculdade de Ciências e Tecnologia da Universidade de Coimbra, 2005. Disponível em: http://www.mat.uc.pt/%7Epedro/lectivos/compiladores/. Acesso em: 08 Junho 2006.
Associação Brasileira de Ergonomia: Abergo. Universidade Federal de Pernambuco. Disponível em: http://www.abergo.org.br/. Acesso em: 05 Novembro 2006.
BASTIEN, Christian J.M., SCAPIN, Dominique L. Ergonomique Criteria for the Evaluation of Human-Computer Interfaces: Critères Ergonomiques pour l’Évaluation d’Interfaces Utilisateurs. 1993. Disponível em: ftp://ftp.inria.fr/INRIA/publication/publi-pdf/RT/RT-0156.pdf. Acesso em: 04 de Novembro 2006.
FURTADO, Olinto J. V. Linguagens Formais e Compiladores. UFSC, Departamento de Informática e de Estatística. Disponível em: http://www.inf.ufsc.br/~olinto/. Acesso em: 08 Junho 2006.
GIL, Antonio C. Como elaborar projetos de pesquisa. São Paulo: Atlas, 2002.
HOPCROFT, John E.; ULLMAN, Jeffrey D.; MOTWANI, Rajeev. Introdução à Teoria de Autômatos, Linguagens e Computação. Rio de Janeiro: Elsevier, 2002.
HOUAISS, Antônio. Dicionário Houaiss da Língua Portuguesa. 1. ed. Rio de Janeiro: Objetiva Ltda, 2001.
JOSE NETO, João. Introdução à compilação. Rio de Janeiro: Livros Técnicos e Científicos, 1987.
JUNG, Carlos F. Metodologia Científica: ênfase em pesquisa tecnológica. 4. ed. Disponível em:http://www.jung.pro.br/. Acesso em: 04 Abril 2006.
80
LOLLINI, Paolo. Didática e Computador: Quando e Como a Informática na Escola. São Paulo: Loyola, 1991.
LOUDEN, Kenneth C. Compiladores: Princípios e Práticas. São Paulo: Pioneira Thomson Learning, 2004.
MENEZES, Paulo F. B. Linguagens Formais e Autômatos. 3. ed. Porto Alegre: Sagra Luzzatto, 2000.
MENEZES, Paulo F. B. Linguagens Formais e Autômatos. 5. ed. Porto Alegre: Sagra Luzzatto, 2005.
NETTO, Alvim Antônio de Oliveira. IHC – Interação Humano Computador – Modelagem e Gerência de Interfaces com o Usuário. 1. ed. Florianópolis: VisualBooks, 2004.
PREECE, Jennifer. Design de Interação: Além da Interação Homem-Computador. 1.ed. Porto Alegre: Bookman, 2005.
PRICE, Ana Maria de A; TOSCANI, Simão S. Implementação de Linguagens de Programação: Compiladores. 2. ed. Porto Alegre: Sagra Luzzatto, 2001.
RANGEL, José L. Compiladores Notas de aula: Informática PUC-RJ, 2000. Disponível em http://www-di.inf.puc-rio.br/~rangel/comp.html. Acesso em: 08 Junho 2006.
ROZENBERG, Grzegorz; SALOMAA, Arto. Handbook of Formal Languages. Heidelberg: Springer-Verlag, 1997.
SILVA, Cassandra Ribeiro de Oliveira e. Bases Pedagógicas e Ergonômicas para Concepção e Avaliação de Produtos Educacionais Informatizados: Dissertação apresentada ao Programa de Pós-Graduação em Engenharia de Produção da Universidade Federal de Santa Catarina. Disponível em: http://www.eps.ufsc.br/disserta98/ribeiro/index.html. Acesso em: 05 Novembro 2006.
VALENTE, José Armando. Computadores e Conhecimento: Repensando a Educação. Campinas: campinas, 1993.