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; }