Literatura executável: interpretando algoritmos em notações arbitrárias

Transcrição

1 Literatura executável: interpretando algoritmos em notações arbitrárias Thiago Bezerra Lima e Silva 1, André Luís Brasil Cavalcante 1 1 UPIS União Pioneira de Integração Social CEP Brasília DF Tel.: (61) tsilva@sourcecraft.info, cavalcantealb@yahoo.com.br Abstract. Currently, there is no single, standard and wide accepted notation to write algorithms in Portuguese. Each text book available about programming logic introduces a specific notation and many programming professors adopt the notation that best fits his or her classes. Moreover, each portugol interpreter available defines its own language. Given the conflicts originated from the disagreement of notations adopted by the literature, in programming courses and by interpreters, this paper presents a tool for executing algorithms written in an arbitrary notation, allowing lexical and syntactical definitions to be easily modified as a means to wholly satisfy the class style and associated literature of programming introduction courses. Keywords: algorithm, programming language, interpreter Resumo. Atualmente, não há uma linguagem de programação em português amplamente aceita para descrever algoritmos. Em geral, cada livro disponível sobre lógica de programação utiliza uma notação específica e cada professor que leciona introdução à programação adota a notação que melhor se ajusta às suas aulas. Ainda, cada interpretador de portugol disponível define sua própria linguagem. Em meio aos conflitos oriundos da discordância entre notações utilizadas na literatura, em sala de aula e por interpretadores, este artigo apresenta uma ferramenta para a execução de algoritmos cuja linguagem pode ser modificada facilmente de forma a satisfazer o estilo de aula e a literatura utilizada em um curso de lógica de programação. Palavras-chave: algoritmo, linguagem de programação, interpretador 1. Introdução Diversos livros sobre o ensino de algoritmos encontram-se disponíveis atualmente e muitos destes livros foram escritos usando uma abordagem particular, muitas vezes, em função da experiência do autor em ministrar aulas de introdução à programação. Ao seguir uma abordagem em particular, estes livros apresentam, também, notações específicas para os algoritmos, sendo que estas diferem pouco ou muito das notações utilizadas em obras semelhantes. Há que se considerar, também, a adoção de interpretadores de algoritmos como ferramenta auxiliar de aprendizagem. E estas, por sua vez, também utilizam uma linguagem própria. Não raro, os professores que adotam

2 tais ferramentas acabam tendo que considerar se devem adotar a linguagem da ferramenta ou a linguagem de uma das obras que constam na bibliografia do curso. Por outro lado, não só com base nos interpretadores ou na literatura uma notação pode ser favorecida para uso em sala de aula. Disciplinas subseqüentes que adotam uma linguagem de programação específica podem ser beneficiadas se os alunos praticarem, anteriormente, a lógica de programação em uma linguagem algorítmica cuja sintaxe e semântica se assemelham à sintaxe e semântica da linguagem em questão. Com todos esses aspectos a considerar, este trabalho apresenta o X-Portugol, um interpretador que possibilita ao usuário definir e modificar facilmente as regras léxicas e sintáticas de sua linguagem algorítmica, permitindo adaptar a linguagem a um estilo específico, ou à notação de uma literatura em particular. O interpretador se baseia fortemente na linguagem OMeta (Warth, A. and Piumarta, I. 2007), uma linguagem orientada à objetos para casamento de padrões e, por sua vez, em Parsing Expression Grammar (Ford, 2004) ou PEG, uma fundamentação para descrição sintática baseada em reconhecimento. Neste artigo, apresenta-se na Seção 2 uma introdução às PEGs e à extensão OMeta. A Seção 3 utiliza as noções previamente discutidas para definir a linguagem base do interpretador X-Portugol. Na Seção 4, as técnicas de adaptação léxica e sintática são apresentadas. A Seção 5 apresenta futuras direções e, finalmente, a Seção 6 conclui o trabalho. 2. PEGs e orientação à objeto Ao construir uma linguagem de programação, é comum considerar a prática de definir as regras léxicas e sintáticas utilizando linguagens regulares e gramáticas livres de contexto (GLCs). É certamente razoável supor que a maior parte das implementações de linguagens de programação utiliza estes dois formalismos. Das definições regulares, em geral, são construídos os autômatos finitos correspondentes cuja tarefa é reconhecer padrões léxicos. Das regras gramaticais são construídos os parsers que devem reconhecer a sintaxe da linguagem. Muitas das técnicas empregadas para a construção de compiladores são apresentadas em obras como a de Aho et al. (1995). Uma alternativa a esta abordagem é definir as regras léxicas e sintáticas utilizando PEGs, ou Parsing Expression Grammars. Estas gramáticas, assim como as GLCs, possuem regras na forma A e, onde A é um não-terminal e e é uma expressão de parsing (PE). Tais expressões podem ser compostas por outras expressões em seqüência, similar às GLCs, e alguns operadores podem ser aplicados sobre elas, como * (zero ou mais ocorrências) e + (uma ou mais ocorrências). Nas PEGs, uma regra pode possuir múltiplas definições, por exemplo, utilizando um operador como, mas, diferente das GLCs, as escolhas são prioritárias, ou seja, as tentativas de derivação acontecem sempre na ordem em que as regras são definidas. Portanto, ambigüidades não ocorrem em gramáticas PEGs. Reconhecedores de PEGs podem ser implementados como Packrat Parsers (Ford, 2002). Sobre o conceito das PEGs, a linguagem OMeta se situa como uma extensão que permite o uso de construções encontradas em linguagens orientadas a objetos e admite a aplicação das regras gramaticais sobre dados arbitrários (não só cadeias de caracteres).

