ListaCed

LIS_tpCondRet LIS_VerificarLista( void * pListaParm )
   {

      LIS_tpLista * pLista = NULL ;

      if ( LIS_VerificarCabeca( pListaParm ) != LIS_CondRetOK )
      {
         return LIS_CondRetErroEstrutura ;
      } /* if */

      CED_MarcarEspacoAtivo( pListaParm ) ;

      pLista = ( LIS_tpLista * ) ( pListaParm ) ;

      return VerificarNo( pLista->pOrigemLista ) ;

   } /* Fim função: LIS  &Verificar uma lista */

#endif

#ifdef _DEBUG

/***************************************************************************
*
*  Função: LIS  &Verificar um nó cabeça
*  ****/

   LIS_tpCondRet LIS_VerificarCabeca( void * pCabecaParm )
   {

      LIS_tpLista * pLista = NULL ;

      /* Verifica o tipo do espaço */

         if ( pCabecaParm == NULL )
         {
            TST_NotificarFalha( "Tentou verificar cabeça inexistente." ) ;
            return LIS_CondRetErroEstrutura ;
         } /* if */

         if ( ! CED_VerificarEspaco( pCabecaParm , NULL ))
         {
            TST_NotificarFalha( "Controle do espaço acusou erro." ) ;
            return LIS_CondRetErroEstrutura ;
         } /* if */

         if ( TST_CompararInt( LIS_TipoEspacoCabeca ,
              CED_ObterTipoEspaco( pCabecaParm ) ,
              "Tipo do espaço de dados não é cabeça de lista." ) != TST_CondRetOK )
         {
            return LIS_CondRetErroEstrutura ;
         } /* if */

         pLista = ( LIS_tpLista * )( pCabecaParm ) ;

      /* Verifica origem da lista */

         if ( pLista->pOrigemLista != NULL )
         {
            if ( TST_CompararPonteiro( pCabecaParm , pLista->pOrigemLista->pCabeca ,
                 "Nó raiz não aponta para cabeça." ) != TST_CondRetOK )
            {
               return LIS_CondRetErroEstrutura ;
            } /* if */
         } else {
            if ( TST_CompararPonteiro( NULL , pLista->pElemCorr ,
                 "Lista vazia tem nó corrente não NULL." ) != TST_CondRetOK )
            {
               return LIS_CondRetErroEstrutura ;
            } /* if */
         } /* if */

      /* Verifica corrente */

         if ( pLista->pElemCorr != NULL )
         {
            if ( TST_CompararPonteiro( pCabecaParm , pLista->pElemCorr->pCabeca ,
                 "Nó corrente não aponta para cabeça." ) != TST_CondRetOK )
            {
               return LIS_CondRetErroEstrutura ;
            } /* if */
         } else {
            if ( TST_CompararPonteiro( NULL , pLista->pOrigemLista ,
                 "Lista não vazia tem nó corrente NULL." ) != TST_CondRetOK )
            {
               return LIS_CondRetErroEstrutura ;
            } /* if */
         } /* if */

      return LIS_CondRetOK ;

   } /* Fim função: LIS  &Verificar um nó cabeça */

#endif

#ifdef _DEBUG

