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; }
GRA_tppGrafo GRA_CriarGrafo( void (*ExcluirValor) (void* pDado) ) { GRA_tpGrafo * pGrafo = NULL ; LIS_tppLista l_vertice = NULL; LIS_tppLista l_componente = NULL; pGrafo = (GRA_tpGrafo*) calloc(1, sizeof(GRA_tpGrafo)) ; if (pGrafo == NULL) { return NULL ; } /* if */ l_vertice = LIS_CriarLista(free); //A Exclusão será manual, iterando sobre os elementos; if (l_vertice == NULL) { free(pGrafo); return NULL; } l_componente = LIS_CriarLista(NULL); //Controle interno e autocontido; Componentes não cuidam de dados do valor, só armazenam ponteiros. if (l_componente == NULL) { free(pGrafo); LIS_DestruirLista(l_vertice); return NULL; } pGrafo->vertices = l_vertice; pGrafo->componentes = l_componente; pGrafo->ExcluirValor = ExcluirValor ; pGrafo->corrente = -1; return pGrafo; }
/*************************************************************************** * 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; }
TAB_tpCondRet TAB_CriarTabuleiro(TAB_tppTabuleiro * pTab, void ( * ExcluirValor ) ( void * pDado ) ) { LIS_tppLista vtCasa[24]; // vetor de casas auxiliar tppPeca vtPecaB[15]; // vetor de peças brancas tppPeca vtPecaP[15]; //vetor de peças pretas int i, jb = 0,jp = 0; *pTab = (TAB_tppTabuleiro)malloc(sizeof(TAB_tpTabuleiro)); (*pTab)->Casas = LIS_CriarLista(ExcluirValor); /* Cria 15 peças brancas */ for(i = 0; i < 15; i++) { if(Pec_CriarPeca(&vtPecaB[i], 'b')!=Pec_CondRetOK) return TAB_CondRetErro; } /* Cria 15 peças pretas */ for(i = 0; i < 15; i++) { if(Pec_CriarPeca(&vtPecaP[i], 'p')!=Pec_CondRetOK) return TAB_CondRetErro; } /* Cria 24 listas que representam cada casa do tabuleiro*/ for(i = 0; i < 24; i++) vtCasa[i] = LIS_CriarLista(ExcluirValor); // Pretas LIS_InserirElementoApos(vtCasa[23], vtPecaP[jp]); jp++; LIS_InserirElementoApos(vtCasa[23], vtPecaP[jp]); jp++; // Brancas LIS_InserirElementoApos(vtCasa[0], vtPecaB[jb]); jb++; LIS_InserirElementoApos(vtCasa[0], vtPecaB[jb]); jb++; for(i = 0; i < 5; i++) { // Pretas LIS_InserirElementoApos(vtCasa[5], vtPecaP[jp]); jp++; LIS_InserirElementoApos(vtCasa[12], vtPecaP[jp]); jp++; // Brancas LIS_InserirElementoApos(vtCasa[11], vtPecaB[jb]); jb++; LIS_InserirElementoApos(vtCasa[18], vtPecaB[jb]); jb++; } for(i = 0; i < 3; i++) { // Pretas LIS_InserirElementoApos(vtCasa[7], vtPecaP[jp]); jp++; // Brancas LIS_InserirElementoApos(vtCasa[16], vtPecaB[jb]); jb++; } // Alocar as 24 casas na lista do tabuleiro for(i = 0; i < 24; i++) LIS_InserirElementoApos((*pTab)->Casas, vtCasa[i]); return TAB_CondRetOK; }
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; }
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; }
Graph *GRA_New (FDelData fdd) { Graph *g; CNT_CONTAR("GRA_New - Inicializao"); g = (Graph *) malloc(sizeof(Graph)); if (!g){ CNT_CONTAR("GRA_New - Nao alocou g"); return NULL; } g->nodes = LIS_CriarLista((FDelData) LIS_DestruirLista ); CNT_CONTAR("GRA_New - Alocando nodes"); if (!g->nodes){ CNT_CONTAR("GRA_New - Nao alocou nodes"); free (g); return NULL; } g->delData = fdd; g->currentNode = NULL; CNT_CONTAR("GRA_New - Atribuies, finalizao"); #ifdef _DEBUG g->nOfNodes = 0; g->nOfLinks = 0; CNT_CONTAR("GRA_New - Chamando AssertGraph, finalizando"); AssertGraph(g); #endif /* _DEBUG */ return g; }
CPC_tpCondRet CPC_CriarClassePeca( CPC_tppClassePeca * ppClassePeca , char * nome ) { CPC_tpClassePeca * cp; cp = (CPC_tppClassePeca)malloc(sizeof(CPC_tpClassePeca)); if(cp == NULL) { return CPC_CondRetFaltouMemoria; } cp->nome = (char*)malloc(sizeof(char) * (strlen(nome) + 1)); if(cp->nome == NULL) { free(cp); return CPC_CondRetFaltouMemoria; } strcpy(cp->nome, nome); cp->movimentos = LIS_CriarLista( free ); if(cp->movimentos == NULL) { free(cp->nome); free(cp); return CPC_CondRetFaltouMemoria; } *ppClassePeca = cp; return CPC_CondRetOK; }
/*************************************************************************** * Função: GRA Criar grafo ******/ GRA_tpCondRet GRA_CriarGrafo(GRA_tppGrafo *ppGrafo, void (*destruirValor)(void *pValor)) { tpGrafo *pGrafo; MEM_Alloc(sizeof(tpGrafo), (void **) &pGrafo); pGrafo->pCorrente = NULL; pGrafo->destruirValor = destruirValor; LIS_CriarLista(&pGrafo->pOrigens, NULL, CompararVerticeENome); LIS_CriarLista(&pGrafo->pVertices, DestruirVertice, CompararVerticeENome); *ppGrafo = (GRA_tppGrafo) pGrafo; return GRA_CondRetOK; }
FIL_tppFila FIL_criaFila (int capacidade, void( * ExcluirValor ) ( void * pDado ) ) { FIL_tppFila fila=(FIL_tpFila*)malloc(sizeof(FIL_tpFila)); fila->capacidade=capacidade; LIS_CriarLista(&(fila->lista),ExcluirValor); return fila; }
void GRA_CriaListaSucessoresVertice(tpVerticeGrafo * pVertice) { LIS_tppLista pListaSuc ; LIS_CriarLista (GRA_excluirValorLista, &pListaSuc); pVertice->pVerSuc = pListaSuc ; } /* Fim função: GRA &Criar Lista de sucessores do vertice do Grafo */
void GRA_CriaListaAntecessoresVertice(tpVerticeGrafo * pVertice) { LIS_tppLista pListaAnt ; LIS_CriarLista (GRA_excluirValorLista , &pListaAnt); pVertice->pVerAnt = pListaAnt ; } /* Fim função: GRA &Criar Lista de antecessores do vertice do Grafo */
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; }
void GRA_CriaListaOrigens( GRA_tppGrafo pGrafo ) { LIS_tppLista pListaOrig ; LIS_CriarLista (GRA_excluirValorLista , &pListaOrig); pGrafo->pListaOrigens = pListaOrig ; } /* Fim função: GRA &Criar Lista de origens Grafo */
/***** 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; }
void GRA_CriaListaVertices( GRA_tppGrafo pGrafo ) { LIS_tppLista pListaVert ; LIS_CriarLista (GRA_excluirValorLista, &pListaVert); pGrafo->pListaVertices= pListaVert ; } /* Fim função: GRA &Criar Lista de vértices Grafo */
BAR_tpCondRet BAR_CriarBAR(BAR_tppCapturadas *pBAR, char cor, void ( * ExcluirValor ) ( void * pDado ) ) { *pBAR = (BAR_tppCapturadas)malloc(sizeof(BAR_tpCapturadas)); if(*pBAR == NULL) return BAR_CondRetFaltouMemoria; (*pBAR)->ListaCapturadas = LIS_CriarLista(ExcluirValor); (*pBAR)->cor = cor; (*pBAR)->tamanho = 0; return BAR_CondRetOK; }
Tabuleiro *TAB_criar() { int x, y; Tabuleiro *tabuleiro = (Tabuleiro*)malloc(sizeof(Tabuleiro)); if(!tabuleiro) return NULL; //Tratamento de espaço dinamico #ifdef _DEBUG CED_DefinirTipoEspaco(tabuleiro, TAB_Tabuleiro); #endif tabuleiro->lista = LIS_CriarLista(ListaExcluirLista); if(!tabuleiro->lista) { free(tabuleiro); return NULL; } for(y = 0; y < TabuleiroAltura; ++y) { LIS_tppLista lista = LIS_CriarLista(ListaExcluirPeca); if(!lista) { TAB_destruir(tabuleiro); return NULL; } if(LIS_InserirElementoAntes(tabuleiro->lista, lista) != LIS_CondRetOK) { TAB_destruir(tabuleiro); return NULL; } for(x = 0; x < TabuleiroLargura; ++x){ if(LIS_InserirElementoAntes(lista, NULL) != LIS_CondRetOK) { TAB_destruir(tabuleiro); return NULL; } } } return tabuleiro; }/* Fim função: TAB &Criar tabuleiro */
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; }
/*************************************************************************** * * Função: PIL &Criar Pilha Cartas * ****/ PIL_tpCondRet PIL_CriarPilhaCartas (PIL_tpPilha *pPilha) { LIS_tpCondRet condRet; *pPilha = (PIL_tppPilha*) malloc (sizeof(PIL_tppPilha)); if (*pPilha == NULL) return PIL_CondRetFaltouMemoria; condRet = LIS_CriarLista( &((*pPilha)->cabeca) ,CAR_DestruirCarta ); if (condRet == LIS_CondRetFaltouMemoria){ free(*pPilha); return PIL_CondRetFaltouMemoria; } else return PIL_CondRetOK; } /* Fim função: PIL &Criar Pilha Cartas */
PILHA_tpCondRet PILHA_CriarPilha(PILHA_tppPilha * pp) { PILHA_tppPilha p = NULL; p = (PILHA_tppPilha)malloc(sizeof(PILHA_tpPilha)); if (!p) return PILHA_CondRetFaltouMemoria; #ifdef _DEBUG CNT_CONTAR("PILHA_CriarPilha"); #endif p->topo = LIS_CriarLista(NULL); p->ExcluirValor = NULL; p->quantidade = 0; *pp = p; #ifdef _DEBUG CED_MarcarEspacoAtivo(pp); #endif return PILHA_CondRetOK; } /* Fim função: PILHA Cria Pilha */
PIL_tpCondRet PIL_CriarPilhaVazia( PIL_tppPilha * pPilha ) { LIS_tpCondRet condRet ; *pPilha = NULL ; *pPilha = ( PIL_tpPilha * ) malloc( sizeof( PIL_tpPilha ) ) ; if( *pPilha == NULL ) { return PIL_CondRetFaltouMemoria ; } /* if */ condRet = LIS_CriarLista( &((*pPilha)->pListaCartas) , ExcluirCarta ) ; if ( condRet == LIS_CondRetFaltouMemoria ) { return PIL_CondRetFaltouMemoria ; } return PIL_CondRetOK ; } /* Fim função: PIL &Criar Pilha Vazia */
/*********************************************************************** * * $FC Função: MEN CriarMenu * ***********************************************************************/ MEN_tpCondRet MEN_CriarMenu(MEN_tppMenus menus, int id, char* nome,int idpai) { MEN_tpCondRet cr; MEN_tppMenu m = (MEN_tppMenu)malloc(sizeof(Menu)); if(m==NULL) return MEN_CondRetFaltouMemoria; m->opcoes = LIS_CriarLista(free); if(m->opcoes==NULL){ free(m); return MEN_CondRetFaltouMemoria; } m->nome = nome; m->id = id; m->pai = idpai; GRA_InserirVertice(menus->grafo,m,m->id); cr = MEN_CriarOpcao(menus, m->id,'0', "Ir para o menu acima\n\t\t (encerrar o programa caso o menu atual seja Inicio)",volta); if(cr!=MEN_CondRetOK) { LIS_DestruirLista(m->opcoes); free(m); } //tratar cond ret return cr; }
//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; }
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; }