3 Cada gramática da linguagem OMeta possui um nome, define um namespace, e pode se relacionar com outra gramática por herança, o que significa que a gramática filha (subgramática) efetivamente herda as regras definidas na gramática mãe (super-gramática). No que diz respeito às regras gramaticais, cada regra pode ter um conjunto de definições e uma ação semântica associada para cada definição, ativada quando os dados de entrada são reconhecidos pela respectiva definição. Tal ação pode ser expressa em uma linguagem de programação específica e, em geral, corresponde à linguagem hospedeira na qual a OMeta foi implementada. Ainda, as regras podem retornar valores (referentes à última expressão reconhecida na definição ou ao valor de sua ação semântica) e estes valores podem ser manipulados associando uma variável à PE correspondente. Cada instância de uma gramática também possui um estado tal qual um objeto em linguagens orientadas à objetos, e as regras e ações semânticas podem consultar os dados do estado e das variáveis associadas às PEs durante o processo de reconhecimento. Para os propósitos deste artigo, uma implementação da linguagem OMeta, chamada de S-OMeta, foi desenvolvida utilizando a linguagem de programação Scheme. Esta implementação utiliza algumas convenções sintáticas, descritas na Tabela 1. Considerando a natureza dinâmica da linguagem Scheme, a facilidade de se definirem ou modificarem regras gramaticais, inclusive em tempo de execução, fica evidente. Ademais, nestes quesitos, esta facilidade dificilmente encontra correspondência quando se adotam técnicas tradicionais de análise léxica e sintática. Regra Tabela 1. Convenções sintáticas da linguagem S-OMeta Descrição da regra A ::= e 1 e2 ; Uma seqüência de PEs. A ::= e 1 e2 ; Escolha prioritária. A ::= ~ e ; Negação da expressão e. A ::= e * ; Zero ou mais ocorrências de e. A ::= e + ; Uma ou mais ocorrências de e. A ::= e? ; Zero ou uma ocorrência de e. A ::= ^; A ::= {e} ; Agrupamento. A ::= Referência à regra A da super-gramática. e : x ; Associa a variável x ao valor da expressão e. A ::= abc ; A ::= `abc`; A ::= abc ; A ::= e => s-expr; Seqüência de caracteres. Seqüência de caracteres seguida, ao final, de zero ou mais espaços em branco. Seqüência de caracteres seguida, ao final, de um ou mais espaços em branco. s-expr é uma ação semântica escrita em Scheme.

4 3. Uma linguagem de algoritmos básica Nesta Seção, é descrita uma linguagem básica para algoritmos em português. A partir desta linguagem básica, aqui chamada de P-Portugol, extensões, modificações ou mesmo novas linguagens derivadas podem ser definidas com base no material descrito na Seção anterior. O algoritmo da Figura 1 apresenta um exemplo de código escrito na linguagem P-Portugol. algoritmo maior_numero; var cont : inteiro; num : inteiro; maior : inteiro; inicio cont <- 0; maior <- 0; enquanto cont <= 10 faca escreva("digite um número"); leia(num); se num > maior entao maior <- num; fim-se cont <- cont + 1; fim-enquanto escreva("o maior número lido:", maior); fim Figura 1. Algoritmo maior_numero escrito em P-Portugol A definição da linguagem P-Portugol escrita em S-OMeta se encontra no anexo A. Regras gramaticais pré-definidas como spaces e digit são descritas na Tabela 2. Cada ação semântica das regras gramaticais é codificada em Scheme e tem como objetivo gerar uma árvore sintática abstrata (AST). Como o propósito deste trabalho é descrever os mecanismos que permitem modificar os termos léxicos e a sintaxe da linguagem, relevam-se os detalhes de análise semântica e execução de códigos que sucedem após a geração da AST e supõe-se a existência destes módulos para a execução dos algoritmos. Expressão space spaces Tabela 2. Regras pré-definidas na linguagem S-Ometa Descrição Qualquer caractere que corresponde a um espaço em branco. Zero ou mais caracteres que correspondem a um espaço em branco. digit Qualquer caractere que representa um digito (0 à 9). alpha-chars Um conjunto de caracteres que formam um identificador (equivalente à expressão regular [a-z][a-z0-9_\-]*). $ Fim da entrada de dados.

