wtf (1) (PDF)

/*
========================================================================
ITEM.H
========================================================================
*/
#ifndef ITEM_H
#define ITEM_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*
========================================================================
Estruturas
========================================================================
*/
typedef struct Mensagem {
int emissor;
int recetor;
char *texto;
} Mensagem, *Item;
/*
========================================================================
Macros
========================================================================
*/
/*
Imprime a representacao externa do Item no stdout.
@param item - Item a imprimir.
*/
#define ItemPrint(item) printf("%d %d %s\n", (item)->recetor, (item)>emissor, (item)->texto)
/*
========================================================================
Construtor
========================================================================
*/
/*
Cria um novo Item, reservando a memoria necessaria para os seus
componentes.
@param emissor - Emissor da mensagem.
@param recetor - Recetor da mensagem.
@param mensagem - Mensagem enviada pelo emissor.
@return Pointer para o novo Item criado.
*/
Item ItemCreate(int emissor, int recetor, char *mensagem);
/*

Destroi um Item, libertando a sua memoria.
@param item - Item a destruir.
*/
void ItemDestroy(Item item);
/*
========================================================================
Funcoes
========================================================================
*/
/*
Compara dois Items, pelo conteudo dos seus textos.
Caso contenham o mesmo texto, compara os seus emissores.
@param itemA, itemB - Pointers para os Items a comparar.
@return Um numero negativo se itemA for antes do itemB,
um numero positivo se itemA for depois do itemB,
0 se itemA for igual a itemB.
*/
int ItemCompare(const void* itemA, const void* itemB);
#endif /* ITEM_H */
/*
========================================================================
ITEM.C
========================================================================
*/
#include "Item.h"
/*
========================================================================
Construtor
========================================================================
*/
/*
Cria um novo Item, reservando a memoria necessaria para os seus
componentes.
*/
Item ItemCreate(int emissor, int recetor, char *mensagem){
Item ItemNovo = (Item) malloc(sizeof(Mensagem));
ItemNovo->emissor = emissor;
ItemNovo->recetor = recetor;
ItemNovo->texto = (char*)malloc(sizeof(char)*(strlen(mensagem)+1));
strcpy(ItemNovo->texto, mensagem);
return ItemNovo;
}
/*
Destroi um Item, libertando a sua memoria.
*/
void ItemDestroy(Item item){

free(item->texto);
free(item);
}
/*
========================================================================
Funcoes
========================================================================
*/
/*
Compara dois Items, pelo conteudo dos seus textos.
Caso contenham o mesmo texto, compara os seus emissores.
*/
int ItemCompare(const void* itemA, const void* itemB){
int diferenca;
if (0 != (diferenca = strcmp((*((Item*)itemA))->texto,
(*((Item*)itemB))->texto)))
return diferenca;
else
return (*((Item*)itemA))->emissor - (*((Item*)itemB))->emissor;
}
/*
========================================================================
QUEUE.H
========================================================================
*/
#ifndef QUEUE_H
#define QUEUE_H
#include <stdio.h>
#include <stdlib.h>
#include "Item.h"
/*
========================================================================
Estruturas
========================================================================
*/
typedef struct Node{
Item item;
struct Node * next;
} *Link, Node;
typedef struct Queue{
Link first;
Link last;
int size;
} Queue, *pQueue;
/*
========================================================================
Prototipos
========================================================================
*/

