Example #1
0
	DES_tpCondRet DES_DestroiDesenho( void )
	{
		int i; 

		// Testa se o ponteiro desenho já foi iniciado;
		if( pDesenho == NULL )
			return DES_CondRetDesenhoNaoIniciado;

		// Libera cada cabeça de lista
		for( i = 0; i < pDesenho->iLinhas; i++ )
			LST_DestruirLista( pDesenho->pListasHorizontais[i], ExcluiValor );

		#ifdef _DEBUG
			CED_MarcarEspacoNaoAtivo( pDesenho->pListasHorizontais );
		#endif
		// Libera o vetor de cabeças de lista
		free( pDesenho->pListasHorizontais );

		// Libera cada cabeça de lista
		for( i = 0; i < pDesenho->iColunas; i++ )
			LST_DestruirLista( pDesenho->pListasVerticais[i], ExcluiValor );

		#ifdef _DEBUG
			CED_MarcarEspacoNaoAtivo( pDesenho->pListasVerticais );
		#endif
		// Libera o vetor de cabeças de lista
		free( pDesenho->pListasVerticais );

		// Libera a matriz de jogo
		MAT_DestruirMatriz( pDesenho->pMatrizJogo, ExcluiCelula );

		#ifdef _DEBUG
			CED_MarcarEspacoNaoAtivo( pDesenho->pMatrizJogo );
		#endif
		// Libera o ponteiro para estrutura matriz
		free( pDesenho->pMatrizJogo );

		#ifdef _DEBUG
			CED_MarcarEspacoNaoAtivo( pDesenho );
		#endif
		// Libera o ponteiro para estrutura encapsulada Desenho 
		free( pDesenho );

		pDesenho = NULL;

		return DES_CondRetOk;
	}