5 A linguagem P-Portugol define, então, algumas construções básicas de condição e repetição e permite declarações de variáveis de tipo inteiro, real, caractere e lógico. Os termos da linguagem não utilizam acentos e são oferecidas duas funções, leia e escreva, de entrada e saída, respectivamente. Com a descrição da linguagem P-Portugol, pode-se considerar duas formas de adaptar ou estender a linguagem: Modificando a própria gramática; Criando uma nova gramática que herda as regras de uma super gramática. Modificar a própria gramática oferece a facilidade de se trabalhar com as próprias definições diretamente, permitindo adequá-las ao intento. Por outro lado, as definições que existiam em um momento anterior às modificações são, em princípio, perdidas. Ao se criar, então, uma nova gramática que herda as regras de uma supergramática, as definições da super-gramática são preservadas, e redefinições de regras podem ser feitas na sub-gramática. Com isso, uma linguagem base pode ser útil para diversas derivações, simultaneamente. Tratando-se de algoritmos executáveis, a única restrição que se faz às adaptações nas gramáticas é que a AST gerada ao final do reconhecimento continue sendo aceita nas etapas de backend seguintes (análise semântica, e interpretação, por exemplo). Ainda, com algumas adaptações no backend é possível enriquecer o vocabulário da linguagem algorítmica oferecendo comandos de acesso a arquivos, sockets, controle de elementos de GUI. 4. Adaptando a linguagem Quando se adota um livro como Manzano (2008) para os estudos de lógica de programação e, ao mesmo tempo, se deseja utilizar um interpretador de pseudo-código, é interessante que a notação utilizada no livro seja compatível com a notação que o interpretador é capaz de executar. No entanto, comparando a linguagem P-Portugol com a notação algorítmica do livro em questão, observa-se que existem algumas diferenças léxicas e sintáticas. Para evidenciar estas diferenças, a Figura 2 apresenta uma adaptação do algoritmo da Figura 1 utilizando a notação deste livro. Observa-se, então, que este autor utiliza a palavra-chave programa ao invés de algoritmo e comentários podem ser escritos utilizando-se chaves. As palavras-chave deste livro são acentuadas de acordo com o português, onde em P-Portugol os acentos são ignorados. Algumas sentenças divergem no uso de pontuação final (como o uso do ; ) e, em especial, os comandos escreva e leia divergem na utilização de parênteses para agrupar os parâmetros. Finalmente, as palavras-chave compostas são separadas por - em P-Portugol, onde o autor utiliza _. Para que o algoritmo da Figura 2 seja executado pelo interpretador X-Portugol, é necessário fazer algumas modificações na definição da linguagem P-Portugol.

6 programa maior_numero {algoritmo ilustrativo} var num : inteiro cont : inteiro maior : inteiro início cont <- 0 maior <- 0 enquanto cont <= 10 faça escreva "Digite um número:" leia num se num > maior então maior <- num fim_se cont <- cont + 1 fim_enquanto escreva "O maior número lido:", maior fim Figura 2. O algoritmo maior_numero na notação do livro (Manzano 2008) Utilizando herança, a gramática descrita na Figura 3 apresenta uma definição da linguagem Manzano-Portugol em S-OMeta. Esta gramática herda as regras da supergramática P-Portugol. Considerando apenas a herança, pode-se afirmar que ambas as gramáticas definem a mesma linguagem. Porém, as regras adicionadas em Manzano- Portugol modificam o reconhecimento da linguagem P-Portugol em pontos específicos. ometa Manzano-Portugol <: P-Portugol { space ::= '{' {~'}' _}* '}'? ^ ; fim-sentenca ::= spaces; cmd-escreva ::= escreva expressao:x {`,` expressao}*:xs fim-sentenca => `(escreva,(cons x xs)); cmd-leia ::= leia identificador:x {`,` identificador}*:xs fim-sentenca => `(leia,(cons x xs)); } algoritmo ::= "programa"; inicio ::= "início"; entao ::= "então"; senao ::= "senão"; faca ::= "faça"; fim-se ::= "fim_se"; fim-enquanto ::= "fim_enquanto"; Figura 3. Extensão da linguagem P-Portugol em S-OMeta A primeira regra da gramática, space, sobre-escreve uma regra existente adicionando informações para reconhecer comentários entre chaves. Já a segunda regra, fimsentenca, que originalmente reconhecia um caractere de ponto e vírgula ( ; ) foi sobre-

