Module for making a doubly linked list

Question

This module makes a doubly linked list and initializes each member. I couldn't do it with a loop, so I gave up and made each node individually.

How can I improve it? Can somebody help me make a loop to chain all these lists together? This is from a Checkers game I'm making.

#include   <stdio.h>
#include   <string.h>
#include   <memory.h>
#include   <malloc.h>
#include   <assert.h>
#include    "LISTA.h"
#include    "PEC.h"

#define TABULEIRO_OWN
#include "TABULEIRO.h"
#undef TABULEIRO_OWN

typedef struct TAB_tagInfoCasa
{
    void * pValor1;
    void * pValor2;
}TAB_tpInfoCasa ;

typedef struct  TAB_tagTabuleiro
{
    LIS_tppLista pElem ;
            /* elemento de uma lista de listas, ou seja, uma lista */

    struct TAB_tagTabuleiro *pProx ;
            /* Ponteiro para o elemento sucessor */

    struct TAB_tagTabuleiro * pAnt ;
            /* Ponteiro para o elemento predecessor */

}TAB_tpTabuleiro ;

/*****  Dados encapsulados no módulo  *****/

    static TAB_tpTabuleiro * pTabuleiro = NULL ;
            /* Ponteiro para a cabeça do tabuleiro */

/***** Protótipos das funções encapsuladas no módulo *****/

   static void EsvaziarTabuleiro( ) ;

   static LIS_tpCondRet InserirInfoCasa( LIS_tppLista pLista, PEC_tpPEC pPEC, int PosCasa ) ;

   /*****  Código das funções exportadas pelo módulo  *****/