/*
Cria uma lista de pointers para Queues, com o tamanho definido.
@param nSize - Tamanho da lista a criar.
@return Pointer para a nova lista criada.
*/
pQueue QueueListCreate(int nSize);
/*
Destroi uma lista de Queues, juntamente com as Queues constituintes.
@param queueList - Lista a destruir.
@param nSize - Tamanho da lista a destruir.
*/
void QueueListDestroy(pQueue queueList, int nSize);
/*
Destroi todos os Items de uma Queue.
@param queue - Pointer para a Queue a destruir.
*/
void QueueClear(pQueue queue);
/*
Remove o primeiro Node da Queue, devolvendo o Item correspondente.
Caso a Queue esteja vazia, devolve NULL.
@param queue - Pointer para a Queue a remover o primeiro Node.
@return Item correspondente ao primeiro Node da Queue,
NULL caso a Queue esteja vazia.
*/
Item QueuePop(pQueue queue);
/*
Adiciona um Item ao fim da Queue.
@param queue - Pointer para a Queue a adicionar o Item.
@param item - Item a adicionar a Queue.
*/
void QueuePush(pQueue queue, Item item);
/*
Cria e devolve uma nova Array com os elementos da Queue.
Caso a Queue esteja vazia, devolve NULL.
@param queue - Pointer para a Queue a converter para uma Array.
@return Uma nova Array com os elementos da Queue,
NULL caso a Queue esteja vazia.
*/
Item* QueueToArray(pQueue queue);
/*
Imprime a representacao externa de cada Item da Queue no stdout.
Caso a Queue esteja vazia, imprime NULL.
@param queue - Pointer para a Queue a imprimir para o stdout.
*/
void QueuePrint(pQueue queue);
#endif /* QUEUE_H */

/*
========================================================================
QUEUE.C
========================================================================
*/
#include "Queue.h"
/*
========================================================================
Construtor
========================================================================
*/
/*
Cria uma lista de pointers para Queues, com o tamanho definido.
*/
pQueue QueueListCreate(int nSize){
pQueue queueList = (pQueue) malloc(nSize * sizeof(Queue));
for(nSize--; nSize >= 0; nSize--)
{
(queueList+nSize)->first=NULL;
(queueList+nSize)->last=NULL;
(queueList+nSize)->size = 0;
}
return queueList;
}
/*
Destroi uma lista de Queues, juntamente com as Queues constituintes.
*/
void QueueListDestroy(pQueue queueList, int nSize){
while (nSize--)
QueueClear(&queueList[nSize]);
free(queueList);
}
/*
========================================================================
Funcoes
========================================================================
*/
/*
Destroi todos os Items de uma Queue.
*/
void QueueClear(pQueue queue){
Link cursor, del;
for (del = cursor = queue->first; cursor != NULL; del = cursor)
{
cursor = cursor->next;
ItemDestroy(del->item);
free(del);
}

/* Reset ao estado da Queue */
queue->first = NULL;
queue->last = NULL;
queue->size = 0;
}
/*
Remove o primeiro Node da Queue, devolvendo o Item correspondente.
Caso a Queue esteja vazia, devolve NULL.
*/
Item QueuePop(pQueue queue){
Item item;
Link del;
if (queue->size == 0)
return NULL;
item = queue->first->item;
del = queue->first;
/* Coloca o segundo Node no inicio da Queue */
queue->first = queue->first->next;
if (--queue->size == 0)
queue->last = NULL;
free(del);
return item;
}
/*
Adiciona um Item ao fim da Queue.
*/
void QueuePush(pQueue queue, Item item){
Link newNode;
/* Cria um Node para o novo Item */
newNode = (Link)malloc(sizeof(Node));
newNode->item = item;
newNode->next = NULL;
/* Adiciona-o ao fim da Queue */
(queue->first == NULL) ? (queue->first = newNode) : (queue->last>next = newNode);
queue->last = newNode;
queue->size++;
}
/*
Cria e devolve uma nova Array com os elementos da Queue.
Caso a Queue esteja vazia, devolve NULL.
*/
Item* QueueToArray(pQueue queue){
Item *list, *listCursor;
Link cursor;
if (queue->size == 0)
return NULL;

listCursor = list = (Item*) malloc(queue->size * sizeof(Item));
for (cursor = queue->first; cursor != NULL; cursor = cursor->next)
{
*listCursor = (cursor->item);
listCursor++;
}
return list;
}
/*
Imprime a representacao externa de cada Item da Queue no stdout.
Caso a Queue esteja vazia, imprime NULL.
*/
void QueuePrint(pQueue queue){
if(queue->size == 0)
printf("NULL\n");
else {
Link cursor;
for(cursor = queue->first; cursor != NULL; cursor = cursor->next)
ItemPrint(cursor->item);
}
}
/*
========================================================================
MAIN.C
========================================================================
*/
/* Ricardo Tavares 78474, Micael Batista 78941, Filipe Magalhaes 79118,
IAED 2semestre 2014*/
#include
#include
#include
#include
#include
#define
#define
#define
#define