7 escrita para reconhecer apenas espaços em branco. As regras cmd-escreva e cmd-leia foram alteradas para não obrigar os parênteses em volta dos parâmetros dos respectivos comandos. As demais regras modificam a lexicografia de algumas palavras-chave da linguagem. Dessa forma, com estas extensões, é possível utilizar a gramática Manzano- Portugol para processar o algoritmo da Figura 2. Este mesmo procedimento pode ser aplicado para fazer com que o interpretador seja capaz de reconhecer a linguagem completa utilizada por Manzano (2008), assim como as linguagens utilizadas por Silva (2007) e Vilarim (2004). 5. Futuras direções Atualmente, o interpretador X-Portugol não possui mecanismos sofisticados de identificação e reportagem de erros característica bastante desejável para o público alvo da ferramenta, limitando-se apenas a informar que houve um erro, caso o reconhecimento da entrada não tenha sido bem sucedido. Acredita-se que tais mecanismos possam ser incorporados incrementando a linguagem de casamento de padrões do S-OMeta e permitindo que seja feito reconhecimento de sentenças incorretas associando à elas mensagens de erro específicas tendo, com isso, um alto grau de precisão de reportagem de erros. Um ambiente integrado também pode ser desenvolvido onde as funcionalidades de execução, depuração e checagem de erros sejam facilmente manipuladas pelos usuários. Ainda, o ambiente pode permitir ao usuário escolher qual das linguagens présuportadas, especificamente, ele gostaria de utilizar para escrever algoritmos (ou mesmo, se deseja criar ou derivar uma nova notação!). 6. Conclusões Frente aos problemas encontrados no contexto de ensino-aprendizagem de algoritmos e lógica de programação, softwares que ajudam a ensinar os conceitos relativos ao raciocínio lógico, especialmente quando interagem bem com a literatura utilizada (ou estilo de aula adotado), podem ajudar os estudantes a compreender melhor os conceitos apresentados e debatidos. É, portanto, um sentimento comum que as ferramentas de apoio ao ensinoaprendizagem devem ser desenvolvidas e exploradas no contexto de sala de aula e este artigo apresenta uma ferramenta que pode ajudar a diminuir as barreiras que existem entre as diferentes notações adotadas, dando oportunidade aos professores para definir a notação algorítmica que melhor se encaixa ao estilo de suas aulas ou a literatura em uso, ao mesmo tempo em que permite, com relativa facilidade, a incorporação de novas notações para algoritmos que antes ficavam a cargo da imaginação para serem executados.

8 Referências Aho, Alfred V. and Sethi, Ravi and Ullman, Jeffrey D. (1995), Compiladores Princípios, Técnicas e Ferramentas. Rio de Janeiro, Guanabara Koogan. Ford, B. (2002). Packrat parsing: simple, powerful, lazy, linear time, functional pearl. In Proceedings of the Seventh ACM SIGPLAN international Conference on Functional Programming (Pittsburgh, PA, USA, October 04-06, 2002). ICFP '02. ACM, New York, NY, Ford, B. (2004). Parsing expression grammars: a recognition-based syntactic foundation. In: Proceedings of the 31st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (Venice, Italy, January 14-16, 2004). POPL '04. ACM, New York, NY, Manzano, José Augusto N. G. (2008), Algoritmos: lógica para desenvolvimento de programação. São Paulo: Érica, 21. ed. Silva, Camila Ceccatto da and de Paula, Everaldo A.. (2007), Lógica de Programação: aprendendo a programar. Santa Cruz do Rio Pardo, Editora Viena. Vilarim, Gilvan de Oliveira. (2004), Algoritmos: Programação para Iniciantes. Rio de Janeiro, Editora Ciência Moderna. Warth, A. and Piumarta, I. (2007). OMeta: an object-oriented language for pattern matching. In: Proceedings of the 2007 Symposium on Dynamic Languages (Montreal, Quebec, Canada, October 22-22, 2007). DLS '07. ACM, New York, NY, Anexo A: A definição da linguagem P-Portugol em S-OMeta ometa P-Portugol { algoritmo ::= "algoritmo"; var ::= "var"; inteiro ::= "inteiro"; real ::= "real"; caractere ::= "caractere"; literal ::= "literal"; logico ::= "logico"; inicio ::= "inicio"; escreva ::= "escreva"; leia ::= "leia"; se ::= "se"; entao ::= "entao"; senao ::= "senao"; fim-se ::= "fim-se"; enquanto ::= "enquanto"; faca ::= "faca"; fim-enquanto ::= "fim-enquanto"; vetor ::= "vetor"; de ::= "de"; verdadeiro ::= "verdadeiro"; falso ::= "falso"; fim ::= "fim"; e ::= "e"; ou ::= "ou"; nao ::= "nao";

