LIS_tppLista MTZ_criarTab(int x, int y) {
int i,j;
PLH_tppPilha Pilha;
LIS_tppLista Elem;
LIS_tppLista Col;
LIS_tppLista Tab = LIS_CriarLista(0);
/*Cria lista*/
if (Tab == NULL)
return NULL;
/*if NULL*/
for (i = 0; i < x; i++) {
Col = LIS_CriarLista(0);
LIS_InserirElementoApos(Tab, Col);
for (j = 0; j < y; j++) {
Pilha = PLH_CriarTopo();
LIS_InserirElementoApos(Col, Pilha);
}
}
/* Cria toda a matriz de pilhas */
IrInicioLista(Tab);
return Tab;
}
/* Essa funcao e' responsavel por criar e compor 2 links ligando
* 2 nos.
*/
enum GRA_Ret linkTwoNodes(Node *node1, Node *node2)
{
Link *link1, *link2, *link;
IrInicioLista(node1->links);
CNT_CONTAR("linkTwoNodes - Inicializacao");
do{ /* Assertiva: Nao repetir links */
CNT_CONTAR("linkTwoNodes - Procurando link igual");
link = LIS_ObterValor(node1->links);
if( link && link->n2 == node2 ){
CNT_CONTAR("linkTwoNodes - Links iguais");
return GRA_InvalidLink;
}
}while (LIS_CondRetOK == LIS_AvancarElementoCorrente (node1->links,1));
CNT_CONTAR("linkTwoNodes - Compondo Links");
link1 = (Link*) malloc (sizeof(Link));
if (!link1){
CNT_CONTAR("linkTwoNodes - Alocacao de link1 falhou");
return GRA_MemoryError;
}
link2 = (Link*) malloc (sizeof(Link));
if (!link2){
/* Muito improvavel de cair aqui num teste
CNT_CNTAR("linkTwoNodes - Alocacao de link2 falhou"); */
free (link1);
return GRA_MemoryError;
}
/* Compoe os dois links */
link1->n1 = node1;
link1->n2 = node2;
link1->brother = link2;
link2->n1 = node2;
link2->n2 = node1;
link2->brother = link1;
IrFinalLista(node1->links);
IrFinalLista(node2->links);
/* Tenta inserir cada link em uma lista, limpa se nao der certo */
CNT_CONTAR("linkTwoNodes - Inserindo link 1 na lista");
if( LIS_CondRetOK != LIS_InserirElementoApos(node1->links, link1) ){
CNT_CONTAR("linkTwoNodes - Nao inseriu link 1 na lista");
return GRA_MemoryError;
}
CNT_CONTAR("linkTwoNodes - Inserindo link 2 na lista");
if( LIS_CondRetOK != LIS_InserirElementoApos(node2->links, link2) ){
CNT_CONTAR("linkTwoNodes - Nao inseriu link 2 na lista");
LIS_ExcluirElemento(node1->links);
return GRA_MemoryError;
}
#ifdef _DEBUG
AssertLink(link1);
AssertLink(link2);
#endif /* _DEBUG */
CNT_CONTAR("linkTwoNodes - Finalizando");
return GRA_Ok;
}
/***************************************************************************
* Função: GRA Inserir aresta
******/
GRA_tpCondRet GRA_InserirAresta(GRA_tppGrafo pGrafoParm,
char *nomeAresta, char *nomeVerticeOrigem, char *nomeVerticeDestino)
{
tpGrafo *pGrafo = (tpGrafo*) pGrafoParm;
tpAresta *pAresta;
LIS_tpCondRet lisCondRet;
GRA_tpCondRet graCondRet;
tpVertice *pVerticeOrigem, *pVerticeDestino;
if (pGrafo == NULL)
{
return GRA_CondRetGrafoNaoFoiCriado;
}
// Procura vértice origem
graCondRet = ProcurarVertice(pGrafo, nomeVerticeOrigem, &pVerticeOrigem);
if (graCondRet != GRA_CondRetOK)
{
return graCondRet;
}
// Procura vértice destino
graCondRet = ProcurarVertice(pGrafo, nomeVerticeDestino, &pVerticeDestino);
if (graCondRet != GRA_CondRetOK)
{
return graCondRet;
}
// Verifica se já existe uma aresta com este nome
if (ExisteAresta(pVerticeOrigem, nomeAresta))
{
return GRA_CondRetJaExiste;
}
MEM_Alloc(sizeof(tpAresta), (void **) &pAresta);
if (pAresta == NULL)
{
return GRA_CondRetFaltouMemoria;
}
// Atualiza os antecessores do vértice destino
lisCondRet = LIS_InserirElementoApos(pVerticeDestino->pAntecessores, pVerticeOrigem);
if (lisCondRet == LIS_CondRetFaltouMemoria)
{
return GRA_CondRetFaltouMemoria;
}
// Atualiza os sucessores do vértice origem
lisCondRet = LIS_InserirElementoApos(pVerticeOrigem->pSucessores, pAresta);
if (lisCondRet == LIS_CondRetFaltouMemoria)
{
return GRA_CondRetFaltouMemoria;
}
pAresta->nome = nomeAresta;
pAresta->pVertice = pVerticeDestino;
return GRA_CondRetOK;
}
GRA_tpCondRet GRA_InserirAresta( GRA_tppGrafo pGrafo, int idVertice1, int idVertice2 , int idAresta) {
tpVertice* origem1 = NULL;
tpVertice* origem2 = NULL;
tpVertice* pVertice1 = get_by_id(pGrafo,idVertice1);
tpVertice* pVertice2 = get_by_id(pGrafo,idVertice2);
tpAresta* vizinho = NULL;
/* Verifica se vertice pertence ao grafo; */
if (pVertice1 == NULL || pVertice2 == NULL) {
return GRA_CondRetNaoEhVertice;
}
if (pVertice1 == pVertice2) {
return GRA_CondRetEhVizinho;
}
if (!EhVizinho(pGrafo, pVertice1, pVertice2) &&
!EhVizinho(pGrafo, pVertice2, pVertice1) ) {
tpAresta * aresta1 = NULL;
tpAresta * aresta2 = NULL;
origem1 = ObterOrigem(pGrafo, pVertice1);
origem2 = ObterOrigem(pGrafo, pVertice2);
aresta1 = ( tpAresta * ) calloc(1, sizeof( tpAresta )) ;
if (aresta1 == NULL){
return GRA_CondRetFaltouMemoria;
}
aresta2 = ( tpAresta * ) calloc(1, sizeof( tpAresta )) ;
if (aresta2 == NULL ) {
free(aresta1);
return GRA_CondRetFaltouMemoria;
}
aresta1->id = idAresta;
aresta2->id = idAresta;
aresta1->pVizinho = pVertice2;
aresta2->pVizinho = pVertice1;
LIS_InserirElementoApos(pVertice1->pNode->arestas, aresta1);
LIS_InserirElementoApos(pVertice2->pNode->arestas, aresta2);
if (origem1 != origem2) { //Estavam em componentes distintas? Se sim, junta
LIS_IrInicioLista(pGrafo->componentes);
LIS_ProcurarValor(pGrafo->componentes, origem1);
LIS_ExcluirElemento(pGrafo->componentes);
}
return GRA_CondRetOK;
}
else {
return GRA_CondRetEhVizinho;
}
}
static int BFS(tpVertice* v, tpVertice* u) {
LIS_tppLista V = NULL; // LISTA VERTICE VISITADOS
LIS_tppLista Q = NULL; //FILA
LIS_tppLista arestas = NULL;
tpVertice* t = NULL;
tpVertice* s = NULL;
tpAresta* a = NULL;
int achou = 0;
int achou_V = 0;
V = LIS_CriarLista(NULL); // dados são referenciados por outros, não devem ser apagados
Q = LIS_CriarLista(NULL); // dados são referenciados por outros, não devem ser apagados
LIS_InserirElementoApos(V, v);
LIS_InserirElementoApos(Q, v); //Usado como uma Fila.
while (LIS_NumeroDeElementos(Q) > 0) {
LIS_IrInicioLista(Q);
t = (tpVertice *)LIS_ObterValor(Q);
LIS_ExcluirElemento(Q);
if (t == u) {
achou = 1;
break;
}
arestas = t->pNode->arestas;
LIS_IrInicioLista(arestas);
do {
a = (tpAresta *)LIS_ObterValor(arestas);
if(a == NULL) continue;
s = a->pVizinho;
LIS_IrInicioLista(V);
achou_V = 0;
do {
tpVertice * re = (tpVertice *)LIS_ObterValor(V);
if (re == NULL) {
continue;
}
if(re == s) achou_V = 1;
} while(LIS_AvancarElementoCorrente(V, 1) == LIS_CondRetOK);
if (!achou_V) {
if(LIS_InserirElementoApos(V, s)!= LIS_CondRetOK){ achou = -1;break;}
if(LIS_InserirElementoApos(Q, s)!= LIS_CondRetOK){ achou = -1;break;}
}
} while(LIS_AvancarElementoCorrente(arestas, 1) == LIS_CondRetOK);
}
LIS_DestruirLista(V);
LIS_DestruirLista(Q);
return achou;
}
/***************************************************************************
* Função: GRA Inserir vertice
******/
GRA_tpCondRet GRA_InserirVertice(GRA_tppGrafo pGrafoParm, char *nomeVertice, void *pValor)
{
tpGrafo *pGrafo = (tpGrafo*) pGrafoParm;
tpVertice *pVertice;
if (pGrafo == NULL)
{
return GRA_CondRetGrafoNaoFoiCriado;
}
if (ExisteVertice(pGrafo, nomeVertice))
{
return GRA_CondRetJaExiste;
}
MEM_Alloc(sizeof(tpVertice), (void **) &pVertice);
if (pVertice == NULL)
{
return GRA_CondRetFaltouMemoria;
}
pVertice->nome = nomeVertice;
pVertice->pValor = pValor;
pVertice->destruirValor = pGrafo->destruirValor;
LIS_CriarLista(&pVertice->pAntecessores, NULL, CompararVerticeENome);
LIS_CriarLista(&pVertice->pSucessores, DestruirAresta, CompararArestaENome);
pGrafo->pCorrente = pVertice;
LIS_InserirElementoApos(pGrafo->pVertices, pVertice);
return GRA_CondRetOK;
}
GRA_tpCondRet GRA_InserirVertice (GRA_tppGrafo pGrafo, void* pValor, int id)
{
int i;
tpVertice * pElem = NULL ;
tpVertice * v = NULL ;
#ifdef _DEBUG
assert( pGrafo != NULL ) ;
#endif
/* Criar o Vertice antes */
pElem = CriarVertice( pGrafo, pValor, id ) ;
if ( pElem == NULL ) {
return GRA_CondRetFaltouMemoria ;
}
if( LIS_InserirElementoApos (pGrafo->vertices, pElem) != LIS_CondRetOK) {
free(pElem);
return GRA_CondRetFaltouMemoria ;
}
if(pGrafo->corrente == -1) {
pGrafo->corrente = id;
}
LIS_NumeroDeElementos(pElem->pNode->arestas);
return GRA_CondRetOK ;
}
LIS_tppLista FRC_CriarBaralho( )
{
int np ;
int rk ;
CAR_tppCarta pAuxCar;
LIS_tppLista pNovo = LIS_CriarLista( NULL );
if( pNovo == NULL)
{
return NULL ;
} /* if */
for( np = CAR_NaipePaus ;
np <= CAR_NaipeOuros ;
np++ )
{
for( rk = CAR_RankAs ;
rk <= CAR_RankRei ;
rk++ )
{
pAuxCar = CAR_CriarCarta( ( CAR_tpNaipe ) ( np ) ,
( CAR_tpRank ) ( rk ) );
LIS_InserirElementoApos( pNovo , ( void *) pAuxCar ) ;
} /* for */
} /* if */
IrInicioLista( pNovo ) ;
return pNovo;
}
CPC_tpCondRet CPC_AdicionarMovimento( CPC_tppClassePeca pClassePeca , int movI , int movJ ) {
CPC_tpMovimento * movimento;
int resp;
if(pClassePeca == NULL) {
return CPC_CondRetPonteiroNulo;
}
CPC_ChecarMovimento(pClassePeca, movI, movJ, &resp);
if(resp == 1) {
return CPC_CondRetArgumentosInvalidos;
}
movimento = (CPC_tpMovimento*)malloc(sizeof(CPC_tpMovimento));
if(movimento == NULL) {
return CPC_CondRetFaltouMemoria;
}
movimento->movI = movI;
movimento->movJ = movJ;
LIS_IrFinalLista(pClassePeca->movimentos);
if( LIS_InserirElementoApos(pClassePeca->movimentos, movimento) == LIS_CondRetFaltouMemoria ) {
return CPC_CondRetFaltouMemoria;
}
return CPC_CondRetOK;
}
GRA_tpCondRet GRA_CriarAresta (char pVertOrig , char pVertDest , GRA_tppGrafo pGrafo, char * String)
{
GRA_tppArestaGrafo pAres;
tpVerticeGrafo * pVertO;
tpVerticeGrafo * pVertD;
int ret = 0;
if(pGrafo==NULL){
return GRA_CondRetGrafoNulo ;
} /* if */
pVertO = GRA_BuscarVertice(pGrafo, pVertOrig);
if(pVertO == NULL){
return GRA_CondRetNaoAchou ;
} /* if */
pVertD = GRA_BuscarVertice(pGrafo, pVertDest);
if(pVertD == NULL){
return GRA_CondRetNaoAchou ;
} /* if */
ret = ChecaArestaExiste(pVertO , String, pVertD->pIdVertice);
if(ret==1){
return GRA_ArestaJaExiste ;
} /* if */
pAres = (GRA_tppArestaGrafo) malloc (sizeof (tpArestaGrafo));
if(pAres == NULL){
return GRA_CondRetFaltouMemoria ;
} /* if */
pAres->Nome = String;
pAres->pVerticeDest = pVertD;
pGrafo->pCorrente = pVertO;
LIS_InserirElementoApos(pGrafo->pCorrente->pVerSuc , pAres);
/* Inserir aresta na lista de sucessores do vertorigem */
pGrafo->pCorrente = pVertD;
LIS_InserirElementoApos(pGrafo->pCorrente->pVerAnt , pVertO);
/* Inserir vertice na lista de antecessores do vertdestino */
return GRA_CondRetOK ;
}
LIS_tppLista criarTab(int x, int y) {
int i;
LIS_tppLista Tab = LIS_CriarLista(0);
if (Tab == NULL)
return NULL;
while ( x > 0) {
LIS_tppLista Col = LIS_CriarLista(0);
LIS_InserirElementoApos(Tab, Col);
for (i = y; i > 0; i--) {
PtoTopo * Pilha = criaTopo();
LIS_InserirElementoApos(Col, Pilha);
}
x--;
}
return Tab;
}
/***** Código das funções encapsuladas no módulo *****/
LIS_tppLista criarListaAPartirDeString( char * str ){
int i, len = strlen(str);
LIS_tppLista lista = LIS_CriarLista();
for( i = 0 ; i <= len ; i++) {
LIS_InserirElementoApos( lista, str[i] );
LIS_IrFinalLista( lista );
}
return lista;
}
int FIL_insereElem (FIL_tppFila fila,void* pValor)
{
if(fila->capacidade==LIS_ObtemNumElementos(fila->lista))
{
printf("\nFila cheia!");
return 0;
}
LIS_IrFinalLista( fila->lista ) ;
LIS_InserirElementoApos(fila->lista,pValor);
return 1;
}
static GRA_tpCondRet ExcluirAresta (GRA_tppGrafo grafo, tpVertice* v, tpVertice* u) {
RemoverAresta(v, u);//mexe só em v, ou deveria
RemoverAresta(u, v);
//BFS pra detectar se é necessário gerar nova componente.
if (BFS(v,u) != 1) { //Estão em componentes distintas
if (LIS_InserirElementoApos(grafo->componentes, u) != LIS_CondRetOK) {
return GRA_CondRetFaltouMemoria;
}
}
return GRA_CondRetOK;
}
/***********************************************************************
*
* $FC Função: MEN CriarOpcao
*
***********************************************************************/
MEN_tpCondRet MEN_CriarOpcao(MEN_tppMenus menus, int idMenu,char cmd, char* nome,MEN_tpCondRet (*callback)(EST_tppEstado e)){
MEN_tppMenu m;
MEN_tppOpcao o = (MEN_tppOpcao)malloc(sizeof(Opcao));
if(o==NULL)
return MEN_CondRetFaltouMemoria;
o->nome = nome;
o->cmd = cmd;
o->callback = callback;
GRA_ObterValor(menus->grafo,idMenu,(void**)&m);
LIS_InserirElementoApos(m->opcoes,o);
return MEN_CondRetOK;
}
GRA_tpCondRet GRA_ObterValores( GRA_tppGrafo pGrafo, LIS_tppLista pValores ) {
LIS_tppLista vertices;
tpVertice* vertice;
void* valor;
vertices = pGrafo->vertices;
LIS_IrInicioLista(vertices);
do{
valor = LIS_ObterValor(vertices);
LIS_InserirElementoApos(pValores,valor);
LIS_AvancarElementoCorrente(pValores,1);
}while(LIS_AvancarElementoCorrente(vertices,1) == LIS_CondRetOK);
}
LIS_tppLista CriarListaPassos(PAS_tppPasso *passos, const int tamanho)
{
int i;
LIS_tppLista pPassos;
LIS_CriarLista(&pPassos, DestruirValor, NULL);
for (i = 0; i < tamanho; i++)
{
PAS_tppPasso pPasso;
pPasso = *(passos + i);
LIS_InserirElementoApos(pPassos, pPasso);
}
return pPassos;
}
PIL_tpCondRet PIL_PushCarta( PIL_tppPilha pPilha , CAR_tppCarta pCarta )
{
LIS_tpCondRet Ret ;
LIS_IrFinalLista( pPilha->pListaCartas ) ;
Ret = LIS_InserirElementoApos( pPilha->pListaCartas , pCarta ) ;
if( Ret != LIS_CondRetOK )
{
return PIL_CondRetFaltouMemoria ;
} /* if */
return PIL_CondRetOK ;
}/* Fim função: PIL Push Carta */
/***********************************************************************
* $FC Função: NPE &Inserir Cartas Em Extra
***********************************************************************/
NPE_tpCondRet NPE_InserirCartaEmNaipe(NPE_Coluna destino, Carta carta){
LIS_tpCondRet condRet;
if(NPE_VerificarInserirCarta(destino, carta) != NPE_CondRetOK){
return NPE_CondRetErroAoInserir;
}
IrFinalLista(destino);
condRet = LIS_InserirElementoApos(destino, carta);
if(condRet == LIS_CondRetOK){
return NPE_CondRetOK;
}
else{
return NPE_CondRetErroAoInserir;
}
}
BAR_tpCondRet BAR_AdicionarPeca(BAR_tppCapturadas pBAR)
{
char cor = pBAR->cor;
tppPeca newPeca;
if(Pec_CriarPeca(&newPeca, cor) != Pec_CondRetOK)
{
printf("Erro ao criar peca (BAR) \n");
return BAR_CondRetErro;
}
if(LIS_InserirElementoApos(pBAR->ListaCapturadas, newPeca) != LIS_CondRetOK)
{
printf("Erro ao inserir peça na lista (BAR) \n");
return BAR_CondRetErro;
}
pBAR->tamanho++;
return BAR_CondRetOK;
}
GRA_tpCondRet GRA_CriaVerticeGrafo(GRA_tppGrafo pGrafo, char * String , char id, void ( * ExcluirValor ) ( void * pDado ))
{
GRA_tppVerGrafo pVert;
int ret = 0;
if(pGrafo==NULL){
return GRA_CondRetGrafoNulo ;
} /* if */
ret = ChecaVerticeExiste(pGrafo, id);
if(ret == 1){
return GRA_VerticeJaExiste ;
} /* if */
pVert = (GRA_tppVerGrafo) malloc (sizeof (tpVerticeGrafo));
if(pVert == NULL){
return GRA_CondRetFaltouMemoria ;
} /* if */
pVert->pIdVertice = id ;
pVert->pConteudo = GRA_CriaContVertice (String) ;
pVert->destruirValorV = ExcluirValor ;
GRA_CriaListaSucessoresVertice (pVert);
GRA_CriaListaAntecessoresVertice (pVert);
LIS_InserirElementoApos(pGrafo->pListaVertices, pVert );
/* Insere vértice na lista de vértices do grafo */
pGrafo->pCorrente = pVert;
return GRA_CondRetOK ;
}
/***************************************************************************
* Função: GRA Tornar vértice corrente uma origem
******/
GRA_tpCondRet GRA_TornarCorrenteUmaOrigem(GRA_tppGrafo pGrafoParm)
{
tpGrafo *pGrafo = (tpGrafo*) pGrafoParm;
if (pGrafo == NULL)
{
return GRA_CondRetGrafoNaoFoiCriado;
}
if (EstaVazio(pGrafo))
{
return GRA_CondRetGrafoVazio;
}
if (ExisteOrigem(pGrafo, pGrafo->pCorrente->nome))
{
return GRA_CondRetJaExiste;
}
LIS_InserirElementoApos(pGrafo->pOrigens, pGrafo->pCorrente);
return GRA_CondRetOK;
}
//cria um vertice e sua estrutura interna
static tpVertice* CriarVertice(GRA_tppGrafo grafo, void* pValor, int id) {
tpVertice* v = NULL;
tpNode* no = NULL;
LIS_tppLista arestas = NULL;
tpVertice* t = NULL;
v = (tpVertice*) malloc( sizeof(tpVertice) );
if (v == NULL) {
return NULL;
}
no = (tpNode*) malloc( sizeof(tpNode) );
if (no == NULL) {
free(v);
return NULL;
}
arestas = LIS_CriarLista(free);
if(arestas == NULL) {
free(v);
free(no);
return NULL;
}
no->arestas = arestas;
no->pValor = pValor;
v->pNode = no;
v->id = id;
if( LIS_InserirElementoApos (grafo->componentes, v) != LIS_CondRetOK) {
free(v);
free(no);
LIS_DestruirLista(arestas);
return NULL ;
}
return v;
}
GRA_tpCondRet GRA_ObterVizinhos ( GRA_tppGrafo pGrafo, int idVertice, LIS_tppLista* pLista) {
tpVertice * pVertice = get_by_id(pGrafo,idVertice);
LIS_tppLista vizinhos = NULL;
LIS_tppLista Ret_vizinhos = NULL;
tpAresta* aresta = NULL;
int* idVerticeVizinho = NULL;
if (pVertice == NULL)
return GRA_CondRetNaoEhVertice;
Ret_vizinhos = LIS_CriarLista(free);
if (Ret_vizinhos == NULL) {
return GRA_CondRetFaltouMemoria;
}
vizinhos = pVertice->pNode->arestas;
LIS_IrInicioLista(vizinhos);
if (LIS_NumeroDeElementos(vizinhos) > 0) {
do {
idVerticeVizinho = (int*) calloc(1, sizeof(int));
aresta = (tpAresta *)LIS_ObterValor(vizinhos);
(*idVerticeVizinho) = aresta->pVizinho->id;
if (LIS_InserirElementoApos( Ret_vizinhos, idVerticeVizinho) != LIS_CondRetOK ) {
LIS_DestruirLista(Ret_vizinhos);
return GRA_CondRetFaltouMemoria;
}
}
while(LIS_AvancarElementoCorrente(vizinhos, 1) == LIS_CondRetOK);
}
*pLista = Ret_vizinhos;
return GRA_CondRetOK;
}
GRA_tpCondRet GRA_ObterOrigens( GRA_tppGrafo pGrafo, LIS_tppLista * pLista) {
LIS_tppLista Ret_origens = NULL;
LIS_tppLista origens = NULL ;
Ret_origens = LIS_CriarLista(NULL);
if (Ret_origens == NULL) {
return GRA_CondRetFaltouMemoria;
}
origens = pGrafo->componentes;
LIS_IrInicioLista(origens);
do {
tpVertice * no = (tpVertice *)LIS_ObterValor(origens);
if(no == NULL) break;
if(LIS_InserirElementoApos(Ret_origens,&(no->id)) != LIS_CondRetOK)
return GRA_CondRetFaltouMemoria;
}
while(LIS_AvancarElementoCorrente(origens, 1) == LIS_CondRetOK);
*pLista = Ret_origens;
return GRA_CondRetOK;
}
GRA_tpCondRet GRA_InsereOrigem(GRA_tppGrafo pGrafo, char IdVert)
{
tpVerticeGrafo * VerCorr;
tpVerticeGrafo * pVertO;
ListaRetCaminho = LIS_CondRetOK ;
VerCorr = GRA_BuscarVertice(pGrafo, IdVert);
if(VerCorr == NULL){
return GRA_CondRetNaoAchou ;
} /* if */
LIS_IrInicioLista(pGrafo->pListaOrigens);
while(ListaRetCaminho==LIS_CondRetOK || ListaRetCaminho==LIS_CondRetFimLista){
LIS_ObterValor (pGrafo->pListaOrigens , (void**)&pVertO);
if(VerCorr->pIdVertice == pVertO->pIdVertice){
return GRA_CondRetMaisdeUmaOrigem;
} /* if */
if(ListaRetCaminho == LIS_CondRetFimLista){
break;
} /* if */
ListaRetCaminho = LIS_AvancarElementoCorrente(pGrafo->pListaOrigens, 1);
} /* while */
LIS_InserirElementoApos(pGrafo->pListaOrigens , VerCorr);
pGrafo->pCorrente = VerCorr;
return GRA_CondRetOK ;
}
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
int inxLista = -1 ,
numLidos = -1 ,
CondRetEsp = -1 ;
char StringDado[ DIM_VALOR ] ;
int ValEsp = -1 ;
int i ;
int numElem = -1 ;
StringDado[ 0 ] = 0 ;
/* Efetuar reset de teste de lista */
if ( strcmp( ComandoTeste , RESET_LISTA_CMD ) == 0 )
{
for( i = 0 ; i < DIM_VT_LISTA ; i++ )
{
vtListas[ i ] = NULL ;
} /* for */
return TST_CondRetOK ;
} /* fim ativa: Efetuar reset de teste de lista */
/* Testar CriarLista */
else if ( strcmp( ComandoTeste , CRIAR_LISTA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , VAZIO )))
{
return TST_CondRetParm ;
} /* if */
vtListas[ inxLista ] =
LIS_CriarLista( DestruirValor ) ;
return TST_CompararPonteiroNulo( 1 , vtListas[ inxLista ] ,
"Erro em ponteiro de nova lista." ) ;
} /* fim ativa: Testar CriarLista */
/* Testar Esvaziar lista lista */
else if ( strcmp( ComandoTeste , ESVAZIAR_LISTA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )))
{
return TST_CondRetParm ;
} /* if */
LIS_EsvaziarLista( vtListas[ inxLista ] ) ;
return TST_CondRetOK ;
} /* fim ativa: Testar Esvaziar lista lista */
/* Testar Destruir lista */
else if ( strcmp( ComandoTeste , DESTRUIR_LISTA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )))
{
return TST_CondRetParm ;
} /* if */
LIS_DestruirLista( vtListas[ inxLista ] ) ;
vtListas[ inxLista ] = NULL ;
return TST_CondRetOK ;
} /* fim ativa: Testar Destruir lista */
/* Testar inserir elemento antes */
else if ( strcmp( ComandoTeste , INS_ELEM_ANTES_CMD ) == 0 )
{
struct user *u = (struct user*) malloc (sizeof (struct user));
LIS_tpCondRet lret;
if (!u)
return TST_CondRetMemoria;
numLidos = LER_LerParametros( "isssi" ,
&inxLista , u->nome, u->tel, u->ender , &CondRetEsp ) ;
if ( ( numLidos != 5 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
lret = LIS_InserirElementoAntes( vtListas[ inxLista ] , u ) ;
if ( lret != LIS_CondRetOK )
{
free( u ) ;
} /* if */
return TST_CompararInt( CondRetEsp , lret ,
"Condicao de retorno errada ao inserir antes." ) ;
} /* fim ativa: Testar inserir elemento antes */
/* Testar inserir elemento apos */
else if ( strcmp( ComandoTeste , INS_ELEM_APOS_CMD ) == 0 )
{
struct user *u = (struct user *)malloc (sizeof (struct user));
LIS_tpCondRet lret;
if (!u)
return TST_CondRetMemoria;
numLidos = LER_LerParametros( "isssi",
&inxLista, u->nome, u->tel, u->ender, &CondRetEsp ) ;
if ( ( numLidos != 5 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
lret = LIS_InserirElementoApos( vtListas[ inxLista ] , u ) ;
if ( lret != LIS_CondRetOK )
{
free( u ) ;
} /* if */
return TST_CompararInt( CondRetEsp , lret,
"Condicao de retorno errada ao inserir antes.") ;
} /* fim ativa: Testar inserir elemento apos */
/* Testar excluir simbolo */
else if ( strcmp( ComandoTeste , EXC_ELEM_CMD ) == 0 )
{
numLidos = LER_LerParametros( "ii" ,
&inxLista , &CondRetEsp ) ;
if ( ( numLidos != 2 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( CondRetEsp ,
LIS_ExcluirElemento( vtListas[ inxLista ] ) ,
"Condição de retorno errada ao excluir." ) ;
} /* fim ativa: Testar excluir simbolo */
/* Testar obter valor do elemento corrente */
else if ( strcmp( ComandoTeste , OBTER_NOME_CMD ) == 0 )
{
struct user *u;
numLidos = LER_LerParametros( "isi" ,
&inxLista , StringDado , &ValEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
u = (struct user*) LIS_ObterValor( vtListas[ inxLista ] ) ;
if ( ValEsp == 0 )
{
return TST_CompararPonteiroNulo( 0 , u,
"Valor não deveria existir." ) ;
} /* if */
if ( u == NULL )
{
return TST_CompararPonteiroNulo( 1 , u,
"Dado tipo um deveria existir." ) ;
} /* if */
return TST_CompararString( StringDado , u->nome,
"Valor nome do elemento esta' errado." ) ;
} /* fim ativa: Testar obter valor do elemento corrente */
/* Testar obter valor do elemento corrente */
else if ( strcmp( ComandoTeste, OBTER_TEL_CMD ) == 0 )
{
struct user *u;
numLidos = LER_LerParametros( "isi" ,
&inxLista , StringDado , &ValEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
u = (struct user*) LIS_ObterValor( vtListas[ inxLista ] ) ;
if ( ValEsp == 0 )
{
return TST_CompararPonteiroNulo( 0 , u,
"Valor não deveria existir." ) ;
} /* if */
if ( u == NULL )
{
return TST_CompararPonteiroNulo( 1 , u,
"Dado tipo um deveria existir." ) ;
} /* if */
return TST_CompararString( StringDado , u->tel,
"Valor nome do elemento esta' errado." ) ;
} /* fim ativa: Testar obter valor do elemento corrente */
/* Testar obter valor do elemento corrente */
else if ( strcmp( ComandoTeste , OBTER_ENDER_CMD ) == 0 )
{
struct user *u;
numLidos = LER_LerParametros( "isi" ,
&inxLista , StringDado , &ValEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
u = (struct user*) LIS_ObterValor( vtListas[ inxLista ] ) ;
if ( ValEsp == 0 )
{
return TST_CompararPonteiroNulo( 0 , u,
"Valor não deveria existir." ) ;
} /* if */
if ( u == NULL )
{
return TST_CompararPonteiroNulo( 1 , u,
"Dado tipo um deveria existir." ) ;
} /* if */
return TST_CompararString( StringDado , u->ender,
"Valor nome do elemento esta' errado." ) ;
} /* fim ativa: Testar obter valor do elemento corrente */
/* Testar ir para o elemento inicial */
else if ( strcmp( ComandoTeste , IR_INICIO_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" , &inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
IrInicioLista( vtListas[ inxLista ] ) ;
return TST_CondRetOK ;
} /* fim ativa: Testar ir para o elemento inicial */
/* LIS &Ir para o elemento final */
else if ( strcmp( ComandoTeste , IR_FIM_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" , &inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
IrFinalLista( vtListas[ inxLista ] ) ;
return TST_CondRetOK ;
} /* fim ativa: LIS &Ir para o elemento final */
/* LIS &Avançar elemento */
else if ( strcmp( ComandoTeste , AVANCAR_ELEM_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iii" , &inxLista , &numElem ,
&CondRetEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( CondRetEsp ,
LIS_AvancarElementoCorrente( vtListas[ inxLista ] , numElem ) ,
"Condicao de retorno errada ao avancar" ) ;
} /* fim ativa: LIS &Avançar elemento */
return TST_CondRetNaoConhec ;
} /* Fim função: TLIS &Testar lista */
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
/* Variáveis para retorno de operações com lista */
/* Devem ser inicializadas com qualquer valor */
LIS_tpCondRet LIS_CondRetObtido = LIS_CondRetOK ;
LIS_tpCondRet LIS_CondRetEsperada = LIS_CondRetFaltouMemoria ;
int indexFocoLista = '0';
int NumLidos = -1 ;
int i = 0;
int resposta = 0;
int numPassos = 0;
char * caracter;
char stringDado [2] ;
TST_tpCondRet Ret = TST_CondRetOK ;
stringDado[1]='\0';
/* Efetuar reset de teste de lista */
if ( strcmp (ComandoTeste, RESET_LIS_CMD) == 0 )
{
for ( i = 0; i < DIM_VT_LISTA; i++ )
vtListas[ i ] = NULL;
return TST_CondRetOK;
} /* Fim ativa: Efetuar reset de teste de lista */
/* Testar LIS Criar lista */
else if ( strcmp( ComandoTeste , CRIAR_LIS_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&indexFocoLista,
&LIS_CondRetEsperada ) ;
if ( NumLidos != 2 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm ;
} /* if */
LIS_CondRetObtido = LIS_CriarLista( &vtListas[ indexFocoLista ], DestruirConteudoLista );
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao criar lista." );
} /* Fim ativa: Testar LIS Criar lista */
/* Testar LIS Inserir elemento na lista antes do elemento corrente */
else if ( strcmp( ComandoTeste , INSERIR_ANTES_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ici" ,
&indexFocoLista,
stringDado,
&LIS_CondRetEsperada ) ;
if ( NumLidos != 3 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm ;
} /* if */
caracter = ( char * ) malloc( strlen( stringDado ) + 1 ) ;
if ( caracter == NULL )
{
return TST_CondRetMemoria ;
} /* if */
strcpy( caracter , stringDado ) ;
LIS_CondRetObtido = LIS_InserirElementoAntes ( vtListas[ indexFocoLista ], caracter );
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao inserir à esquerda (antes do elemento corrente da lista)." );
} /* fim ativa: Testar LIS Inserir elemento na lista antes do elemento corrente */
/* Testar LIS Inserir elemento na lista depois do elemento corrente */
else if ( strcmp( ComandoTeste , INSERIR_APOS_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ici" ,
&indexFocoLista,
stringDado,
&LIS_CondRetEsperada ) ;
if ( NumLidos != 3 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm ;
} /* if */
caracter = ( char * ) malloc( strlen( stringDado ) + 1 ) ;
if ( caracter == NULL )
{
return TST_CondRetMemoria ;
} /* if */
strcpy( caracter , stringDado ) ;
LIS_CondRetObtido = LIS_InserirElementoApos ( vtListas[ indexFocoLista ], caracter );
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao inserir à direita (após elemento corrente)." );
} /* fim ativa: Testar LIS Inserir elemento na lista depois do elemento corrente */
/* Testar LIS Ir para elemento inicial (origem da lista) */
else if ( strcmp( ComandoTeste , IR_INICIOLISTA_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&indexFocoLista,
&LIS_CondRetEsperada ) ;
if ( NumLidos != 2 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm ;
} /* if */
LIS_CondRetObtido = LIS_IrInicioLista( vtListas[ indexFocoLista ] ) ;
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao ir para o início da lista." );
} /* fim ativa: Testar LIS Ir para elemento inicial (origem da lista) */
/* Testar LIS Ir para elemento final (fim da lista) */
else if ( strcmp( ComandoTeste , IR_FIMLISTA_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&indexFocoLista,
&LIS_CondRetEsperada ) ;
if ( NumLidos != 2 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm ;
} /* if */
LIS_CondRetObtido = LIS_IrFinalLista( vtListas[ indexFocoLista ] ) ;
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao ir para o fim da lista." );
} /* fim ativa: Testar LIS Ir para elemento final (fim da lista) */
/* Testar LIS Percorre lista */
else if ( strcmp( ComandoTeste , PERCORRE_LIS_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "iii" ,
&indexFocoLista,
&numPassos,
&LIS_CondRetEsperada ) ;
if ( NumLidos != 3 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm ;
} /* if */
LIS_CondRetObtido = LIS_PercorreLista( vtListas[ indexFocoLista ], numPassos ) ;
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao percorrer a lista." );
} /* fim ativa: Testar LIS Percorre lista */
/* Testar LIS Obter elementos existentes na lista */
else if ( strcmp ( ComandoTeste, OBTER_NUMELEMLISTA_CMD ) == 0 )
{
NumLidos = LER_LerParametros ( "ii",
&indexFocoLista,
&LIS_CondRetEsperada ) ;
if ( NumLidos != 2 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm;
}
LIS_CondRetObtido = LIS_ObterNumeroElementos ( vtListas[ indexFocoLista ], &resposta );
if ( LIS_CondRetObtido == LIS_CondRetOK )
{
printf ( "\nNumero de elementos na lista: %d\n", resposta );
}
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao requisitar número de elementos de lista." );
} /* fim ativa: Testar LIS Obter elementos existentes na lista */
/* Testar LIS Excluir elemento corrente da lista */
else if ( strcmp ( ComandoTeste, EXC_ELEM_CMD ) == 0 )
{
NumLidos = LER_LerParametros ( "ii",
&indexFocoLista,
&LIS_CondRetEsperada );
if ( NumLidos != 2 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ))
{
return TST_CondRetParm;
}
LIS_CondRetObtido = LIS_ExcluirElementoCorrente ( vtListas[ indexFocoLista ] );
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao excluir elemento corrente da lista." );
} /* fim ativa: Testar LIS Excluir elemento corrente da lista */
/* Testar LIS Procurar valor nos elementos da lista */
else if ( strcmp ( ComandoTeste, PROCURA_VALISTA_CMD ) == 0 )
{
NumLidos = LER_LerParametros ( "ici",
&indexFocoLista,
stringDado,
&LIS_CondRetEsperada );
if ( NumLidos != 3 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ))
{
return TST_CondRetParm;
}
LIS_CondRetObtido = LIS_ProcurarValor ( vtListas[ indexFocoLista ], (void**)&stringDado, ComparaConteudo );
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao procurar elemento da lista." );
} /* fim ativa: Testar LIS Procurar valor nos elementos da lista */
/* Testar LIS Obter valor armazenado no elemento corrente */
else if ( strcmp( ComandoTeste , OBTER_VALISTA_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ici" ,
&indexFocoLista,
stringDado,
&LIS_CondRetEsperada );
if ( NumLidos != 3 || !ValidarIndex( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm ;
} /* if */
LIS_CondRetObtido = LIS_ObterValorCorrente ( vtListas[ indexFocoLista ], (void**)&caracter ) ;
if ( LIS_CondRetObtido == LIS_CondRetOK )
{
printf ("\nCaracter obtido: %c \n", *caracter );
return TST_CompararChar( stringDado[0], *caracter, "Caracteres diferentes" );
}
else
{
return TST_CompararInt( LIS_CondRetEsperada, LIS_CondRetObtido, "Retorno errado para obter elemento do elemento corrente da lista." );
}
} /* fim ativa: Testar LIS Obter valor armazenado no elemento corrente */
/* Testar LIS Esvaziar lista */
else if ( strcmp( ComandoTeste , ESVAZIAR_LIS_CMD ) == 0 )
{
NumLidos = LER_LerParametros ( "ii",
&indexFocoLista,
&LIS_CondRetEsperada );
if (NumLidos != 2 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm;
}
LIS_CondRetObtido = LIS_EsvaziarLista ( vtListas[ indexFocoLista ] ) ;
return TST_CompararInt ( LIS_CondRetEsperada, LIS_CondRetObtido, "Retorno de erro ao esvaziar lista." );
} /* fim ativa: Testar LIS Esvaziar lista */
/* Testar LIS Destruir lista */
else if ( strcmp( ComandoTeste , DESTROI_LIS_CMD ) == 0 )
{
NumLidos = LER_LerParametros ( "ii",
&indexFocoLista,
&LIS_CondRetEsperada );
if ( NumLidos != 2 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm;
}
LIS_CondRetObtido = LIS_DestruirLista( &vtListas[ indexFocoLista ] ) ;
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao destruir lista." );
} /* fim ativa: Testar LIS Destruir lista */
return TST_CondRetNaoConhec ;
} /* Fim função: TLIS Efetuar operações de teste específicas para lista de caracteres */
TST_tpCondRet TST_EfetuarComando(char * ComandoTeste)
{
int inxLista = -1, numLidos = -1, CondRetEsp = -1;
TST_tpCondRet CondRet;
char StringDado[DIM_VALOR];
char * pDado;
int IntDado[DIM_VALOR_INT];
int* pDadoInt;
int ValEsp = -1;
int i;
int numElem = -1;
int inxStoredPtr;
for(i = 0; i < DIM_VT_LISTA; i++)
storedPtr[i][0] = NULL;
StringDado[0] = 0;
/* Efetuar reset de teste de lista */
if(strcmp(ComandoTeste, RESET_LISTA_CMD) == 0) {
for(i = 0; i < DIM_VT_LISTA; i++) {
vtListas[i] = NULL;
storedPtrIndex[i] = 1;
}
return TST_CondRetOK;
} /* fim ativa: Efetuar reset de teste de lista */
/* Testar CriarLista */
else if(strcmp(ComandoTeste, CRIAR_LISTA_CMD) == 0) {
numLidos = LER_LerParametros("i", &inxLista);
if((numLidos != 1) || (!ValidarInxLista(inxLista, VAZIO)))
return TST_CondRetParm;
vtListas[inxLista] = LIS_CriarLista(DestruirValor);
return TST_CompararPonteiroNulo(1, vtListas[inxLista], "Erro em ponteiro de nova lista.");
} /* fim ativa: Testar CriarLista */
/* Testar Esvaziar lista lista */
else if(strcmp(ComandoTeste, ESVAZIAR_LISTA_CMD) == 0) {
numLidos = LER_LerParametros("i", &inxLista);
if((numLidos != 1) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
LIS_EsvaziarLista(vtListas[inxLista]);
return TST_CondRetOK;
} /* fim ativa: Testar Esvaziar lista lista */
/* Testar Destruir lista */
else if(strcmp(ComandoTeste, DESTRUIR_LISTA_CMD) == 0) {
numLidos = LER_LerParametros("i", &inxLista);
if((numLidos != 1) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
LIS_DestruirLista(vtListas[inxLista]);
vtListas[inxLista] = NULL;
return TST_CondRetOK;
} /* fim ativa: Testar Destruir lista */
/* Testar inserir elemento antes */
else if(strcmp(ComandoTeste, INS_ELEM_ANTES_CMD) == 0) {
numLidos = LER_LerParametros("isi", &inxLista, StringDado, &CondRetEsp);
if((numLidos != 3) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
if(!ValidarInxStoredPtr(storedPtrIndex[inxLista]))
return TST_CondRetMemoria;
pDado = (char *) malloc(strlen(StringDado) + 1);
if(pDado == NULL)
return TST_CondRetMemoria;
storedPtr[inxLista][storedPtrIndex[inxLista]++] = pDado;
strcpy(pDado, StringDado);
CondRet = LIS_InserirElementoAntes(vtListas[inxLista], pDado);
if(CondRet != LIS_CondRetOK)
free(pDado);
return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao inserir antes.");
} /* fim ativa: Testar inserir elemento antes */
/* Testar inserir elemento antes INTEIRO */
else if(strcmp(ComandoTeste, INS_ELEM_ANTES_CMD_INT) == 0) {
numLidos = LER_LerParametros("iiii", &inxLista, &IntDado[0], &IntDado[1], &CondRetEsp);
if((numLidos != 4) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
if(!ValidarInxStoredPtr(storedPtrIndex[inxLista]))
return TST_CondRetMemoria;
pDadoInt = (int *) malloc(DIM_VALOR_INT*sizeof(int));
if(pDadoInt == NULL)
return TST_CondRetMemoria;
storedPtr[inxLista][storedPtrIndex[inxLista]++] = pDadoInt;
for(i=0;i<DIM_VALOR_INT;i++)
pDadoInt[i]=IntDado[i];
CondRet = LIS_InserirElementoAntes(vtListas[inxLista], pDadoInt);
if(CondRet != LIS_CondRetOK)
free(pDadoInt);
return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao inserir antes.");
} /* fim ativa: Testar inserir elemento antes INTEIRO*/
/* Testar inserir elemento apos */
else if(strcmp(ComandoTeste, INS_ELEM_APOS_CMD) == 0) {
numLidos = LER_LerParametros("isi", &inxLista, StringDado, &CondRetEsp);
if((numLidos != 3) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
if(!ValidarInxStoredPtr(storedPtrIndex[inxLista]))
return TST_CondRetMemoria;
pDado = (char*)malloc(strlen(StringDado) + 1);
if(pDado == NULL)
return TST_CondRetMemoria;
storedPtr[inxLista][storedPtrIndex[inxLista]++] = pDado;
strcpy(pDado, StringDado);
CondRet = LIS_InserirElementoApos(vtListas[inxLista], pDado);
if(CondRet != LIS_CondRetOK)
free(pDado);
return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao inserir apos.");
} /* fim ativa: Testar inserir elemento apos */
/* Testar inserir elemento apos INTEIRO*/
else if(strcmp(ComandoTeste, INS_ELEM_APOS_CMD_INT) == 0) {
numLidos = LER_LerParametros("iiii", &inxLista, &IntDado[0], &IntDado[1], &CondRetEsp);
if((numLidos != 4) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
if(!ValidarInxStoredPtr(storedPtrIndex[inxLista]))
return TST_CondRetMemoria;
pDadoInt = (int *) malloc(DIM_VALOR_INT * sizeof(int));
if(pDadoInt == NULL)
return TST_CondRetMemoria;
storedPtr[inxLista][storedPtrIndex[inxLista]++] = pDadoInt;
for(i=0;i<DIM_VALOR_INT;i++)
pDadoInt[i]=IntDado[i];
CondRet = LIS_InserirElementoApos(vtListas[inxLista], pDadoInt);
if(CondRet != LIS_CondRetOK)
free(pDadoInt);
return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao inserir apos.");
} /* fim ativa: Testar inserir elemento apos INTEIRO*/
/* Testar excluir simbolo */
else if(strcmp(ComandoTeste, EXC_ELEM_CMD) == 0) {
numLidos = LER_LerParametros("ii", &inxLista, &CondRetEsp);
if((numLidos != 2) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
return TST_CompararInt(CondRetEsp, LIS_ExcluirElemento(vtListas[inxLista]),
"Condição de retorno errada ao excluir.");
} /* fim ativa: Testar excluir simbolo */
/* Testar obter valor do elemento corrente */
else if(strcmp(ComandoTeste, OBTER_VALOR_CMD) == 0) {
numLidos = LER_LerParametros("isi", &inxLista, StringDado, &ValEsp);
if((numLidos != 3) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
pDado = (char *) LIS_ObterValor(vtListas[inxLista]);
if(ValEsp == 0)
return TST_CompararPonteiroNulo(0, pDado, "Valor não deveria existir.");
if(pDado == NULL)
return TST_CompararPonteiroNulo(1, pDado, "Dado tipo um deveria existir.");
return TST_CompararString(StringDado, pDado, "Valor do elemento errado.");
} /* fim ativa: Testar obter valor do elemento corrente */
/* Testar obter valor do elemento corrente INTEIRO*/
else if(strcmp(ComandoTeste, OBTER_VALOR_CMD_INT) == 0) {
numLidos = LER_LerParametros("iiii", &inxLista, &IntDado[0], &IntDado[1], &ValEsp);
if((numLidos != 4) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
pDadoInt = (int *)LIS_ObterValor(vtListas[inxLista]);
if(ValEsp == 0)
return TST_CompararPonteiroNulo(0, pDadoInt, "Valor não deveria existir.");
if(pDadoInt == NULL)
return TST_CompararPonteiroNulo(1, pDadoInt, "Dado tipo um deveria existir.");
return TST_CompararEspaco(IntDado, pDadoInt, DIM_VALOR_INT * sizeof(int),
"Valor do elemento errado.");
} /* fim ativa: Testar obter valor do elemento corrente INTEIRO*/
/* Testar ir para o elemento inicial */
else if(strcmp(ComandoTeste, IR_INICIO_CMD) == 0) {
numLidos = LER_LerParametros("i", &inxLista);
if((numLidos != 1) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
LIS_IrInicioLista(vtListas[inxLista]);
return TST_CondRetOK;
} /* fim ativa: Testar ir para o elemento inicial */
/* LIS &Ir para o elemento final */
else if(strcmp(ComandoTeste, IR_FIM_CMD) == 0) {
numLidos = LER_LerParametros("i", &inxLista);
if((numLidos != 1) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
LIS_IrFinalLista(vtListas[inxLista]);
return TST_CondRetOK;
} /* fim ativa: LIS &Ir para o elemento final */
/* LIS &Avançar elemento */
else if(strcmp(ComandoTeste, AVANCAR_ELEM_CMD) == 0) {
numLidos = LER_LerParametros("iii", &inxLista, &numElem, &CondRetEsp);
if((numLidos != 3) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
return TST_CompararInt(CondRetEsp,
LIS_AvancarElementoCorrente(vtListas[inxLista], numElem),
"Condicao de retorno errada ao avancar");
} /* fim ativa: LIS &Avançar elemento */
/* Testar Ir Indice */
else if(strcmp(ComandoTeste, IR_INDICE_CMD) == 0) {
numLidos = LER_LerParametros("iii", &inxLista, &numElem, &CondRetEsp);
if((numLidos != 3) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
return TST_CompararInt(CondRetEsp, LIS_IrIndice(vtListas[inxLista], numElem),
"Condicao de retorno errada ao ir para o índice");
} /* fim ativa: Testar Ir Indice */
/* Testar Setar Valor INTEIRO*/
else if(strcmp(ComandoTeste, SETAR_VALOR_CMD_INT) == 0) {
numLidos = LER_LerParametros("iiii", &inxLista, &IntDado[0], &IntDado[1], &CondRetEsp);
if((numLidos != 4) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
if(!ValidarInxStoredPtr(storedPtrIndex[inxLista]))
return TST_CondRetMemoria;
pDadoInt = (int *) malloc(DIM_VALOR_INT * sizeof(int));
if(pDadoInt == NULL)
return TST_CondRetMemoria;
storedPtr[inxLista][storedPtrIndex[inxLista]++] = pDadoInt;
for(i=0;i<DIM_VALOR_INT;i++)
pDadoInt[i]=IntDado[i];
return TST_CompararInt(CondRetEsp, LIS_SetarValor(vtListas[inxLista], pDadoInt),
"Condicao de retorno errada ao ir marcar o valor");
} /* fim ativa: LIS Setar Valor INTEIRO*/
/* Testar Procurar Valor */
else if(strcmp(ComandoTeste, PROCURAR_VALOR_CMD) == 0) {
numLidos = LER_LerParametros("iii", &inxLista, &inxStoredPtr, &CondRetEsp);
if((numLidos != 3) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
if(!ValidarInxStoredPtr(inxStoredPtr))
return TST_CondRetParm;
return TST_CompararInt(CondRetEsp, LIS_ProcurarValor(vtListas[inxLista], storedPtr[inxLista][inxStoredPtr]),
"Condicao de retorno errada ao procurar valor");
} /* fim ativa: LIS Procurar Valor */
return TST_CondRetNaoConhec;
} /* Fim função: TLIS &Testar lista */
int main (void)
{
int qtdprocessos, met;
FILE* out = fopen("saida.txt","w");
int i, j, fail = 0, cnt = 0, tamProntos, tamIO, tamIO2, seg = 0, inxExec, inxIO;
Processo *aux, *procExec, *procIO, *procRetirado;
LIS_tppLista listaIO = LIS_CriarLista();
LIS_tppLista listaProntos = LIS_CriarLista();
Memory * mem = (Memory*)malloc(sizeof(Memory));
FILE* fp = fopen("entrada.txt", "r");
Processo *vp = (Processo*)malloc(100*sizeof(Processo));
qtdprocessos = lerEntrada(&fp, vp);
imprimeVetor(vp, qtdprocessos);
InicializaMemoria(mem);
procExec = NULL;
// Insere os elementos lidos numa lista de prontos
for(i = 0; i < qtdprocessos; i++)
{
LIS_InserirElementoApos(listaProntos, &vp[i]);
LIS_AvancarElementoCorrente(listaProntos, 1);
vp[i].segAtual = -1;
vp[i].naMemoria = 0;
vp[i].t_exec = 0;
vp[i].t_io = 0;
}
printf("1: First Fit \n");
printf("2: Best Fit \n");
printf("3: Worst Fit \n");
printf("4: Next Fit \n");
scanf("%d", &met);
EXEC:
IrInicioLista(listaProntos); // vai pro inicio da lista de prontos
aux = (Processo*)LIS_ObterValor(listaProntos);
switch(met)
{
case 1:
firstFit(mem, listaProntos);
break;
case 2:
BestFit(mem, listaProntos);
break;
case 3:
WorstFit(mem, listaProntos);
break;
case 4:
NextFit(mem, listaProntos);
break;
default:
break;
}
imprimeMemoria(mem);
printf("\n Lista de Prontos \n");
ImprimirLista(listaProntos);
printf("\n Lista de IO \n");
ImprimirLista(listaIO);
/* * * * * * * * * * * * * * * * * * * * * * */
// executar o processo
IrInicioLista(listaProntos);
tamProntos = LIS_ObterTamanho(listaProntos);
tamIO = LIS_ObterTamanho(listaIO);
aux = (Processo*)LIS_ObterValor(listaProntos); // obtem o priemeiro elemento da lista de prontos
while(tamProntos > 0)
{
if(!aux->naMemoria) // se o processo não esta em memoria
{
LIS_AvancarElementoCorrente(listaProntos, 1);
aux = (Processo*)LIS_ObterValor(listaProntos);
continue;
}
procExec = aux;
for(i = 0; i < 10; i++) // os 10 clocks de cpu
{
ImprimirEstado(&out, listaIO, procExec, mem, tempoTotal);
clock(1); tempoTotal++;
inxExec = procExec->t_exec;
procExec->exec[inxExec]--;
tamIO = LIS_ObterTamanho(listaIO);
IrInicioLista(listaIO);
for(j = 0; j < tamIO; j++) // diminui 1 de IO para todos q estao na lista de I/O
{
procIO = (Processo*)LIS_ObterValor(listaIO);
inxIO = procIO->t_io;
procIO->io[inxIO]--;
if(procIO->io[inxIO] == 0) // seu tempo de io acabou
{
LIS_ExcluirElemento(listaIO); // retira da lista de io e insere-o na lista de prontos
IrFinalLista(listaProntos);
LIS_InserirElementoApos(listaProntos, procIO);
procIO->t_io++;
}
LIS_AvancarElementoCorrente(listaIO, 1);
}
tamIO2 = LIS_ObterTamanho(listaIO);
if(tamIO != tamIO2)
{
switch(met)
{
case 1:
firstFit(mem, listaProntos);
break;
case 2:
BestFit(mem, listaProntos);
break;
case 3:
WorstFit(mem, listaProntos);
break;
case 4:
NextFit(mem, listaProntos);
break;
default:
break;
}
}
getNext(listaProntos);
if(procExec->exec[inxExec] == 0 || i == 9) // se o seu tempo de exec terminou entao retira da memoria
{
/* * * * * */ //imprimeMemoria(mem);
LIS_ExcluirElemento(listaProntos);
if(procExec->exec[inxExec] == 0) procExec->t_exec++; // se acabou um exec inteiro
if(procExec->exec[inxExec] == 0 && procExec->t_io < procExec->qtdio) // se o processo terminou um exec e ainda tem io para fazer
{
IrFinalLista(listaIO);
LIS_InserirElementoApos(listaIO, procExec);
}
// retira da memoria
// se o processo ainda tem exec para fazer
if(procExec->exec[inxExec] > 0)
{
IrFinalLista(listaProntos);
LIS_InserirElementoApos(listaProntos, procExec);
}
seg = procExec->segAtual;
procRetirado = RetiraProcessoMem(mem, seg);
procRetirado->naMemoria = 0;
switch(met)
{
case 1:
firstFit(mem, listaProntos);
break;
case 2:
BestFit(mem, listaProntos);
break;
case 3:
WorstFit(mem, listaProntos);
break;
case 4:
NextFit(mem, listaProntos);
break;
default:
break;
}
break;
}
imprimeMemoria(mem);
printf("\n Lista de Prontos \n");
ImprimirLista(listaProntos);
printf("\n Lista de IO \n");
ImprimirLista(listaIO);
} /* final dos 10 clocks*/
imprimeMemoria(mem);
printf("\n Lista de Prontos \n");
ImprimirLista(listaProntos);
printf("\n Lista de IO \n");
ImprimirLista(listaIO);
tamProntos = LIS_ObterTamanho(listaProntos);
IrInicioLista(listaProntos);
aux = (Processo*)LIS_ObterValor(listaProntos);
}
tamIO = LIS_ObterTamanho(listaIO);
while(tamIO > 0) // entao tem IO sobrando e ngm para executar
{
IrInicioLista(listaIO);
clock(1);tempoTotal++;
for(j = 0; j < tamIO; j++) // diminui 1 de IO para todos q estao na lista de I/O
{
procIO = (Processo*)LIS_ObterValor(listaIO);
inxIO = procIO->t_io;
procIO->io[inxIO]--;
if(procIO->io[inxIO] == 0) // seu tempo de io acabou
{
LIS_ExcluirElemento(listaIO); // retira da lista de io e insere-o na lista de prontos
IrFinalLista(listaProntos);
LIS_InserirElementoApos(listaProntos, procIO);
procIO->t_io++;
}
LIS_AvancarElementoCorrente(listaIO, 1);
}
tamIO = LIS_ObterTamanho(listaIO);
tamProntos = LIS_ObterTamanho(listaProntos);
imprimeMemoria(mem);
printf("\n Lista de Prontos \n");
ImprimirLista(listaProntos);
printf("\n Lista de IO \n");
ImprimirLista(listaIO);
if(tamProntos > 0) // se alguem voltou par a lista de prontos...
goto EXEC;
}
fclose(out);
free(mem);
free(vp);
free(listaProntos);
free(listaIO);
return 0;
}
