| 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 apesentado); 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á estever 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, returna-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:
[x123] {Isto é um título}
[] {Isto é outro título}
[w83] {}
[] {}
Este comando já está parcialmente implementado na classe da package pex.textui.evaluator (disponível no CVS): ListSections.
Apresenta o título e todo o conteúdo da secção actual: o texto de cada parágrafo é apresentado por ordem; cada secção é apresentada tal como no caso da apresentação do índice, seguida dos seus parágrafos e subsecções (apresentação recursiva).
Este comando já está parcialmente implementado na classe da package pex.textui.evaluator (disponível no CVS): ShowContent.
Permite seleccionar a secção indicada pelo utilizador (através da especificação do identificador local requestSectionId()). Se a secção indicada não existir, continua na secção actual, sendo apresentada a mensagem noSuchSection(). Caso contrário, é apresentada a mensagem newActiveSection() e o menu de edição de secções é aberto para a secção seleccionada.
Este comando já está parcialmente implementado na classe da package pex.textui.evaluator (disponível no CVS): SelectSection.
Permite inserir uma subsecção antes de outra de referência (indicada pelo identificador local requestSectionId()). É pedido o título (requestSectionTitle()) da nova secção. Se a subsecção de referência não existir, insere a nova subsecção no final da secção actual.
Este comando já está parcialmente implementado na classe da package pex.textui.evaluator (disponível no CVS): InsertSection.
Permite atribuir um identificador único (no contexto do documento) a uma secção. É pedido o identificador local (inteiro) da subsecção a identificar (requestSectionId()) e o identificador único a atribuir (requestUniqueId()) (cadeia de caracteres). Se a secção não existir é apresentada a mensagem noSuchSection() e a acção termina. Se o identificador já existir, passa a designar a nova secção (a ligação anterior é destruída). Se a secção já tiver um identificador, a mensagem de aviso sectionNameChanged() é apresentada e é atribuído o novo identificador único à secção.
Este comando já está parcialmente implementado na classe da package pex.textui.evaluator (disponível no CVS): NameSection.
Permite remover a secção indicada pelo utilizador através do identificador local (requestSectionId()). Se a secção indicada não existir, apresenta a mensagem noSuchSection() e não realiza nenhuma acção.
Este comando já está parcialmente implementado na classe da package pex.textui.evaluator (disponível no CVS): RemoveSection.
Permite inserir um novo parágrafo antes de outro parágrafo da secção actual. É pedido o número do parágrafo de referência (requestParagraphId()) e o texto do novo parágrafo (requestParagraphContent()). Se o parágrafo de referência não existir, insere o novo parágrafo no final da sequência de parágrafos da secção.
Este comando já está parcialmente implementado na classe da package pex.textui.evaluator (disponível no CVS): InsertParagraph.
Permite atribuir um identificador único (no contexto do documento) a um parágrafo. É pedido o número do parágrafo a identificar (requestParagraphId()) e o identificador único a atribuir (requestUniqueId()) (cadeia de caracteres). Se o parágrafo não existir é apresentada a mensagem noSuchParagraph() e a acção termina. Se o identificador já existir, passa a designar o novo parágrafo (a ligação anterior é destruída). Se o parágrafo já tiver um identificador, a mensagem de aviso paragraphNameChanged() é apresentada e é atribuído o novo identificador único ao parágrafo.
Este comando já está parcialmente implementado na classe da package pex.textui.evaluator (disponível no CVS): NameParagraph.
Permite alterar o texto do parágrafo indicado. É pedido o número do parágrafo a alterar (requestParagraphId()) e o texto do novo parágrafo (requestParagraphContent()). Se o parágrafo indicado não existir, apresenta a mensagem noSuchParagraph() e não realiza nenhuma acção.
Este comando já está parcialmente implementado na classe da package pex.textui.evaluator (disponível no CVS): EditParagraph.
Permite remover o parágrafo indicado pelo utilizador (requestParagraphId()). Se o parágrafo indicado não existir, apresenta a mensagem noSuchParagraph() e não realiza nenhuma acção.
Este comando já está parcialmente implementado na classe da package pex.textui.evaluator (disponível no CVS): RemoveParagraph.
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.