AVISOS - Avaliação em Época Normal |
---|
Esclarecimento de dúvidas:
|
Requisitos para desenvolvimento, material de apoio e actualizações do enunciado (ver informação completa em Projecto de Programação com Objectos):
|
Processo de avaliação (ver informação completa em Avaliação do Projecto):
|
Material de Uso Obrigatório |
---|
As bibliotecas po-uuilib e o conteúdo inicial do CVS são de uso obrigatório: |
|
A máquina virtual, fornecida para desenvolvimento do projecto, já contém todo o material de apoio. |
Uso Obrigatório: Repositório CVS |
Apenas se consideram para avaliação os projectos existentes no repositório CVS oficial.
Trabalhos não presentes no repositório no final do prazo têm classificação 0 (zero) (não são aceites outras formas de entrega). Não são admitidas justificações para atrasos em sincronizações do repositório. A indisponibilidade temporária do repositório, desde que inferior a 24 horas, não justifica atrasos na submissão de um trabalho. |
O objectivo do projecto é criar uma aplicação que permite ver e gerir um conjunto de expressões.
Neste texto que se segue, o tipo negrito indica um literal (i.e., é exactamente como apresentado); o símbolo indica um espaço; e o tipo itálico indica uma parte variável (i.e., uma descrição).
A calculadora permite interpretar e avaliar expressões. Possui também várias formas de preservar o seu estado.
As expressões, apresentadas à calculadora em forma de texto, devem ser interpretadas antes de serem armazenadas. O texto original não é preservado.
O texto de uma expressão a interpretar pode ser providenciado via interface da própria calculadora ou na forma de um ficheiro que contém a expressão.
A falha de interpretação de uma expressão causa o lançamento da excepção pex.ParserException.
A calculadora permite associar expressões a identificadores, preservando-as. Note-se que isto não corresponde a guardar o valor da expressão, mas a guardar toda a informação sobre a expressão, resultante da interpretação da forma textual. Se o identificador já estiver em uso, a associação à expressão anterior é perdida.
A calculadora permite, dado um identificador, recuperar a expressão a ele associada. Se o identificador não tiver sido definido, o valor nulo é retornado e o identificador mantém-se indefinido.
Os identificadores definidos na calculadora podem ser utilizados na escrita de novas expressões, antes ou depois de terem sido definidos (são sempre avaliados quando a expressão onde ocorrem é avaliada, i.e., não são "expandidos" quando a expressão onde ocorrem é interpretada).
A avaliação de expressões guardadas na calculadora é feita de forma flexível, sendo possível -- sem alterar o código das expressões ou da calculadora -- definir novas formas de avaliação. O avaliador por omissão calcula simplesmente o valor de uma expressão.
Uma outra "avaliação" possível é a produção de descrições textuais a partir de expressões (isto permite recuperar a forma inicial das expressões).
É possível escrever todo o conteúdo da calculadora como uma sequência de atribuições de expressões a identificadores (ficheiro textual). Desta forma, o resultado da avaliação dessa sequência é indistinguível do conteúdo original da calculadora.
É possível reiniciar, guardar e recuperar a sessão de interacção com o utilizador.
Uma expressão é uma representação algébrica de uma quantidade: todas as expressões têm um tipo e devolvem um valor.
Uma expressão pode ser descrita por uma linguagem cuja interpretação resulta na representação dessa expressão como uma estrutura de dados, sobre a qual pode ser executado o processo de avaliação, para determinação do valor da expressão.
Neste documento utiliza-se uma linguagem simples e uniforme para descrever qualquer expressão, que pode ser categorizada como expressão primitiva (literais e identificadores) ou como expressão composta (operadores).
As expressões primitivas, ou representam directamente um valor (expressões literais), ou referem outra expressão (identificadores).
As expressões literais são de três tipos: inteiros, reais e cadeias de caracteres.
São iniciados por uma letra, seguindo-se 0 (zero) ou mais letras ou dígitos. O comprimento do nome é ilimitado e dois nomes são distintos se houver alteração de maiúscula para minúscula, ou vice-versa, de pelo menos um carácter.
Os valores das expressões compostas correspondem à avaliação de um operador sobre os seus argumentos. O tipo de argumentos e de resultado depende do operador: alguns operadores podem aceitar vários tipos de argumentos e produzir vários tipos de resultados, enquanto outros podem restringir tanto os tipos dos argumentos como o do resultado.
O formato de representação de uma expressão composta é como se segue:
( nome-do-operador argumento-1 ... argumento-N )
Alguns operadores têm um número fixo de argumentos, enquanto outros têm um número variável de argumentos (operadores variádicos).
Exemplos:
Os vários operadores e a correspondente semântica são apresentados na tabela. A maioria dos operadores segue a semântica da família da linguagem C, excepto onde explicitamente indicado. Tal como em C, os valores lógicos são 0 (zero) (valor falso), e diferente de zero (valor verdadeiro).
Designação | Operadores | Operandos | Semântica |
aritméticos (unários) | neg | inteiros, reais | C |
---|---|---|---|
aritméticos (binários) | add, sub, mul, div, mod | inteiros, reais | C -- mod é apenas para inteiros |
comparação (binários) | lt le ge gt | inteiros, reais, strings | C -- Para cadeias de caracteres, como strcmp |
igualdade (binários) | eq ne | inteiros, reais | C -- Para cadeias de caracteres, como strcmp |
lógicos (unários) | not | inteiros | C |
lógicos (binários) | and or | inteiros | C -- Para and, o 2º argumento só é avaliado se o 1º não for falso. Para or, o 2º argumento só é avaliado se o 1º não for verdadeiro. |
atribuição (binário) | set | todos os tipos | O valor da expressão (2º argumento) é associado ao identificador (1º argumento). O valor da expressão é o do seu 2º argumento. |
sequência (variádico) | seq | todos os tipos | As sub-expressões são avaliadas em sequência. O valor da expressão é o do seu último argumento. |
impressão (variádico) | todos os tipos | As sub-expressões são avaliadas em sequência e os valores correspondentes apresentados na saída. O valor da expressão é o do seu último argumento. | |
leitura (sem argumentos) | readi, readr, reads | inteiros, reais, cadeias de caracteres (respectivamente) | Pedem a introdução (pelo utilizador) de valores com os tipos correspondentes. |
condicional (trenário) | if | condição (1º argumento) deve ser inteira | C -- Comporta-se de modo semelhante ao do operador trenário ?: (não exige concordância de tipos entre os 2º e 3º argumentos). Apenas é avaliado o argumento correspondente ao valor lógico indicado pela condição. |
ciclo (binário) | while | condição (1º argumento) deve ser inteira | Avalia o 1º argumento: se o valor lógico for falso, retorna-o; se o valor lógico for verdadeiro, avalia o 2º argumento, após o que reinicia o ciclo com nova avaliação do 1º argumento, etc. O valor da expressão é o valor da mais recente avaliação do seu primeiro argumento. |
Os exemplos seguintes apresentam casos de uso simples dos operadores acima.
Exemplo 1: sequência com 3 expressões (valor 9):
Exemplo 2: seuência com 5 expressões (valor "olá"):
Exemplo 3: sequência com 2 expressões (valor final 0) (note-se que esta sequência corresponde a um pequeno "programa" que apresenta o valor do identificador ix na saída):
Descreve-se nesta secção a funcionalidade máxima da interface com o utilizador. Em geral, os comandos pedem toda a informação antes de proceder à sua validação (excepto onde indicado). Todos os menus têm automaticamente a opção Sair (fecha o menu).
As operações de leitura e escrita devem realizar-se através do objecto ist.po.ui.Dialog.IO. As mensagens são produzidas pelos métodos das bibliotecas de suporte (po-uilib e pex-support). As mensagens não podem ser usadas no núcleo da aplicação ("core"). Além disso, não podem ser definidas novas. Potenciais omissões devem ser esclarecidas antes de qualquer implementação.
As excepções usadas na interacção, excepto se indicado, são subclasses de ist.po.ui.DialogException, são lançadas pelos comandos e tratadas por ist.po.ui.Menu. Outras excepções não devem substituir as fornecidas nos casos descritos.
Note-se que os comandos e menus a seguir descritos, assim como o programa principal, já estão parcialmente implementados nas classes das packages pex.textui, pex.textui.main e pex.textui.evaluator. Estas classes são de uso obrigatório e estão disponíveis no CVS (módulo pex-textui).
As acções do menu, listadas em pex.textui.main.MenuEntry, permitem gerir a salvaguarda do estado da aplicação, assim como operar sobre o documento actual: Criar, Abrir, Guardar, Guardar Textualmente e Editar. A classe pex.textui.main.Message define os métodos para geração das mensagens de diálogo. Inicialmente, a aplicação tem uma calculadora vazia.
O conteúdo do documento pode ser guardado para posterior recuperação (via serialização Java: java.io.Serializable). Na leitura e escrita do estado da aplicação, devem ser tratadas as excepções associadas. A funcionalidade é a seguinte:
A opção Sair nunca guarda o estado da aplicação, mesmo que existam alterações.
Estes comandos já estão parcialmente implementados nas classes da package pex.textui.main (disponível no CVS): New, Open, Save, WriteDescription.
Abre o menu de edição (alteração) da calculadora e do seu conteúdo.
Este comando já está parcialmente implementado na classe da package pex.textui.main (disponível no CVS): Edit.
Este menu permite efectuar operações sobre um documento. A lista completa é a seguinte: Listar identificadores, Mostrar identificador, Definir identificador, Renomear identificador, Remover identificador.
As etiquetas das opções deste menu estão definidas na classe pex.textui.evaluator.MenuEntry. Todos os métodos correspondentes às mensagens de diálogo para este menu estão definidos na classe pex.textui.evaluator.Message.
Em todos os casos, só podem ser indicados secções e parágrafos filhos da secção actual. O documento é estruturalmente semelhante a uma secção, sendo considerado a secção raiz (na primeira abertura deste menu).
É apresentada a lista de títulos de todas as subsecções da secção actual (recursivamente): cada título entre chavetas é precedido pelo seu identificador único entre parênteses rectos (ou só os parânteses, caso o identificador não esteja definido). Se algum título for vazio, apresentam-se apenas as chavetas.
Exemplos (existindo 3 identificadores em memória):
a b c
Este comando já está parcialmente implementado na classe pex.textui.evaluator.ListIdentifiers (disponível no CVS).
Permite apresentar o identificador, a expressão a ela associada e o resultado da correspondente avaliação (assim, como possíveis efeitos secundários). O identificador a apresentar é indicado através da especificação do identificador requestId(). Se o identificador indicado não existir, deve ser apresentada a mensagem noSuchIdentifier().
Exemplos:
a (add 1 3) 4
Este comando já está parcialmente implementado na classe pex.textui.evaluator.ShowIdentifier (disponível no CVS).
Permite definir um novo identificador ou substituir a expressão de um previamente definido. O identificador a definir é indicado através da especificação do identificador requestId(). A especificação textual da nova expressão é indicada através de requestExpression(). Se o identificador indicado já existir, deve ser apresentada a mensagem identifierRedefined(). A nova expressão é interpretada: se a excepção pex.ParserException (do "core") for recebida, então a excepção pex.textui.BadExpressionException deve ser lançada pelo comando.
Este comando já está parcialmente implementado na classe pex.textui.evaluator.RegisterIdentifier (disponível no CVS).
Permite renomear um identificador e associar a sua expressão ao novo nome. O identificador a renomear é indicado através da especificação do identificador requestId(). O novo nome é indicado através de requestNewId(). Se o identificador a renomear não existir, deve ser apresentada a mensagem noSuchIdentifier().
Este comando já está parcialmente implementado na classe pex.textui.evaluator.RenameIdentifier (disponível no CVS).
Permite remover um identificador. O identificador a renomear é indicado através da especificação do identificador requestId(). O novo nome é indicado através de requestNewId(). Se o identificador a renomear não existir, deve ser apresentada a mensagem noSuchIdentifier().
A remoção do identificador torna inacessível a expressão a ele associada. Se existirem expressões que refiram o identificador, então deve ser apresentada a mensagem identifierInUse() e o identificador não deve ser removido.
Este comando já está parcialmente implementado na classe da pex.textui.evaluator.RemoveIdentifier (disponível no CVS).
Além das opções de manipulação de ficheiros descritas no menu principal, é possível iniciar a aplicação com um ficheiro de texto especificado pela propriedade Java import. Este ficheiro contém uma expressão que é avaliada pela calculadora, podendo ser usado como forma cómoda de inicialização da sua memória (através de expressões set). Se não existirem definições de variáveis, a avaliação não deixa traços na memória da calculadora. Apenas é lida a primeira expressão presente no ficheiro.
Note-se que, neste exemplo, a sequência de topo garante que são lidas todas as outras. Note-se também que, apesar de nenhuma sequência ser memorizada, o identificador ix fica registado (associado à expressão correspondente ao último valor da iteração).
(seq (seq (add 1 2.3) (sub 1 2) (mul (add 1 2) 3)) (seq (add 1 2.3) (sub 1 2) (mul (add 1 2) 3.2) (div 2 0) "olá") (seq (set ix 0) (while (lt ix 30) (seq (print "ix =" ix) (set ix (add ix 1))))))
Este exemplo corresponde a um pequeno "programa" (triangulos.pex) para verificar se três segmentos de recta formam um triângulo. Tal como no exemplo anterior, os identificadores a, b e c ficam associados a valores usados durante a avaliação, embora a expressão do "programa" não seja memorizada.
(seq (print "Introduza as dimensões do 1º lado do triângulo: ") (set a (readi)) (print "Introduza as dimensões do 2º lado do triângulo: ") (set b (readi)) (print "Introduza as dimensões do 3º lado do triângulo: ") (set c (readi)) (if (lt a 1) (print "As dimensões dos lados do triângulo devem ser positivas") (if (lt b 1) (print "As dimensões dos lados do triângulo devem ser positivas") (if (lt c 1) (print "As dimensões dos lados do triângulo devem ser positivas") (if (le (add a b) c) (print "Não é um triângulo") (if (le (add a c) b) (print "Não é um triângulo") (if (le (add c b) a) (print "Não é um triângulo") (if (eq a b) (if (eq b c) (print "Triângulo equilátero") (print "Triângulo isósceles")) (if (eq b c) (print "Triângulo isósceles") (print "Triângulo escaleno"))))))))))
A calculadora pode produzir ficheiros textuais com o conteúdo da sua memória, mas nunca os lê a partir de nenhum comando.
Embora o interpretador de expressões da calculadora tenha de assinalar problemas relativos à interpretação de expressões mal especificadas, assume-se que não há entradas mal-formadas nestes ficheiros (embora tenham de ser detectadas).
Devem ser possíveis extensões ou alterações de funcionalidade com impacto mínimo no código já produzido para a calculadora. O objectivo é aumentar a flexibilidade da aplicação relativamente ao suporte de novas funções. Em particular, a solução encontrada para salvaguardar textualmente o conteúdo do documento deve ser suficientemente flexível de modo a permitir visualizar o conteúdo de um documento noutro formato (por exemplo, XML) sem que isso implique alterações no código core da aplicação.
Usando os ficheiros test.pex, test.in e test.out, é possível verificar automaticamente o resultado correcto do programa. Note-se que é necessária a definição apropriada da variável CLASSPATH (ou da opção equivalente -cp do comando java), para localizar as classes do programa, incluindo a que contém o método correspondente ao ponto de entrada da aplicação (pex.textui.App.main). As propriedades são tratadas automaticamente pelo código de apoio.
java -Dimport=test.pex -Din=test.in -Dout=test.outhyp pex.textui.App
Assumindo que aqueles ficheiros estão no directório onde é dado o comando de execução, o programa produz o ficheiro de saída test.outhyp. Em caso de sucesso, os ficheiros das saídas esperada (test.out) e obtida (test.outhyp) devem ser iguais. A comparação pode ser feita com o comando:
diff -b test.out test.outhyp
Este comando não deve produzir qualquer resultado quando os ficheiros são iguais. Note-se, contudo, que este teste não garante o correcto funcionamento do código desenvolvido, apenas verificando alguns aspectos da sua funcionalidade.