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. |
Contents |
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).
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):
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 (estrutura). Se o identificador esteiver já em uso, a associação à expressão anterior é perdida.
A calculadora permite ainda, 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.
É 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.
Além disso, é ainda possível reiniciar, guardar e recuperar a sessão de interacção com o utilizador.
Descreve-se abaixo 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 edt-support). As mensagens não podem ser usadas no núcleo da aplicação. 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 edt.textui, edt.textui.main e edt.textui.section. Estas classes são de uso obrigatório e estão disponíveis no CVS (módulo edt-textui).
As acções do menu, listadas em edt.textui.main.MenuEntry, permitem gerir a salvaguarda do estado da aplicação, assim como operar sobre o documento actual: Criar, Abrir, Guardar, Listar meta-informação, Adicionar autor, Listar secções, Mostrar elemento de texto e Editar. A classe edt.textui.main.Message define os métodos para geração das mensagens de diálogo. Inicialmente, a aplicação tem um documento vazio e anónimo.
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:
Apenas existe um documento no editor (explicitamente criado ou aberto). A opção Sair nunca guarda o estado da aplicação, mesmo que existam alterações.
Estes três comandos já estão parcialmente implementados nas classes da package edt.textui.main (disponível no CVS): New, Open, Save.
É apresentada a seguinte informação: título do documento, autores do documento (ordem alfabética), número de secções de topo do documento, dimensão do documento (bytes) e número de identificadores únicos (das secções e parágrafos do documento). Cada linha é gerada por uma mensagem de edt.textui.main.Message.
Título: título do documento Autor: nome do autor 1/email do autor 1 ... Autor: nome do autor N/email do autor N Secções de topo: número de secções de topo Dimensão do documento (bytes): dimensão do documento (soma da dimensão dos títulos e dos parágrafos) Identificadores únicos: número de identificadores
Este comando já está parcialmente implementado na classe da package edt.textui.main (disponível no CVS): ShowMetadata.
É pedido o nome (requestAuthorName()) e o email (requestEmail()) do novo autor. Se o nome já estiver associado ao documento, apresenta a mensagem duplicateAuthor() e não executa nenhuma acção.
Este comando já está parcialmente implementado na classe da package edt.textui.main (disponível no CVS): AddAuthor.
É apresentada a lista de títulos de todas as secções de topo do documento (um título por linha): 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). O título do documento deve ser apresentado antes da lista de secções, tal como os títulos das secções (entre chavetas). Se algum título for vazio, apresentam-se apenas as chavetas. Note-se que apesar de o documento tem uma estrutura semelhante à das secções, não possui identificador, pelo que o seu título não é precedido de nenhuma marca identificação (nem sequer parênteses rectos vazios).
Exemplos:
{Título do documento} [x123] {Isto é um título} [] {Isto é outro título} [w83] {} [] {}
Este comando já está parcialmente implementado na classe da package edt.textui.main (disponível no CVS): ShowIndex.
Permite apresentar o conteúdo do elemento de texto indicado pelo utilizador (através da especificação do identificador único requestElementId()). Se o elemento de texto não existir, é apresentada a mensagem noSuchTextElement() e a acção termina. Caso contrário, é apresentado o conteúdo. Se o elemento de texto for um parágrafo, apresenta-se simplesmente o seu texto. Se for uma secção, apresenta-se tal como especificado em mostrar conteúdo.
Este comando já está parcialmente implementado na classe da package edt.textui.main (disponível no CVS): ShowTextElement.
Abre o menu de edição (alteração) do documento e do seu conteúdo, estabelecendo como secção actual o nível de topo do documento.
Este comando já está parcialmente implementado na classe da package edt.textui.main (disponível no CVS): Edit.
Este menu permite efectuar operações sobre um documento. A lista completa é a seguinte: Alterar título, Listar secções, Mostrar conteúdo, Ir para secção, Inserir secção, Nomear secção, Remover secção, Inserir parágrafo, Nomear parágrafo, Alterar parágrafo, Remover parágrafo.
As etiquetas das opções deste menu estão definidas na classe edt.textui.section.MenuEntry. Todos os métodos correspondentes às mensagens de diálogo para este menu estão definidos na classe edt.textui.section.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).
Permite alterar o título da secção actual (ou do próprio documento). Para tal, pede-se o novo título (requestSectionTitle()).
Este comando já está parcialmente implementado na classe da package edt.textui.section (disponível no CVS): ChangeTitle.
É 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 edt.textui.section (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 edt.textui.section (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 edt.textui.section (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 edt.textui.section (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 edt.textui.section (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 edt.textui.section (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 edt.textui.section (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 edt.textui.section (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 edt.textui.section (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 edt.textui.section (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 (apresentada abaixo; este exemplo está no ficheiro test.import). Estes dados são apenas uma forma cómoda de inicialização e nunca são produzidos pela aplicação (nem mesmo para salvaguardar o estado para execuções futuras). Quando se especifica a propriedade, o sistema de ficheiros é povoado com as entidades do ficheiro indicado (uma por linha).
Nestes ficheiros, as secções são sempre filhas do documento e os parágrafos pertencem à secção criada mais recentemente (ou ao documento, se não tiverem sido ainda criadas secções).
Assume-se que não há entradas mal-formadas (nestes ficheiros, as secções têm sempre identificador; os parágrafos não são identificados). Sugere-se a utilização do método String.split, para dividir uma cadeia de caracteres em campos.
Objects in Space Obi-Wan Kenobi/ob1@tatooine.geocities.com|Master Yoda/yoda@dagobah.net|Luke Skywalker/luke@jedi.org SECTION|lfd|A Walk in the Desert PARAGRAPH|These aren't the droids you're looking for. SECTION|wm|Patience You Must Have PARAGRAPH|Do or do not. PARAGRAPH|There is no try. SECTION|dvls|Drama in the Clouds PARAGRAPH|Obi-Wan never told you what happened to your father. PARAGRAPH|He told me enough! He told me YOU killed him. PARAGRAPH|NOOOOOOOOOOOOOOOOOOO...
O editor nunca produz ficheiros neste formato, nem os pode ler a partir de nenhum menu.
Devem ser possíveis extensões ou alterações de funcionalidade com impacto mínimo no código já produzido para o editor de texto. O objectivo é aumentar a flexibilidade da aplicação relativamente ao suporte de novas funções. Em particular, a solução encontrada para visualizar o conteúdo do documento deve ser suficientemente flexível por forma a que se possa 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.import, 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 (edt.textui.TextEditor.main). As propriedades são tratadas automaticamente pelo código de apoio.
java -Dimport=test.import -Din=test.in -Dout=test.outhyp edt.textui.TextEditor
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.