Example #2
0
File: PILHA.C Project: Rifeli/t4
PILHA_tpCondRet PILHA_DestroiPilha(PILHA_tppPilha p){
	if(!p){
		return PILHA_CondRetPilhaInexistente;
	}

#ifdef _DEBUG
	CED_MarcarEspacoNaoAtivo(p);
#endif

	LIS_DestruirLista(p->topo);
	free(p);

	return PILHA_CondRetOK;
}
Example #3
0
File: LISTA.C Project: Rifeli/t4
void LIS_DestruirLista( LIS_tppLista pLista )
{
#ifdef _DEBUG
	CED_MarcarEspacoNaoAtivo(pLista);
#endif
#ifdef _DEBUG
	assert( pLista != NULL ) ;
#endif

	LIS_EsvaziarLista( pLista ) ;

	free( pLista ) ;

} /* Fim função: LIS  &Destruir lista */
Example #4
0
LST_tpCondRet LST_DestruirLista( TpLista * pLista, void ( * ExcluirValor) ( void * pDado)  )
{

	if ( pLista == NULL)
	{
		return LST_CondRetListaInexistente;
	} /* if */

	LST_EsvaziarLista ( pLista , ExcluirValor );

#ifdef _DEBUG
	CED_MarcarEspacoNaoAtivo( pLista );
#endif
	free ( pLista );
	return LST_CondRetOK;

} /* Fim função: LST Destruir lista duplamente encadeada*/
Example #5
0
File: LISTA.C Project: Rifeli/t4
LIS_tpCondRet LIS_ExcluirElemento( LIS_tppLista pLista )
{

	tpElemLista * pElem ;

#ifdef _DEBUG
	CED_MarcarEspacoNaoAtivo(pLista->pElemCorr);
#endif

#ifdef _DEBUG
	assert( pLista  != NULL ) ;
#endif

	if ( pLista->pElemCorr == NULL )
	{
		return LIS_CondRetListaVazia ;
	} /* if */

	pElem = pLista->pElemCorr ;

	/* Desencadeia à esquerda */

	if ( pElem->pAnt != NULL )
	{
		pElem->pAnt->pProx   = pElem->pProx ;
		pLista->pElemCorr    = pElem->pAnt ;
	} else {
		pLista->pElemCorr    = pElem->pProx ;
		pLista->pOrigemLista = pLista->pElemCorr ;
	} /* if */

	/* Desencadeia à direita */

	if ( pElem->pProx != NULL )
	{
		pElem->pProx->pAnt = pElem->pAnt ;
	} else
	{
		pLista->pFimLista = pElem->pAnt ;
	} /* if */

	LiberarElemento( pLista , pElem ) ;

	return LIS_CondRetOK ;

} /* Fim função: LIS  &Excluir elemento */
Example #6
0
void LiberarNo( TpLista * pLista , TpNoLista * pElem, void ( * ExcluirValor) ( void * pDado) )
{

	if (( pElem != NULL ))
	{
		pElem->pAnt = pElem->pProx;
		ExcluirValor ( pElem->pValor ) ;

		pLista->numElementos = pLista->numElementos - 1;
#ifdef _DEBUG
		CED_MarcarEspacoNaoAtivo(pElem);
#endif
		free(pElem);
	} /* if */



} /* Fim função: LST Liberar No da lista */
Example #7
0
File: LISTA.C Project: Rifeli/t4
void LiberarElemento( LIS_tppLista   pLista ,
	tpElemLista  * pElem   )
{

#ifdef _DEBUG
	CED_MarcarEspacoNaoAtivo(pElem);
#endif

	if ( ( pLista->ExcluirValor != NULL )
		&& ( pElem->pValor != NULL        ))
	{
		pLista->ExcluirValor( pElem->pValor ) ;
	} /* if */

	free( pElem ) ;

	pLista->numElem-- ;

} /* Fim função: LIS  -Liberar elemento da lista */
Example #8
0
void LIS_eliminaElemCorr(LIS_tppLista pLista){  // 1
	CED_MarcarEspacoNaoAtivo(pLista->pElemCorr);
	free(pLista->pElemCorr);
	
}
Example #9
0
   TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
   {

      int  i ;
         
      int  numLidos    = -1 ;
      int  inxEspaco   = -1 ;
      int  valEsperado = -1 ;
      int  valObtido   = -1 ;
         
      #define  DIM_STRING_PARM   100
      char StringParm[ DIM_STRING_PARM ] ;
         
      int       Deslocamento ;
      int       Valor ;

      int   Tamanho ;
      int   numLinhaFonte ;

      int idTipo ;

      int numAllocs  = -1 ,
          Frequencia =  0 ,
          ContaNULL  =  0 ;

      double Tolerancia      ,
             PercentEsperado ,
             PercentObtido   ;

      void * pEspaco = NULL ;

      InstrumentarString( StringParm , DIM_STRING_PARM ) ;

      /* Tratar: Reinicializar módulo de teste espeçifico */

         if ( strcmp( ComandoTeste , ResetEspacosCmd ) == 0 )
         {

            if ( EhPrimeiraVez )
            {
               EhPrimeiraVez = FALSE ;

               for( i = 0 ; i < DIM_VT_ESPACO ; i ++ )
               {
                  vtEspaco[ i ] = NULL ;
               } /* for */

               return TST_CondRetOK ;
            } /* if */

            for( i = 0 ; i < DIM_VT_ESPACO ; i++ )
            {
               if ( vtEspaco[ i ] != NULL )
               {
                  CED_Free( vtEspaco[ i ] ) ;
                  vtEspaco[ i ] = NULL ;
               } /* if */
            } /* for */

            return TST_CondRetOK ;

         } /* fim ativa: Tratar: Reinicializar módulo de teste espeçifico */

      /* Tratar: Deturpar espaço */

         else if ( strcmp( ComandoTeste , DeturparEspacoCmd ) == 0 )
         {

            numLidos = LER_LerParametros( "iii" ,
                               &inxEspaco , &Deslocamento , &Valor ) ;

            if ( ( numLidos != 3 )
              || !VerificarInxEspaco( inxEspaco , TRUE ))
            {
               return TST_CondRetParm ;
            } /* if */

            (( char * ) vtEspaco[ inxEspaco ] )[ Deslocamento ] = ( char ) Valor ;

            return TST_CondRetOK ;

         } /* fim ativa: Tratar: Deturpar espaço */

      /* Tratar: Atribuir string ao espaço */

         else if ( strcmp( ComandoTeste , InserirStringEspacoCmd ) == 0 )
         {

            numLidos = LER_LerParametros( "is" ,
                               &inxEspaco , StringParm ) ;

            if ( ( numLidos != 2 )
              || !VerificarInxEspaco( inxEspaco , TRUE )
              || !VerificarString( StringParm , DIM_STRING_PARM ))
            {
               return TST_CondRetParm ;
            } /* if */

            strcpy( vtEspaco[ inxEspaco ] , StringParm ) ;

            return TST_CondRetOK ;

         } /* fim ativa: Tratar: Atribuir string ao espaço */

      /* Testar: Obter string contido no espaço */

         else if ( strcmp( ComandoTeste , ObterStringEspacoCmd ) == 0 )
         {

            numLidos = LER_LerParametros( "is" ,
                               &inxEspaco , StringParm ) ;

            if ( ( numLidos != 2 )
              || !VerificarInxEspaco( inxEspaco , TRUE )
              || !VerificarString( StringParm , DIM_STRING_PARM ))
            {
               return TST_CondRetParm ;
            } /* if */

            return TST_CompararEspaco( StringParm , vtEspaco[ inxEspaco ] ,
                      strlen( StringParm ) , "Conteúdo do valor errado." ) ;

         } /* fim ativa: Testar: Obter string contido no espaço */

      /* Testar: CED &Alocar espaço */

         else if ( strcmp( ComandoTeste , AlocarEspacoCmd ) == 0 )
         {

            numLidos = LER_LerParametros( "iiis" ,
                               &inxEspaco , &Tamanho , &numLinhaFonte , StringParm ) ;

            if ( ( numLidos != 4 )
              || ( Tamanho  <= 0 )
              || ( numLinhaFonte < 1 )
              || !VerificarInxEspaco( inxEspaco , FALSE )
              || !VerificarString( StringParm , DIM_STRING_PARM ))
            {
               return TST_CondRetParm ;
            } /* if */

            vtEspaco[ inxEspaco ] =
                      CED_Malloc( Tamanho , numLinhaFonte , StringParm ) ;

            return TST_CondRetOK ;

         } /* fim ativa: Testar: CED &Alocar espaço */

      /* Testar: CED &Desalocar espaço */

         else if ( strcmp( ComandoTeste , DesalocarEspacoCmd ) == 0 )
         {

            numLidos = LER_LerParametros( "i" ,
                               &inxEspaco ) ;

            if ( ( numLidos != 1 )
              || !VerificarInxEspaco( inxEspaco , FALSE ))
            {
               return TST_CondRetParm ;
            } /* if */

            CED_Free( vtEspaco[ inxEspaco ] ) ;

            vtEspaco[ inxEspaco ] = NULL ;

            return TST_CondRetOK ;

         } /* fim ativa: Testar: CED &Desalocar espaço */

      /* Testar: CED &Exibir conteúdo bruto do espaço */

         else if ( strcmp( ComandoTeste , ExibirEspacoBrutoCmd ) == 0 )
         {

            #define  DIM_ESPACO  70

            numLidos = LER_LerParametros( "i" ,
                               &inxEspaco ) ;

            if ( ( numLidos != 1 )
              || !VerificarInxEspaco( inxEspaco , FALSE ))
            {
               return TST_CondRetParm ;
            } /* if */

            TST_ExibirEspacoHexa( DIM_ESPACO + 4 , (( char * ) vtEspaco[ inxEspaco ] ) - DIM_ESPACO ) ;

            return TST_CondRetOK ;

         } /* fim ativa: Testar: CED &Exibir conteúdo bruto do espaço */

      /* Testar: CED &Exibir conteúdo útil do espaço */

         else if ( strcmp( ComandoTeste , ExibirEspacoCmd ) == 0 )
         {

            numLidos = LER_LerParametros( "i" ,
                               &inxEspaco ) ;

            if ( ( numLidos != 1 )
              || !VerificarInxEspaco( inxEspaco , FALSE ))
            {
               return TST_CondRetParm ;
            } /* if */

            CED_ExibirEspaco( vtEspaco[ inxEspaco ] ) ;

            return TST_CondRetOK ;

         } /* fim ativa: Testar: CED &Exibir conteúdo útil do espaço */

      /* Testar: CED &Verificar a integridade de um espaço de dados */

         else if ( strcmp( ComandoTeste , VerificarEspacoCmd ) == 0 )
         {

            numLidos = LER_LerParametros( "ii" ,
                               &inxEspaco , &valEsperado ) ;

            if ( ( numLidos != 2 )
              || !VerificarInxEspaco( inxEspaco , FALSE ))
            {
               return TST_CondRetParm ;
            } /* if */

            valObtido = CED_VerificarEspaco( vtEspaco[ inxEspaco ] ,
                                             VerificarValor ) ;

            return TST_CompararBool( valEsperado , valObtido ,
                   "Verificação resultou errado." ) ;

         } /* fim ativa: Testar: CED &Verificar a integridade de um espaço de dados */

      /* Testar: CED &Definir o tipo do espaço */

         else if ( strcmp( ComandoTeste , DefinirTipoEspacoCmd ) == 0 )
         {

            numLidos = LER_LerParametros( "iii" ,
                               &inxEspaco , &idTipo , &valEsperado ) ;

            if ( ( numLidos != 3 )
              || !VerificarInxEspaco( inxEspaco , FALSE ))
            {
               return TST_CondRetParm ;
            } /* if */

            valObtido = CED_DefinirTipoEspaco( vtEspaco[ inxEspaco ] , idTipo );

            return TST_CompararInt( valEsperado , valObtido ,
                   "Condição de retorno errada." ) ;

         } /* fim ativa: Testar: CED &Definir o tipo do espaço */

      /* Testar: CED &Obter o tipo do espaço */

         else if ( strcmp( ComandoTeste , ObterTipoEspacoCmd ) == 0 )
         {

            numLidos = LER_LerParametros( "ii" ,
                               &inxEspaco , &valEsperado ) ;

            if ( ( numLidos != 2 )
              || !VerificarInxEspaco( inxEspaco , FALSE ))
            {
               return TST_CondRetParm ;
            } /* if */

            valObtido = CED_ObterTipoEspaco( vtEspaco[ inxEspaco ] ) ;

            return TST_CompararInt( valEsperado , valObtido ,
                   "Tipo do espaço errado." ) ;

         } /* fim ativa: Testar: CED &Obter o tipo do espaço */

      /* Testar: CED &Obter tamanho do valor contido no espaço */

         else if ( strcmp( ComandoTeste , ObterTamanhoEspacoCmd ) == 0 )
         {

            numLidos = LER_LerParametros( "ii" ,
                               &inxEspaco , &valEsperado ) ;

            if ( ( numLidos != 2 )
              || !VerificarInxEspaco( inxEspaco , FALSE ))
            {
               return TST_CondRetParm ;
            } /* if */

            valObtido = CED_ObterTamanhoValor( vtEspaco[ inxEspaco ] ) ;

            return TST_CompararInt( valEsperado , valObtido ,
                   "Tamanho do valor errado." ) ;

         } /* fim ativa: Testar: CED &Obter tamanho do valor contido no espaço */

      /* Testar: CED &Marcar ativo o espaço */

         else if ( strcmp( ComandoTeste , MarcarEspacoAtivoCmd ) == 0 )
         {

            numLidos = LER_LerParametros( "i" ,
                               &inxEspaco ) ;

            if ( ( numLidos != 1 )
              || !VerificarInxEspaco( inxEspaco , TRUE ))
            {
               return TST_CondRetParm ;
            } /* if */

            CED_MarcarEspacoAtivo( vtEspaco[ inxEspaco ] ) ;

            return TST_CondRetOK ;

         } /* fim ativa: Testar: CED &Marcar ativo o espaço */

      /* Testar: CED &Marcar não ativo o espaço */

         else if ( strcmp( ComandoTeste , MarcarEspacoNaoAtivoCmd ) == 0 )
         {

            numLidos = LER_LerParametros( "i" ,
                               &inxEspaco ) ;

            if ( ( numLidos != 1 )
              || !VerificarInxEspaco( inxEspaco , TRUE ))
            {
               return TST_CondRetParm ;
            } /* if */

            CED_MarcarEspacoNaoAtivo( vtEspaco[ inxEspaco ] ) ;

            return TST_CondRetOK ;

         } /* fim ativa: Testar: CED &Marcar não ativo o espaço */

      /* Testar: CED &Marcar não ativos todos os espaços */

         else if ( strcmp( ComandoTeste , MarcarTodosNaoAtivosCmd ) == 0 )
         {

            CED_MarcarTodosEspacosInativos( ) ;

            return TST_CondRetOK ;

         } /* fim ativa: Testar: CED &Marcar não ativos todos os espaços */

      /* Testar: CED &Verificar se espaço é ativo */

         else if ( strcmp( ComandoTeste , VerificarEspacoAtivoCmd ) == 0 )
         {

            numLidos = LER_LerParametros( "ii" ,
                               &inxEspaco , &valEsperado ) ;

            if ( ( numLidos != 2 )
              || !VerificarInxEspaco( inxEspaco , TRUE ))
            {
               return TST_CondRetParm ;
            } /* if */

            valObtido = CED_EhEspacoAtivo( vtEspaco[ inxEspaco ] ) ;

            return TST_CompararInt( valEsperado , valObtido ,
                   "Marca de espaço ativo errada." ) ;

         } /* fim ativa: Testar: CED &Verificar se espaço é ativo */

      /* Testar CED  &Limitar com freqüência de geração de NULL */

         else if ( strcmp( ComandoTeste , VerificarFrequenciaCmd ) == 0 )
         {

            numLidos = LER_LerParametros( "iif" ,
                               &numAllocs , &Frequencia , &Tolerancia ) ;

            if ( ( numLidos != 3   )
              || ( numAllocs < 100 ))
            {
               return TST_CondRetParm ;
            } /* if */

            valObtido = CED_LimitarFrequencia( Frequencia ) ;
            if ( !valObtido )
            {
               return TST_NotificarFalha( "Freqüência limite de malloc em erro." ) ;
            } /* if */

            for( i = 0 ; i < numAllocs ; i++ )
            {
               pEspaco = CED_Malloc( 100 , i + 1 , "TesteFrequencia" ) ;
               if ( pEspaco == NULL )
               {
                  ContaNULL ++ ;
               } else
               {
                  CED_Free( pEspaco ) ;
               } /* if */
            } /* for */

            PercentEsperado = ( 1000. - Frequencia ) / 1000. ;

            PercentObtido   = ContaNULL ;
            PercentObtido   = PercentObtido / numAllocs ;

            return TST_CompararFloat( PercentEsperado , PercentObtido , Tolerancia ,
                        "Número de NULLs gerados está fora da tolerância." ) ;

         } /* fim ativa: Testar CED  &Limitar com freqüência de geração de NULL */

      /* Testar: CED &Iterador: iniciar iterador de espaços */

         else if ( strcmp( ComandoTeste , IniciarIteradorEspacosCmd ) == 0 )
         {

            CED_InicializarIteradorEspacos(  ) ;

            return TST_CondRetOK ;

         } /* fim ativa: Testar: CED &Iterador: iniciar iterador de espaços */

      /* Testar: CED &Iterador: avançar para o próximo espaço */

         else if ( strcmp( ComandoTeste , AvancarProximoEspacoCmd ) == 0 )
         {

            numLidos = LER_LerParametros( "i" ,
                               &valEsperado ) ;

            if ( numLidos != 1 )
            {
               return TST_CondRetParm ;
            } /* if */

            valObtido = CED_AvancarProximoEspaco( ) ;

            return TST_CompararInt( valEsperado , valObtido ,
                   "Condição de avanço errada." ) ;

         } /* fim ativa: Testar: CED &Iterador: avançar para o próximo espaço */

      /* Testar: CED &Iterador: obter referência para o espaço corrente */

         else if ( strcmp( ComandoTeste , ObterEspacoCorrenteCmd ) == 0 )
         {

            numLidos = LER_LerParametros( "i" ,
                               &inxEspaco ) ;

            if ( ( numLidos != 1 )
              || !VerificarInxEspaco( inxEspaco , FALSE ))
            {
               return TST_CondRetParm ;
            } /* if */

            vtEspaco[ inxEspaco ] = CED_ObterPonteiroEspacoCorrente( ) ;

            return TST_CondRetOK ;

         } /* fim ativa: Testar: CED &Iterador: obter referência para o espaço corrente */

      /* Testar: CED &Iterador: existe espaço corrente */

         else if ( strcmp( ComandoTeste , ExisteEspacoCorrenteCmd ) == 0 )
         {

            numLidos = LER_LerParametros( "i" ,
                               &valEsperado ) ;

            if ( numLidos != 1 )
            {
               return TST_CondRetParm ;
            } /* if */

            valObtido = CED_ExisteEspacoCorrente( ) ;

            return TST_CompararInt( valEsperado , valObtido ,
                   "Condição de existência de iterador errada." ) ; {

            } /* fim repete: Testar: CED &Iterador: existe espaço corrente */

         } /* fim ativa: Testar: CED &Iterador: existe espaço corrente */

      /* Testar: CED &Iterador: terminar iterador */

         else if ( strcmp( ComandoTeste , TerminarIteradorEspacoCmd ) == 0 )
         {

            CED_TerminarIteradorEspacos(  ) ;

            return TST_CondRetOK ;

         } /* fim ativa: Testar: CED &Iterador: terminar iterador */

      /* Testar: CED &Iterador: excluir espaço corrente */

         else if ( strcmp( ComandoTeste , ExcluirEspacoCorrenteCmd ) == 0 )
         {

            CED_ExcluirEspacoCorrente( ) ;

            return TST_CondRetOK ;

         } /* fim ativa: Testar: CED &Iterador: excluir espaço corrente */

      return TST_CondRetNaoConhec ;

   } /* Fim função: TCED &Efetuar comando de teste do controle de espaço dinâmico */