/***************************************************************************
*  Função TAB Criar tabuleiro
***************************************************************************/

    TAB_tpCondRet TAB_CriarTabuleiro( )
    {

        LIS_tpCondRet CondRet ;
        int PosCasa ;
        int CasaBranca = -1 ;

        /************************** Declarações dos nós do tabuleiro ***************/
        TAB_tpTabuleiro * pTab ;
        TAB_tpTabuleiro * pTab2 ;
        TAB_tpTabuleiro * pTab3 ;
        TAB_tpTabuleiro * pTab4 ;
        TAB_tpTabuleiro * pTab5 ;
        TAB_tpTabuleiro * pTab6 ;
        TAB_tpTabuleiro * pTab7 ;
        TAB_tpTabuleiro * pTab8 ;

        /************************** Declaração das listas **************************/
        LIS_tppLista pListaA ;
        LIS_tppLista pListaB ;
        LIS_tppLista pListaC ;
        LIS_tppLista pListaD ;
        LIS_tppLista pListaE ;
        LIS_tppLista pListaF ;
        LIS_tppLista pListaG ;
        LIS_tppLista pListaH ;

        /************************** Declaração das peças **************************/
        PEC_tpPEC PECBranca ;
        PEC_tpPEC PECPreta ;

        /************************** Criação das peças **************************/
        PECBranca = PEC_CriarPEC( BRANCA, NORMAL );
        if ( PECBranca == NULL )
        {
            return TAB_CondRetFaltouMemoria ;
        } /* if */

        PECPreta = PEC_CriarPEC( PRETA, NORMAL );
        if ( PECPreta == NULL )
        {
            return TAB_CondRetFaltouMemoria ;
        } /* if */

        /************************** Criação das listas **************************/
        pListaA = LIS_CriarLista( PEC_DestruirPEC ) ;
        if ( pListaA == NULL )
        {
            return TAB_CondRetFaltouMemoria ;
        } /* if */

        pListaB = LIS_CriarLista( PEC_DestruirPEC ) ;
        if ( pListaB == NULL )
        {
            return TAB_CondRetFaltouMemoria ;
        } /* if */

        pListaC = LIS_CriarLista( PEC_DestruirPEC ) ;
        if ( pListaC == NULL )
        {
            return TAB_CondRetFaltouMemoria ;
        } /* if */

        pListaD = LIS_CriarLista( PEC_DestruirPEC ) ;
        if ( pListaD == NULL )
        {
            return TAB_CondRetFaltouMemoria ;
        } /* if */

        pListaE = LIS_CriarLista( PEC_DestruirPEC ) ;
        if ( pListaE == NULL )
        {
            return TAB_CondRetFaltouMemoria ;
        } /* if */

        pListaF = LIS_CriarLista( PEC_DestruirPEC ) ;
        if ( pListaF == NULL )
        {
            return TAB_CondRetFaltouMemoria ;
        } /* if */

        pListaG = LIS_CriarLista( PEC_DestruirPEC ) ;
        if ( pListaG == NULL )
        {
            return TAB_CondRetFaltouMemoria ;
        } /* if */

        pListaH = LIS_CriarLista( PEC_DestruirPEC ) ;
        if ( pListaH == NULL )
        {
            return TAB_CondRetFaltouMemoria ;
        } /* if */

                /* Inserção dos elementos da lista A */
        CondRet = InserirInfoCasa( pListaA, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 5 ;
        CondRet = InserirInfoCasa( pListaA, PECBranca, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaA, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 13 ;
        CondRet = InserirInfoCasa( pListaA, NULL, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaA, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 21 ;
        CondRet = InserirInfoCasa( pListaA, PECPreta, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaA, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 29 ;
        CondRet = InserirInfoCasa( pListaA, PECPreta, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */
        IrInicioLista( pListaA ) ;

                /* Inserção dos elementos da lista B */
        PosCasa = 1 ;
        CondRet = InserirInfoCasa( pListaB, PECBranca, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaB, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 9 ;
        CondRet = InserirInfoCasa( pListaB, PECBranca, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaB, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 17 ;
        CondRet = InserirInfoCasa( pListaB, NULL, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaB, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 25 ;
        CondRet = InserirInfoCasa( pListaB, PECPreta, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaB, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */
        IrInicioLista( pListaB ) ;

                    /* Inserção dos elementos da lista C */
        CondRet = InserirInfoCasa( pListaC, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 6 ;
        CondRet = InserirInfoCasa( pListaC, PECBranca, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaC, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 14 ;
        CondRet = InserirInfoCasa( pListaC, NULL, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaC, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 22 ;
        CondRet = InserirInfoCasa( pListaC, PECPreta, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaC, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 30 ;
        CondRet = InserirInfoCasa( pListaC, PECPreta, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */
        IrInicioLista( pListaC ) ;

                    /* Inserção dos elementos da lista D */
        PosCasa = 2 ;
        CondRet = InserirInfoCasa( pListaD, PECBranca, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaD, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 10 ;
        CondRet = InserirInfoCasa( pListaD, PECBranca, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaD, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 18 ;
        CondRet = InserirInfoCasa( pListaD, NULL, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaD, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 26 ;
        CondRet = InserirInfoCasa( pListaD, PECPreta, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaD, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */
        IrInicioLista( pListaD ) ;

                    /* Inserção dos elementos da lista E */
        CondRet = InserirInfoCasa( pListaE, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 7 ;
        CondRet = InserirInfoCasa( pListaE, PECBranca, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaE, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 15 ;
        CondRet = InserirInfoCasa( pListaE, NULL, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaE, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 23 ;
        CondRet = InserirInfoCasa( pListaE, PECPreta, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaE, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 31 ;
        CondRet = InserirInfoCasa( pListaE, PECPreta, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */
        IrInicioLista( pListaE ) ;

                    /* Inserção dos elementos da lista F */
        PosCasa = 3 ;
        CondRet = InserirInfoCasa( pListaF, PECBranca, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaF, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 11 ;
        CondRet = InserirInfoCasa( pListaF, PECBranca, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaF, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 19 ;
        CondRet = InserirInfoCasa( pListaF, NULL, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaF, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 27 ;
        CondRet = InserirInfoCasa( pListaF, PECPreta, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaF, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */
        IrInicioLista( pListaF ) ;

                    /* Inserção dos elementos da lista G */
        CondRet = InserirInfoCasa( pListaG, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 8 ;
        CondRet = InserirInfoCasa( pListaG, PECBranca, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaG, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 16 ;
        CondRet = InserirInfoCasa( pListaG, NULL, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaG, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 24 ;
        CondRet = InserirInfoCasa( pListaG, PECPreta, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaG, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 32 ;
        CondRet = InserirInfoCasa( pListaG, PECPreta, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */
        IrInicioLista( pListaG ) ;

                    /* Inserção dos elementos da lista H */
        PosCasa = 4 ;
        CondRet = InserirInfoCasa( pListaH, PECBranca, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaH, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 12 ;
        CondRet = InserirInfoCasa( pListaH, PECBranca, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaH, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 20 ;
        CondRet = InserirInfoCasa( pListaH, NULL, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaH, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        PosCasa = 28 ;
        CondRet = InserirInfoCasa( pListaH, PECPreta, PosCasa ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */

        CondRet = InserirInfoCasa( pListaH, NULL, CasaBranca ) ;
        if ( CondRet != LIS_CondRetOK )
        {
            return CondRet ;
        } /* if */
        IrInicioLista( pListaH ) ;


        /************************** Criação dos nós do tabuleiro **************************/

        pTab = ( TAB_tpTabuleiro * ) malloc( sizeof( TAB_tpTabuleiro ) ) ;
        if ( pTab == NULL )
        {
            return TAB_CondRetFaltouMemoria ;
        } /* if */

        pTab2 = ( TAB_tpTabuleiro * ) malloc( sizeof( TAB_tpTabuleiro ) ) ;
        if ( pTab2 == NULL )
        {
            return TAB_CondRetFaltouMemoria ;
        } /* if */

        pTab3 = ( TAB_tpTabuleiro * ) malloc( sizeof( TAB_tpTabuleiro ) ) ;
        if ( pTab3 == NULL )
        {
            return TAB_CondRetFaltouMemoria ;
        } /* if */

        pTab4 = ( TAB_tpTabuleiro * ) malloc( sizeof( TAB_tpTabuleiro ) ) ;
        if ( pTab4 == NULL )
        {
            return TAB_CondRetFaltouMemoria ;
        } /* if */

        pTab5 = ( TAB_tpTabuleiro * ) malloc( sizeof( TAB_tpTabuleiro ) ) ;
        if ( pTab5 == NULL )
        {
            return TAB_CondRetFaltouMemoria ;
        } /* if */

        pTab6 = ( TAB_tpTabuleiro * ) malloc( sizeof( TAB_tpTabuleiro ) ) ;
        if ( pTab6 == NULL )
        {
            return TAB_CondRetFaltouMemoria ;
        } /* if */

        pTab7 = ( TAB_tpTabuleiro * ) malloc( sizeof( TAB_tpTabuleiro ) ) ;
        if ( pTab7 == NULL )
        {
            return TAB_CondRetFaltouMemoria ;
        } /* if */

        pTab8 = ( TAB_tpTabuleiro * ) malloc( sizeof( TAB_tpTabuleiro ) ) ;
        if ( pTab8 == NULL )
        {
            return TAB_CondRetFaltouMemoria ;
        } /* if */

        /******************** Setando os elementos do tabuleiro e fazendo as ligações entre os nós ***********/

        pTabuleiro = pTab ; /* pTab é a origem do tabuleiro */
        pTab->pAnt = NULL ;
        pTab->pProx = pTab2 ;
        pTab->pElem = pListaA ;

        pTab2->pAnt = pTab ;
        pTab2->pProx = pTab3 ;
        pTab2->pElem = pListaB ;

        pTab3->pAnt = pTab2 ;
        pTab3->pProx = pTab4 ;
        pTab3->pElem = pListaC ;

        pTab4->pAnt = pTab3 ;
        pTab4->pProx = pTab5 ;
        pTab4->pElem = pListaD ;

        pTab5->pAnt = pTab4 ;
        pTab5->pProx = pTab6 ;
        pTab5->pElem = pListaE ;

        pTab6->pAnt = pTab5 ;
        pTab6->pProx = pTab7 ;
        pTab6->pElem = pListaF ;

        pTab7->pAnt = pTab6 ;
        pTab7->pProx = pTab8 ;
        pTab7->pElem = pListaG ;

        pTab8->pAnt = pTab7 ;
        pTab8->pProx = NULL ;
        pTab8->pElem = pListaH;     

        return TAB_CondRetOK ;
    } /* Fim função: TAB  &Criar tabuleiro */

/***************************************************************************
*
*  Função: TAB  &Destruir tabuleiro
*  ****/

   TAB_tpCondRet TAB_DestruirTabuleiro( )
   {

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

      EsvaziarTabuleiro( ) ;

      free( pTabuleiro ) ;

      pTabuleiro = NULL ;

      return TAB_CondRetOK ;

   } /* Fim função: TAB  &Destruir tabuleiro */

/***************************************************************************
*
*  Função: TAB  &Avancar Elemento Corrente
*  ****/

   TAB_tppTabuleiro TAB_AvancarElemento( int numElem )
   {

      int i ;

      TAB_tppTabuleiro pTab = pTabuleiro ;

      if ( pTabuleiro == NULL )
          return NULL;

      //#ifdef _DEBUG
      //   assert( pTab != NULL ) ;
      //#endif

      #ifdef _DEBUG
         assert( numElem <= 7 ) ;
      #endif

      /* Tratar lista vazia */

         if ( pTab->pElem == NULL )
         {
             return NULL ;
         } /* fim ativa: Tratar lista vazia */

      /* Tratar avançar para frente */

         if ( numElem > 0 )
         {

            for( i = numElem ; i > 0 ; i-- )
            {
                if ( pTab == NULL )
               {
                  break ;
               } /* if */
                pTab = pTab->pProx ;
            } /* for */

            if ( pTab->pElem != NULL )
            {
               return pTab ;
            } /* if */

         } /* fim ativa: Tratar avançar para frente */

            /* Retorno caso numElem seja igual a 0 ou outro número inválido */
         return pTab ;


   } /* Fim função: TAB  &Avançar elemento */


/***************************************************************************
*
*  Função: TAB  &Obter Valor de uma lista de listas
*  ****/

   void * TAB_ObterValorTab( TAB_tppTabuleiro pTab )
   {

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

      if ( pTab->pElem == NULL )
      {
        return NULL ;
      } /* if */

      return pTab->pElem ;

   } /* Fim função: TAB  &Obter referência para o valor contido no elemento */

/***************************************************************************
*
*  Função: TAB  &Obter Valor 1 da estrutura TAB_tagInfoCasa
*  ****/

   void * TAB_ObterValor1Casa( TAB_tppInfoCasa pInfo )
   {

      if ( pInfo == NULL )
      {
        return ( void * ) -1 ;
      } /* if */

      return pInfo->pValor1 ;

   } /* Fim função: TAB  &Obter referência para o valor 1 contido no elemento */

/***************************************************************************
*
*  Função: TAB  &Obter Valor 2 da estrutura TAB_tagInfoCasa
*  ****/

   void * TAB_ObterValor2Casa( TAB_tppInfoCasa pInfo )
   {

      if ( pInfo == NULL )
      {
        return ( void * ) -1 ;
      } /* if */

      return pInfo->pValor2 ;

   } /* Fim função: TAB  &Obter referência para o valor 2 contido no elemento */

/*****  Código das funções encapsuladas no módulo  *****/

/***********************************************************************
*
*  $FC Função: TAB  &Esvaziar tabuleiro
*
*  $ED Descrição da função
*     Elimina todos os elementos, sem contudo eliminar o tabuleiro
*
*  $EP Parâmetros
*     pTabuleiro - ponteiro para o tabuleiro a ser esvaziado
*
***********************************************************************/

   static void EsvaziarTabuleiro( )
   {

       TAB_tpTabuleiro * pNext ;
       TAB_tpTabuleiro * pCurr = pTabuleiro ;
        #ifdef _DEBUG
         assert( pTabuleiro != NULL ) ;
        #endif

        /* IrInicioLista( pTabuleiro ) ;*/
        while ( pCurr != NULL )
        {
            pNext = pCurr->pProx ;
            LIS_DestruirLista( pCurr->pElem ) ;
            pCurr = pNext ;
        } /* while */

    } /* Fim função: TAB  &Esvaziar tabuleiro */

/***********************************************************************
*
*  $FC Função: TAB  &Inserir elemento numa casa do tabuleiro
*
*  $ED Descrição da função
*     Preenche uma variável do tipo TAB_tagInfoCasa com os parâmetros
*     recebidos e chama a função de inserir do módulo lista, preenchendo
*     a informação necessária de uma casa do tabuleiro.
*
*  $EP Parâmetros
*     pLista  - ponteiro para a lista em que será inserida a informação
*     pPEC   - ponteiro para a peça que será inserida.
*     Poscasa - valor da numeração da casa que será inserida.
*
*  $FV Valor retornado
*     Valor retornado
*        LIS_CondRetOK
*        LIS_CondRetFaltouMemoria
*
***********************************************************************/

   static LIS_tpCondRet InserirInfoCasa( LIS_tppLista pLista, PEC_tpPEC pPEC, int PosCasa ) 
   {

            /***** Declaração do tipo que será inserido numa casa do tabuleiro *****/
        TAB_tppInfoCasa pInfo ;

        /***** Alocação do tipo que será inserido numa casa do tabuleiro *****/
        pInfo = ( TAB_tpInfoCasa * ) malloc ( sizeof ( TAB_tpInfoCasa ) ) ;
        if ( pInfo == NULL )
        {
            return LIS_CondRetFaltouMemoria ;
        } /* if */

        pInfo->pValor1 = ( void * ) pPEC   ;
        pInfo->pValor2 = ( void * ) PosCasa ;

        return LIS_InserirElementoApos( pLista, pInfo ) ;
   } /* Fim função: TAB  &Inserir elemento numa casa */

/********** Fim do módulo de implementação: TAB  Tabuleiro **********/

Answer 1

Well, some parts can be converted to loops pretty easily. Just for the most obvious example, your series of code like:

    pListaA = LIS_CriarLista( PEC_DestruirPEC ) ;
    if ( pListaA == NULL )
    {
        return TAB_CondRetFaltouMemoria ;
    } /* if */

(repeated for pListaB...pListaH), can be converted to a loop quite easily:

#define num_tabs 8

TAB_tpTabuleiro *Tabs[num_tabs];

for (i=0; i<num_tabs; i++) {
    Tabs[i] = LIS_CriarLista( PEC_DestruirPEC ) ;
    if (Tabs[i] == NULL)
        return TAB_CondRetFaltouMemoria ;
} 

Some of the other parts look just irregular enough that the conversion is likely to be a bit more complex. While I could certainly write some code that would produce the same result, I'm pretty sure I'm not following enough of what all this is really supposed to accomplish. I can puzzle out just enough of the meaning of some of the names to convince me that I really don't understand the code as well as I should to produce something that's as clean as possible. I could undoubtedly figure out what it means even without names that are meaningful to me, but having done that many times before, I'm pretty sure it would take more time than I'm willing to spend on it at the moment.