/***************************************************************************
*
*  Função: LIS  &Verificar um nó de estrutura
*  ****/

   LIS_tpCondRet LIS_VerificarNo( void * pNoParm )
   {

      tpElemLista * pNo     = NULL ;
      LIS_tpLista   * pLista = NULL ;

      /* Verificar se é nó estrutural */

         if ( pNoParm == NULL )
         {
            TST_NotificarFalha( "Tentou verificar nó inexistente." ) ;
            return LIS_CondRetErroEstrutura ;

         } /* if */

         if ( ! CED_VerificarEspaco( pNoParm , NULL ))
         {
            TST_NotificarFalha( "Controle do espaço acusou erro." ) ;
            return LIS_CondRetErroEstrutura ;
         } /* if */

         if ( TST_CompararInt( LIS_TipoEspacoNo ,
              CED_ObterTipoEspaco( pNoParm ) ,
              "Tipo do espaço de dados não é nó de lista." ) != TST_CondRetOK )
         {
            return LIS_CondRetErroEstrutura ;
         } /* if */

         pNo     = ( tpElemLista * )( pNoParm ) ;
         pLista = pNo->pCabeca ;

      /* Verificar cabeça */

         if ( pLista->pOrigemLista != NULL  )
         {
            if ( TST_CompararPonteiro( pLista , pLista->pOrigemLista->pCabeca ,
                 "Nó não pertence à lista." ) != TST_CondRetOK )
            {
               return LIS_CondRetErroEstrutura ;
            } /* if */
         } else
         {
            return TST_NotificarFalha( "Nó pertence a lista vazia." ) ;
         } /* if */

      /* Verificar antecessor */

         if ( pNo->pAnt != NULL )
         {
            if (pNo->pAnt->pProx != pNo )
            {
               return LIS_CondRetErroEstrutura ;
            } /* if */
         } else
         {
            if ( TST_CompararPonteiro( pNo , pLista->pOrigemLista ,
                 "Primeiro nó da lista não é apontado por pOrigemLista." ) != TST_CondRetOK )
            {
               return LIS_CondRetErroEstrutura ;
            } /* if */
         } /* if */

      /* Verificar sucessor */

         if ( pNo->pProx != NULL )
         {
            if ( pNo->pProx->pAnt != pNo )
            {
               return LIS_CondRetErroEstrutura ;
            } /* if */
         } else
         {
            if ( TST_CompararPonteiro( pNo , pLista->pFimLista ,
                 "Último nó da lista não é apontado por pFimLista." ) != TST_CondRetOK )
            {
               return LIS_CondRetErroEstrutura ;
            } /* if */
         } /* if */

      return LIS_CondRetOK ;

   } /* Fim função: LIS  &Verificar um nó de estrutura */

#endif

#ifdef _DEBUG

/***************************************************************************
*
*  Função: LIS  &Deturpar lista
*  ****/

   void LIS_Deturpar( void * pListaParm ,
                      LIS_tpModosDeturpacao ModoDeturpar )
   {

      LIS_tpLista * pLista = NULL ;

      if ( pListaParm == NULL )
      {
         return ;
      } /* if */

      pLista = ( LIS_tpLista * )( pListaParm ) ;

      switch ( ModoDeturpar ) {

      /* Modifica o tipo da cabeça */

         case DeturpaTipoCabeca :
         {

            CED_DefinirTipoEspaco( pLista , CED_ID_TIPO_VALOR_NULO ) ;

            break ;

         } /* fim ativa: Modifica o tipo da cabeça */

      /* Deturpa nó */

         default :

         if ( pLista->pElemCorr != NULL )
         {

            switch ( ModoDeturpar ) {

            /* Modifica tipo nó corrente */

            /* Anula ponteiro do elemento anterior */

               case DeturpaPtAntNulo :
               {

                  pLista->pElemCorr->pAnt = NULL ;

                  break ;

               } /* fim ativa: Anula ponteiro do elemento anterior */

            /* Anula ponteiro do elemento posterior  */

               case DeturpaPtProxNulo :
               {

                  pLista->pElemCorr->pProx = NULL ;

                  break ;

               } /* fim ativa: Anula ponteiro do elemento posterior */

            } /* fim seleciona: Deturpa nó */

            break ;

         } /* fim ativa: Deturpa nó */

      } /* fim seleciona: Raiz de LIS  &Deturpar lista */

   } /* Fim função: LIS  &Deturpar lista */

#endif


/*=======
*  $FC Função: LIS  -Explorar verificando os nós de uma lista
*
*  $ED Descrição da função
*     Percorre recursivamente a lista verificando os nós à medida que forem
*     visitados. Caso seja encontrado alguma falha, a verificação será
*     suspensa. Portanto, no caso de falha, é possível que nem todos
*     os nós da lista sejam visitados.
*
***********************************************************************/

   LIS_tpCondRet VerificarNo( tpElemLista * pNo )
   {

      LIS_tpCondRet CondErro = LIS_CondRetOK ;

      if ( pNo == NULL )
      {
         return LIS_CondRetOK ;
      } /* if */

      CED_MarcarEspacoAtivo( pNo ) ;

      CondErro = LIS_VerificarNo( pNo ) ;

      if ( CondErro == LIS_CondRetOK )
      {
         CondErro = VerificarNo( pNo->pProx ) ;
      } /* if */

      return CondErro ;

   } /* Fim função: LIS  -Explorar verificando os nós de uma lista */

#endif