9 igual ::= `=`; diferente ::= `<>`; maior ::= `>`; menor ::= `<`; maior-igual ::= `>=`; menor-igual ::= `<=`; potencia ::= `^`; simb-atrib ::= `<-`; aspas-literal-abre ::= '"'; aspas-literal-fecha ::= '"'; separador-decimal ::= '.'; fim-sentenca ::= `;`; fim-linha ::= ; portugol ::= spaces declaracao-algoritmo:nome declaracoes-e-comandos:x $ => `(algoritmo,nome,x); declaracoes-e-comandos ::= secao-declaracoes:vars bloco-principal:cmds => `(inicio,vars,cmds); declaracao-algoritmo ::= algoritmo identificador:nome fim-sentenca => nome; secao-declaracoes ::= var declaracoes-de-variaveis; declaracoes-de-variaveis ::= {declaracao-de-variavel:d fim-sentenca=> d}*:d => `(declaracoes,d); declaracao-de-variavel ::= lista-de-variaveis:v `:` tipo-de-dado:t => `(,t,v); lista-de-variaveis ::= identificador:x {`,` identificador}*:xs => (cons x xs); identificador ::= alpha-chars:i spaces => (string->symbol i); tipo-de-dado ::= {inteiro real caractere logico}:x => (string->symbol x); bloco-principal ::= inicio comandos:c fim => `(comandos,c); comandos ::= comando*; comando ::= cmd-atribuicao cmd-escreva cmd-leia cmd-se cmd-enquanto; cmd-atribuicao ::= lhs:l simb-atrib expressao:r fim-sentenca => `(<-,l,r); lhs ::= identificador; cmd-escreva ::= escreva `(` expressao:x {`,` expressao}*:xs `)` fim-sentenca => `(escreva,(cons x xs)); cmd-leia ::= leia `(` identificador:x {`,` identificador}*:xs `)` fim-sentenca => `(leia,(cons x xs)); cmd-se ::= se expressao:e entao comandos:x senao comandos:y fim-se => `(se,e,x,y) se expressao:e então comandos:x fim-se => `(se,e,x);

10 cmd-enquanto ::= enquanto expressao:e faca comandos:x fim-enquanto => `(enquanto,e,x); expressao ::= expr-ou; expr-ou ::= expr-e:x ou expr-e:xs => `(ou,x,xs) expr-e; expr-e ::= expr-rel:x e expr-rel:xs => `(e,x,xs) expr-rel; expr-rel ::= expr-soma:x { igual => '= diferente => '<> menor-igual => '<= maior-igual => '>= menor => '< maior => '> }:o expr-soma:xs => `(,o,x,xs) expr-soma; expr-soma ::= expr-mul:x {`+` => '+ `-` => '-}:o expr-mul:xs => `(,o,x,xs) expr-mul; expr-mul ::= expr-pot:x {`*` => '* `/` => '/ `%` => '%}:o expr-pot:xs => `(,o,x,xs) expr-pot; expr-pot ::= expr-unaria:x potencia expr-unaria:xs => `(^,x,xs) expr-unaria; expr-unaria ::= {`+` => '+ `-` => '- nao => 'nao}:o termo:x => `(,o,x) termo `(` expressao:e `)` => e; termo ::= carac-literal logico-literal real-literal inteiro-literal lhs; logico-literal ::= verdadeiro => #t falso => #f; carac-literal ::= aspas-literal-abre {~aspas-literal-fecha char:c => c}*:cs aspas-literal-fecha => (list->string cs); inteiro-literal ::= digit+:x spaces => (string->number (list->string x)); } real-literal ::= digit+:x separador-decimal digit+:xs spaces => (string->number (list->string (append x '(#\.) xs)));