<stdio.h>
<stdlib.h>
<string.h>
"Item.h"
"Queue.h"

TRUE 1
FALSE 0
BUFFERSIZE 501
CMDBUFFERSIZE 11

/*
========================================================================
Prototipos
========================================================================
*/
/*
Comando: send
Sintaxe: "send <emissor> <recetor> <texto>"
Regista o <texto> enviado pelo <emissor> para o <recetor>.
O <texto> tem um tamanho maximo de 500 caracteres, incluindo espacos.

@param queueList - Lista onde estao os queues para as mensagens de
cada utilizador.
*/
void send(pQueue queueList);
/*
Comando: process
Sintaxe: "process <utilizador>"
Imprime a proxima mensagem destinada ao <utilizador> (ou NULL caso
nao exista),
apagando-a dos registos do sistema.
@param queueList - Lista onde estao os queues para as mensagens de
cada utilizador.
*/
void process(pQueue queueList);
/*
Comando: list
Sintaxe: "list <utilizador>"
Imprime todas as mensagens em espera destinadas ao <utilizador>,
ordenadas por ordem de chegada (ou NULL caso nao exista nenhuma).
@param queueList - Lista onde estao os queues para as mensagens de
cada utilizador.
*/
void list(pQueue queueList);
/*
Comando: listsorted
Sintaxe: "listsorted <utilizador>"
Imprime todas as mensagens em espera destinadas ao <utilizador>,
ordenadas por ordem alfabetica (ou NULL caso nao exista nenhuma).
Nota: Caso duas mensagens sejam iguais, a ordenacao segue o indice
do emissor, por ordem crescente.
@param queueList - Lista onde estao os queues para as mensagens de
cada utilizador.
*/
void listsorted(pQueue queueList);
/*
Comando: kill
Sintaxe: "kill <utilizador>"
Apaga todas as mensagens em espera destinadas ao <utilizador>.
@param queueList - Lista onde estao os queues para as mensagens de
cada utilizador.
*/
void kill(pQueue queueList);
/*
========================================================================
Main
========================================================================
*/
int main(void){
int nUtilizadores;

char strCommand[CMDBUFFERSIZE];
Queue *queueList;
/* Pede o numero de utilizadores */
scanf("%d", &nUtilizadores);
/* Inicializa a lista onde estao os queues para as mensagens de cada
utilizador */
queueList = QueueListCreate(nUtilizadores);
/* Ciclo de interpretacao de comandos */
while (TRUE)
{
scanf("%s", strCommand);
if (!strcmp(strCommand, "send"))
send(queueList);
else if (!strcmp(strCommand, "process"))
process(queueList);
else if (!strcmp(strCommand, "list"))
list(queueList);
else if (!strcmp(strCommand, "listsorted"))
listsorted(queueList);
else if (!strcmp(strCommand, "kill"))
kill(queueList);
else if (!strcmp(strCommand, "quit"))
{
/* Limpa todas as mensagens do sistema */
QueueListDestroy(queueList, nUtilizadores);
break;
}
}
return 0;
}
/*
Sintaxe: "send <emissor> <recetor> <texto>"
Regista o <texto> enviado pelo <emissor> para o <recetor>.
O <texto> tem um tamanho maximo de 500 caracteres, incluindo espacos.
*/
void send(pQueue queueList){
int nEmissor, nRecetor;
/*char *lpszMsg = (char *) malloc(BUFFERSIZE * sizeof(char));*/
char strTexto[BUFFERSIZE];
Item itemMensagem;
/* Argumentos do comando */
scanf("%d%d ", &nEmissor, &nRecetor);
fgets(strTexto, BUFFERSIZE, stdin);
/* Remove o \n do final da string lida */
strTexto[strlen(strTexto) - 1] = 0;
/* Cria a nova Mensagem e adiciona-a a lista de espera do recetor */
itemMensagem = ItemCreate(nEmissor, nRecetor, strTexto);
QueuePush(&queueList[nRecetor], itemMensagem);
}