/* 
+----------------------------------------------------------------------------- 
|  Project :  
|  Modul   : cdc_std.c
+----------------------------------------------------------------------------- 
|  Copyright 2002 Texas Instruments Berlin, AG 
|                 All rights reserved. 
| 
|                 This file is confidential and a trade secret of Texas 
|                 Instruments Berlin, AG 
|                 The receipt of or possession of this file does not convey 
|                 any rights to reproduce or disclose its contents or to 
|                 manufacture, use, or sell anything it may describe, in 
|                 whole, or in part, without the specific written consent of 
|                 Texas Instruments Berlin, AG. 
+----------------------------------------------------------------------------- 
|  Purpose :  Condat Conder Decoder 
|             Definitions of non protocol specific encoding and decoding 
|             functions
+----------------------------------------------------------------------------- 
*/ 

#define CCD_STD_C

#ifdef _MSDOS
#include <dos.h>
#include <conio.h>
#endif

/*
 * standard definitions like UCHAR, ERROR etc.
 */
#include "typedefs.h"
#include "header.h"
#include <string.h>

/*
 * Prototypes of ccd (USE_DRIVER EQ undef) for prototypes only
 * look at ccdapi.h.
 */
#undef USE_DRIVER
#include "ccdapi.h"

/*
 * Types and functions for bit access and manipulation
 */
#include "ccd_globs.h"
#include "bitfun.h"

/*
 * Declaration of coder/decoder tables and/or functions to access them
 */
#include "ccdtable.h"
#include "ccddata.h"

/*
 * Prototypes of ccd internal functions
 */
#include "ccd.h"

/*
 * Need memory allocation functions for dynamic arrays (pointers)
 */
#ifdef DYNAMIC_ARRAYS
#include "vsi.h"
#endif

#ifndef RUN_FLASH
/*
+--------------------------------------------------------------------+
| PROJECT : CCD (6144)               MODULE  : CCD                   |
| STATE   : code                     ROUTINE : cdc_decodeElemvalue   |
+--------------------------------------------------------------------+

  PURPOSE : Performs a standard decoding for a given elem table entry.
            This means for non structured elements that 1-n bits are
            read from the bitstream and write to a C-Variable
            in a machine dependent format. For structured elements
            an (indirect) recursive call to cc_decodeComposition()
            is performed. If the element is a bitbuffer with variable
            size, the repeat value gives the number of bits to read
            from the bitstream into the buffer. The maxBitpos
            indicates the maximum valid position for the
            readpointer of the bitstream while decoding this element.
            If the readpointer break this boundary, this element will
            not be decoded.
*/

void cdc_decodeElemvalue (ULONG e_ref, ULONG *repeat, T_CCD_Globs *globs)
{
  UBYTE     *ActStructpos;
  ULONG      i;
  UBYTE      spareLen;

  /*
   * element is a bit field of variable length
   */
  if ((melem[e_ref].repType == 'b') || (melem[e_ref].repType == 's'))
  {
    if (*repeat > (ULONG) (globs->maxBitpos-globs->bitpos))
    {
      ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE, 
                       (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
      *repeat = MINIMUM (*repeat, (ULONG) (globs->maxBitpos-globs->bitpos));
    }
    if (melem[e_ref].repType == 'b')
    {
      if (mvar[melem[e_ref].elemRef].cType EQ 'X')
        bf_readBitChunk (*repeat, globs);
      else
        bf_readBits (*repeat, globs); 
    }
    else 
    {
      U16 finalBP = globs->bitpos + (USHORT) *repeat;
      /* Store the limit. This comp may contain other comps as bitstring. */
      globs->maxBitpos = finalBP;
      ActStructpos = globs->pstruct;
      globs->pstruct += globs->pstructOffs;
#ifdef DEBUG_CCD
#ifdef CCD_SYMBOLS
      TRACE_CCD (globs, "decoding composition %s as a bit array",
                       mcomp[melem[e_ref].elemRef].name);
#else
      TRACE_CCD (globs, "decoding composition %d", melem[e_ref].elemRef);
#endif
#endif

      ccd_decodeComposition ((ULONG) (melem[e_ref].elemRef), globs);
      if (finalBP < globs->bitpos)
      {
        ccd_recordFault (globs, ERR_BITSTR_COMP, CONTINUE, (USHORT) e_ref,
                         globs->pstruct + globs->pstructOffs);
      }
      bf_setBitpos (finalBP, globs);
      /* Update maxBitpos to avoid an early end of decoding. */
      globs->maxBitpos = globs->buflen;
      globs->pstruct = ActStructpos;
    }
  }
  else
  {
    /*
     * For pointer types, globs->pstruct is already set to point to
     * the new memory area, and these types are not treated differently
     * from non-pointer types.
     */
    i=0;
    switch (melem[e_ref].elemType)
    {
      case 'R': /* Pointer to (possible array of) basetype */
      case 'F': /* Code-transparent pointer to (possible array of) basetype */
      case 'V':
        while (i < *repeat)
        {
          if (globs->bitpos < globs->maxBitpos)
          {
#ifdef DEBUG_CCD
#ifdef CCD_SYMBOLS
            TRACE_CCD (globs, "decoding var %s",
                       ccddata_get_alias((USHORT) e_ref, 1));
#else
            TRACE_CCD (globs, "decoding var %d", melem[e_ref].elemRef);
#endif
#endif
            if (mvar[melem[e_ref].elemRef].cType EQ 'X')
              bf_readBitChunk (mvar[melem[e_ref].elemRef].bSize, globs);
            else
              bf_readBits (mvar[melem[e_ref].elemRef].bSize, globs);

            globs->pstructOffs += mvar[melem[e_ref].elemRef].cSize;

            i++;
          }
          else
          {
            if (melem[e_ref].repType != 'i')
            {
              ccd_recordFault (globs, ERR_ELEM_LEN, CONTINUE, (USHORT) e_ref,
                               globs->pstruct + globs->pstructOffs);
            }
            break;
          }
        }
        break;

      case 'D': /* Pointer to a composition */
      case 'P': /* Code transparent pointer to a comp */
      case 'C': /* Element is a composition. */
      case 'U': /* Element is a union. */
        /*
         * Store the actual structure position.
         */
        ActStructpos = globs->pstruct;

        globs->pstruct += globs->pstructOffs;

        while (i < *repeat)
        {
          if (globs->bitpos < globs->maxBitpos)
          {
#ifdef DEBUG_CCD
#ifdef CCD_SYMBOLS
            TRACE_CCD (globs, "decoding composition %s",
                       mcomp[melem[e_ref].elemRef].name);
#else
            TRACE_CCD (globs, "decoding composition %d", melem[e_ref].elemRef);
#endif
#endif
		        /*
		         * recursiv call
		         */
            ccd_decodeComposition ((ULONG) (melem[e_ref].elemRef), globs);
            globs->pstruct += mcomp[melem[e_ref].elemRef].cSize;

            i++;
          }
          else
          {
            if (melem[e_ref].repType != 'i')
            {
              ccd_recordFault (globs, ERR_ELEM_LEN, CONTINUE, (USHORT) e_ref,
                               globs->pstruct + globs->pstructOffs);
            }
            break;
          }
        }
        /*
         * restore the write pointer
         */
        globs->pstruct = ActStructpos;
        break;

      case 'S': /* Element is a spare. */
      {
        spareLen = spare[melem[e_ref].elemRef].bSize;
        /*
         * Do not decode padding bits. They are not relevant.
         * Just adjust the position pointer in the bit stream buffer.
         */
        while (i < *repeat)
        {
          if (globs->bitpos < globs->maxBitpos)
          {
#ifdef DEBUG_CCD
            TRACE_CCD (globs, "decoding spare");
#endif
            bf_incBitpos (spareLen, globs);
            i++;
          }
          else
            break;
        }
        break;
      }
    }
    *repeat = i;
  }
}
#endif /* !RUN_FLASH */

#ifndef RUN_FLASH
/*
+--------------------------------------------------------------------+
| PROJECT : CCD (6144)               MODULE  : CCD                   |
| STATE   : code                     ROUTINE : cdc_encodeElemvalue   |
+--------------------------------------------------------------------+

  PURPOSE : Performs a standard encoding for a given elem table entry.
            This means for non structured elements that 1-n bits are
            read from the bitstream and write to a C-Variable
            in a machine dependent format. For structured elements
            an (indirect) recursive call to cc_decodeComposition()
            is performed. If the element is a bitbuffer with variable
            size, the repeat value gives the number of bits to write
            from the buffer into the bitstream.
*/

void cdc_encodeElemvalue (ULONG e_ref, ULONG repeat, T_CCD_Globs *globs)
{
  UBYTE     *ActStructpos = NULL;
  ULONG      i;
  UBYTE      spareLen;

  /*
   * Element is a bit field of variable length.
   */
  if (melem[e_ref].repType == 'b')
  {
    if (mvar[melem[e_ref].elemRef].cType EQ 'X')
      bf_writeBitChunk (repeat, globs);
    else
      bf_writeBits (repeat, globs);
  }
  /*
   * Element is a structured IE defined as bit string.
   */
  else if (melem[e_ref].repType == 's')
  {
    U16 finalBP = (USHORT) (globs->bitpos + repeat);
    ActStructpos = globs->pstruct;
    globs->pstruct += globs->pstructOffs;
#ifdef DEBUG_CCD
#ifdef CCD_SYMBOLS
    TRACE_CCD (globs, "encoding composition %s as a bit array",
                       mcomp[melem[e_ref].elemRef].name);
#else
    TRACE_CCD (globs, "encoding composition %d", melem[e_ref].elemRef);
#endif
#endif

    ccd_encodeComposition ((ULONG) melem[e_ref].elemRef, globs);
    if (finalBP < globs->bitpos)
    {
      ccd_recordFault (globs, ERR_BITSTR_COMP, CONTINUE, (USHORT) e_ref, 
                       globs->pstruct + globs->pstructOffs);
    }
    bf_setBitpos (finalBP, globs);
    globs->pstruct = ActStructpos;
  }
  else
  {
    /*
     * For pointer types, globs->pstruct is already set to point to
     * the new memory area, and these types are not treated differently
     * from non-pointer types.
     */
    switch(melem[e_ref].elemType)
    {
      case 'R': /* Pointer to (possible array of) basetype */
      case 'F': /* Code-transparent pointer to (possible array of) basetype */
      case 'V':
        for (i=0; i<repeat; i++)
        {
  #ifdef DEBUG_CCD
  #ifdef CCD_SYMBOLS
          TRACE_CCD (globs, "encoding var %s",
                     ccddata_get_alias((USHORT) e_ref, 1));
  #else
          TRACE_CCD (globs, "encoding var %s", melem[e_ref].elemRef);
  #endif
  #endif
          if (mvar[melem[e_ref].elemRef].cType EQ 'X')
            bf_writeBitChunk (mvar[melem[e_ref].elemRef].bSize, globs);
          else
            bf_writeBits (mvar[melem[e_ref].elemRef].bSize, globs);

          globs->pstructOffs += mvar[melem[e_ref].elemRef].cSize;
        }
        break;

      case 'D': /* Pointer to a composition (already dereferenced) */
      case 'P': /* Code transparent pointer to a comp (already dereferenced) */
      case 'C': /* Element is a composition. */
      case 'U': /* Element is a union. */
        /*
         * store the actual structure position
         */
        ActStructpos = globs->pstruct;

        globs->pstruct += globs->pstructOffs;

        for (i=0; i<repeat; i++)
        {
  #ifdef DEBUG_CCD
  #ifdef CCD_SYMBOLS
          TRACE_CCD (globs, "encoding composition %s",
                     mcomp[melem[e_ref].elemRef].name);
  #else
          TRACE_CCD (globs, "encoding composition %d", melem[e_ref].elemRef);
  #endif
  #endif
          ccd_encodeComposition ((ULONG) melem[e_ref].elemRef, globs);	/* recursiv call */
          globs->pstruct += mcomp[melem[e_ref].elemRef].cSize;
        }
        /*
         * restore the write pointer
         */
        globs->pstruct = ActStructpos;
        break;

      case 'S': /* element is a spare          */
      {
        spareLen = spare[melem[e_ref].elemRef].bSize;

        /*
         * encode the spare
         */
        for (i=0; i < repeat; i++)
        {
  #ifdef DEBUG_CCD
          TRACE_CCD (globs, "encoding spare");
  #endif
          bf_codeLongNumber (spareLen, spare[melem[e_ref].elemRef].value, globs);
        }
        break;
      }
    }
  }
}
#endif /* !RUN_FLASH */

#ifndef RUN_FLASH
/*
+--------------------------------------------------------------------+
| PROJECT : CCD (6144)               MODULE  : CCD                   |
| STATE   : code                     ROUTINE : cdc_STD_decode        |
+--------------------------------------------------------------------+

  PURPOSE : Performs a standard decoding for a given elem table entry.
            This means for non structured elements that 1-n bits are
            read from the bitstream and write to a C-Variable
            in a machine dependent format. For structured elements
            an (indirect) recursive call to cc_decodeComposition()
            is performed.
            The element may be conditional and/or repeatable.
*/

SHORT cdc_std_decode (const ULONG c_ref, const ULONG e_ref, T_CCD_Globs *globs)
{
  ULONG               repeat, amount, act_offset;
  BOOL                is_variable;
  U8                 *old_pstruct = NULL;
  ULONG               cix_ref, num_prolog_steps, prolog_step_ref;

#ifdef DEBUG_CCD
  #ifndef CCD_SYMBOLS
  TRACE_CCD (globs, "cdc_std_decode()");
	#else
	TRACE_CCD (globs, "cdc_std_decode() %s", ccddata_get_alias((USHORT) e_ref, 1));
	#endif
#endif

  cix_ref = melem[e_ref].calcIdxRef;
  num_prolog_steps = calcidx[cix_ref].numPrologSteps;
  prolog_step_ref  = calcidx[cix_ref].prologStepRef;

  /*
   * if this element is conditional, check the condition
   */
  if (calcidx[cix_ref].numCondCalcs NEQ 0
  AND ! ccd_conditionOK (e_ref, globs))
    return 1;

  /*
   * if this element has a defined prologue
   * we have to process it before decoding the bitstream
   * If there are some epilogue expressions to be processed for this element
   * (rare cases) the result here will be a reading of 0 to an internal
   * register. The valid processing of expression takes place after the 
   * decoding of the element. 
   */
  if (num_prolog_steps)
  {
    ccd_performOperations (num_prolog_steps, prolog_step_ref, globs);
  }
  
  /*
   * if this element is repeatable, and the number of
   * repeats depends on another element, calculate the repeater
   */
  if (melem[e_ref].repType NEQ ' ')
  {
    is_variable = ccd_calculateRep (e_ref, &repeat, &act_offset, globs);
  }
  else
  {
    repeat = 1;
    is_variable = FALSE;
  }

  if (melem[e_ref].elemType NEQ 'S')
  {
    /*
     * Element is not a SPARE.
     * Setup the offset into the C-structure for this element
     */
    globs->pstructOffs = melem[e_ref].structOffs;

    if (melem[e_ref].optional)
    {
      /* 20010621 MVJ: Dynamic array addition.
       * Postpone optional flag setting for non-code transparent
       * pointer types ('P', 'Q', 'R').
       * For these types, the optional flag is the pointer itself.
       * These types cannot be set yet, as the pointer may be
       * preceeded by a counter octet, a union tag id octet etc.
       */
      if (melem[e_ref].elemType < 'P' OR melem[e_ref].elemType > 'R')
	      globs->pstruct[globs->pstructOffs++] = (UBYTE) TRUE;
    }

    if (is_variable)
    {
      /*
       * for variable sized elements store the min-value
       * as counter into the C-Structure (c_xxx).
       */
      if (act_offset > 65535)
        *(ULONG *) (globs->pstruct + globs->pstructOffs++) = repeat;
      else if (act_offset > 255)
        *(USHORT *) (globs->pstruct + globs->pstructOffs++) = (USHORT) repeat;
      else
        globs->pstruct[globs->pstructOffs] = (UBYTE) repeat;

      globs->pstructOffs++;
    }
  }
  #ifdef DYNAMIC_ARRAYS
  /*
   * MVJ: Dynamic array addition.
   * Check for pointer types; allocate memory if necessary.
   */
  if ( is_pointer_type(e_ref) ) {
    U32     cSize;
    U8      *addr;

    /*
     * Find size to allocate;
     * - Read from mcomp or mvar according to type
     */
    cSize = (ULONG)((melem[e_ref].elemType EQ 'V' OR
		      melem[e_ref].elemType EQ 'R')
                     ? mvar[melem[e_ref].elemRef].cSize
                     : mcomp[melem[e_ref].elemRef].cSize
		     ) * repeat;

    /*
     * Allocate additional memory
     */
    addr = (U8 *)DP_ALLOC( cSize, globs->alloc_head, DP_NO_FRAME_GUESS);

    /* If no memory, log error and return immediately */
    if (addr EQ NULL) {
      ccd_setError (globs, ERR_NO_MEM,
                    BREAK,
                    (USHORT) -1);
      return 1;
    }
    else
      memset (addr, 0, (size_t)cSize);

    /*
     * Memory allocated;
     * 1. Save old "globs->pstruct" variables
     * 2. Store pointer to freshly allocated memory area in structure
     * 3. Initialize pstruct to point to the freshly allocated memory area.
     * 4. Initialize pstructOffs to 0 to start decoding at offset 0
     *    in the new memory area.
     */
    old_pstruct        = globs->pstruct;
    *(U8 **)(globs->pstruct + globs->pstructOffs) = addr;
    globs->pstruct     = addr;
    globs->pstructOffs = 0;
  }
#endif

  amount = repeat;

  cdc_decodeElemvalue (e_ref, &amount, globs);

  /*
   * process the epilogue expression for this element if there is any 
   */
  if (num_prolog_steps)
  {
    if (  (calc[prolog_step_ref+1].operation EQ 'K')
       || (calc[prolog_step_ref+1].operation EQ 'C')
       || (calc[prolog_step_ref+1].operation EQ 's'))
    {
      ccd_performOperations (num_prolog_steps, prolog_step_ref, globs);
    }
  }

#ifdef DYNAMIC_ARRAYS
  /*
   * Restore globs->pstruct for possible use below
   */
  if (old_pstruct NEQ NULL)
  {
    globs->pstruct     = old_pstruct;
  }
#endif
  if (amount NEQ repeat AND is_variable)
  {
    /*
     * if the decoded elements are not equal the specified
     * repeat value, because the bitstream or the IE ended,
     * store the new c_xxx value.
     */
    globs->pstructOffs = melem[e_ref].structOffs;

    if (melem[e_ref].optional)
      globs->pstructOffs++;

      if (act_offset > 65535)
        *(ULONG *) (globs->pstruct + globs->pstructOffs) = amount;
      else if (act_offset > 255)
        *(USHORT *) (globs->pstruct + globs->pstructOffs) = (USHORT) amount;
      else
        globs->pstruct[globs->pstructOffs] = (UBYTE) amount;

    if (melem[e_ref].repType NEQ 'i')
    {
      /*
       * if this element is not of the repeat style 'interval'
       * ([X..Y] where X and Y are constants) we have to generate
       * an ccd error because some outstanding repeats are missing.
       */
      ccd_setError (globs, ERR_MAND_ELEM_MISS, CONTINUE, (USHORT) -1);
    }
  }

  return 1;
}
#endif /* !RUN_FLASH */

#ifndef RUN_FLASH
/*
+--------------------------------------------------------------------+
| PROJECT : CCD (6144)               MODULE  : CCD                   |
| STATE   : code                     ROUTINE : cdc_std_encode        |
+--------------------------------------------------------------------+

  PURPOSE : Performs a standard encoding for a given elem table entry.
            This means for non structured elements that m bytes read
            from the C-Variable, converted to MSB-first format and
            write 1-n bits at the end of the bitstream.
            For structured elements an (indirect) recursive call
            to ccd_encodeComposition() is performed.
            The element may be conditional and/or repeatable.
*/

SHORT cdc_std_encode (const ULONG c_ref, const ULONG e_ref, T_CCD_Globs *globs)
{
  ULONG               repeat, max_rep;
  BOOL                is_variable;
  ULONG               cix_ref, num_prolog_steps, prolog_step_ref;
#ifdef DYNAMIC_ARRAYS
  U8                  *old_pstruct = NULL;
#endif

#ifdef DEBUG_CCD
	#ifndef CCD_SYMBOLS
  TRACE_CCD (globs, "cdc_std_encode()");
	#else
	TRACE_CCD (globs, "cdc_std_encode() %s", ccddata_get_alias((USHORT) e_ref, 1));
	#endif
#endif

  cix_ref = melem[e_ref].calcIdxRef;
  num_prolog_steps = calcidx[cix_ref].numPrologSteps;
  prolog_step_ref  = calcidx[cix_ref].prologStepRef;
  /*
   * if this element is conditional, check the condition
   */
  if (calcidx[cix_ref].numCondCalcs NEQ 0
  AND ! ccd_conditionOK (e_ref, globs))
    return 1;

  /*
   * if this element have a defined Prolog
   * we have to process it before decoding the bitstream
   */
  if (num_prolog_steps)
  {
    ccd_performOperations (num_prolog_steps, prolog_step_ref, globs);
  }
  
  if (melem[e_ref].elemType NEQ 'S')
  {
    /*
     * Element is not a SPARE.
     * Setup the readpointer into the C-structure for this element
     * MVJ: In case of pointer types, the pstructOffs must be
     * the offset into the memory area pointed to. CCDGEN must
     * ensure this holds true.
     */
    globs->pstructOffs = melem[e_ref].structOffs;

    if (melem[e_ref].optional)
    {
      /*
       * for optional elements check the valid-flag in the C-struct.
       * Spare elements does not have a corresponding valid flag. For
       * the spare elements we have to calculate and check the
       * condition to decide if this elements have to be coded.
       */
      /* 20010621 MVJ: Dynamic array addition.
       * Postpone optional check for non-code transparent pointer
       * types ('P', 'Q', 'R').
       * For these types, the optional flag is the pointer itself.
       * These types cannot be checked yet, as the pointer may be
       * preceeded by a counter octet, a union tag id octet etc.
       */
      if (melem[e_ref].elemType < 'P' OR melem[e_ref].elemType > 'R')
      { 
        if (globs->pstruct[globs->pstructOffs++] == FALSE)
        {
          return 1;
        }
#ifdef DEBUG_CCD
        else if (globs->pstruct [melem[e_ref].structOffs] != TRUE)
        {
          TRACE_CCD (globs, "Ambiguous value for valid flag!\n...assumed 1 for ccdID=%d",
                     e_ref);
        }
#endif
      }
    }

    if ((melem[e_ref].repType EQ 'v' OR melem[e_ref].repType EQ 'i'))
    {
      /*
       * for variable sized elements read the amount
       * of repeats out of the C-Structure (c_xxx).
       * If the number of repeats given by the C-Structure 
       * exceeds the allowed value (maxRepeat) CCD gives a warning!
       */
      if (melem[e_ref].maxRepeat > 255)
      {
        ULONG count = (ULONG) (* (USHORT *)(globs->pstruct + globs->pstructOffs++));
        repeat = MINIMUM (count, (ULONG) melem[e_ref].maxRepeat);
        if (repeat < count) 
          ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE, 
                           (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
      }
      else
      {
        repeat = (ULONG)MINIMUM (globs->pstruct[globs->pstructOffs], 
                                  melem[e_ref].maxRepeat);
        if ( repeat < (ULONG) (globs->pstruct[globs->pstructOffs]) ) 
          ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE, 
                           (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
      }
      globs->pstructOffs++;
    }
    else
      if (melem[e_ref].repType EQ 'c')
      {
        repeat = (ULONG) melem[e_ref].maxRepeat;
      }
      else
        if (melem[e_ref].repType == 's' || melem[e_ref].repType == 'b')
        {
          switch (melem[e_ref].elemType)
          {
            case 'R': /* Pointer to (possible array of) basetype */
            case 'F': /* Code-transparent pointer to (possible array of) basetype */
            case 'V':
              globs->maxBitpos = globs->bitpos + mvar[melem[e_ref].elemRef].bSize;
              break;
            case 'D': /* Pointer to a composition */
            case 'P': /* Code transparent pointer to a comp */
            case 'C': /* Element is a composition. */
            case 'E': /* Pointer to a union */
            case 'Q': /* Code transparent pointer to a union */
            case 'U': /* Element is a union. */
              globs->maxBitpos = globs->bitpos + mcomp[melem[e_ref].elemRef].bSize;
              break;
          }
          
          is_variable = ccd_calculateRep (e_ref, &repeat, &max_rep, globs);
        }
        else
          repeat = 1;

    /* 20010621 MVJ: Dynamic array addition.
     * Check for non-code transparent pointer types ('P', 'Q', 'R').
     * For these types, the optional flag is the pointer itself.
     * ASSUMPTION: The pointer may be preceeded by a counter octet,
     * a union tag id octet etc., but it is up to CCDGEN to ensure
     * word alignment (by inserting alignment bytes). Therefore
     * we just read from globs->pstruct[globs->pstructOffs].
    */
#ifdef DEBUG_CCD
    /* Check pointer alignment and re-align if necessary (should never happen) */
    if ( is_pointer_type(e_ref) AND ((globs->pstructOffs & 3) NEQ 0)) {
      TRACE_CCD (globs, "cdc_STD_encode(): Pointer misaligned! pstruct=0x08x,"
		 " pstructOffs=0x%08x", globs->pstruct, globs->pstructOffs);
      globs->pstructOffs = (globs->pstructOffs + 3) & 3;
    }
#endif
#ifdef DYNAMIC_ARRAYS
    /*
     * MVJ: Perform pointer dereference for pointer types.
     * Also, check optionality for these types.
     */
    if ( is_pointer_type(e_ref) ) {
      U8 *deref_pstruct;

      /* Get pointer value */
      deref_pstruct = *(U8 **)&globs->pstruct[globs->pstructOffs];

      /*
       * Strictly speaking the 'D' to 'F' types should not need this
       * check (should have returned after the optionality check above),
       * but it will catch stray NULL pointers (or uninitialized
       * valid flags)
      */
      if (ccd_check_pointer(deref_pstruct) != ccdOK )
      {
        ccd_recordFault (globs, ERR_INVALID_PTR, BREAK, (USHORT) e_ref, 
                         &globs->pstruct[globs->pstructOffs]);
        return 1;
      }
      /*
       * Pointer not NULL;
       * 1. Save old globs->pstruct and assign pointer to globs->pstruct
       *    as new base.
       * 2. Set pstructOffs to 0 (zero) as the next offset will start
       *    in the new memory area.
       */
      old_pstruct        = globs->pstruct;
      globs->pstruct     = deref_pstruct;
      globs->pstructOffs = 0;
    }
#endif /* DYNAMIC_ARRAYS */
  }
  else
  {
    /*
     * for spare elements we have to calculate the conditions
     * and the repetitions because there are no valid-flags and
     * c_xxx variables in the C-structure to read.
     */
    if (melem[e_ref].optional)
    {
      /*
       * Spare elements does not have a corresponding valid flag.
       * For the spare elements we have to calculate and check the
       * condition to decide if this elements have to be coded.
       */
      if (calcidx[cix_ref].numCondCalcs NEQ 0
      AND ! ccd_conditionOK (e_ref, globs))
        return 1;
    }
    /*
     * if this spare is repeatable, calculate the amount of
     * repeats because there is no corresponding c_xxx element
     * in the C-Structure.
     */
    if (melem[e_ref].repType NEQ ' ')
    {
      globs->maxBitpos = globs->bitpos + spare[melem[e_ref].elemRef].bSize;
      is_variable = ccd_calculateRep (e_ref, &repeat, &max_rep, globs);
    }
    else
      repeat = 1;
  }

  cdc_encodeElemvalue (e_ref, repeat, globs);

#ifdef DYNAMIC_ARRAYS
  if ( old_pstruct NEQ NULL )
    globs->pstruct = old_pstruct;
#endif

  return 1;
}
#endif /* !RUN_FLASH */

/*
 * some elementary bitfunctions
 */

/* LSB,MSB Definitions for the CPUs */

#ifdef M_INTEL
#define MSB_POS 1
#define LSB_POS 0
#define MSW_POS 2
#define LSW_POS 0
#else /* M_INTEL */
#ifdef M_MOTOROLA
#define MSB_POS 0
#define LSB_POS 1
#define MSW_POS 0
#define LSW_POS 2
#endif /* M_MOTOROLA */
#endif /* M_INTEL */

extern const ULONG ccd_bitfun_mask[];

/*
 * Table of one-bit values (2^X)
 * This unused variable is commented now in order to avoid some compiler 
 * warnings like:  variable "shift" (line xxx) is not used

LOCAL const UBYTE shift[] =
{
  128, 64, 32, 16, 8, 4, 2, 1
};
 */

#ifndef RUN_FLASH
/*
+--------------------------------------------------------------------+
| PROJECT : CCD (6144)               MODULE  : CCD                   |
| STATE   : code                     ROUTINE : ccd_codeByte          |
+--------------------------------------------------------------------+

 PURPOSE:   encodes the value of (value) into a CPU-dependent
            bitstring. The length of the bitstring is specified
            throu (bitlen). The function copies the bitstring into
            the buffer (bitstream) at bit position (startbit).
            The bitlen may be between 1 and 8.

*/

BYTE CCDDATA_PREF(ccd_codeByte) (UBYTE * bitstream,
                                 USHORT startbit,
              		               USHORT bitlen,
                                 UBYTE value)
{
  union
  {	/* Conversion structure 2 Byte <-> unsigned short */
    UBYTE c[2];
    USHORT s;
  }
  conv;

  UBYTE *p, lshift;

  USHORT m;

  p = bitstream + (startbit >> 3);

  lshift = (16 - ((startbit & 7) + bitlen));

  conv.c[MSB_POS] = p[0];

  conv.c[LSB_POS] = p[1];

  m = ((USHORT) ccd_bitfun_mask[bitlen]) << lshift;

  conv.s &= ~m;

  conv.s |= ((value << lshift) & m);

  p[0] = conv.c[MSB_POS];

  p[1] = conv.c[LSB_POS];

  return ccdOK;
}
#endif /* !RUN_FLASH */

#ifndef RUN_FLASH
/*
+--------------------------------------------------------------------+
| PROJECT : CCD (6144)               MODULE  : CCD                   |
| STATE   : code                     ROUTINE : ccd_decodeByte        |
+--------------------------------------------------------------------+

 PURPOSE:   decodes (bitlen) bits from the (bitstream) at position
            (startbit) and converts them to a numeric value (value)
            The bitlen may be between 1 and 8.

*/

BYTE CCDDATA_PREF(ccd_decodeByte) (UBYTE *bitstream,
                                   USHORT startbit,
                                   USHORT bitlen,
                                   UBYTE *value)
{
  union
  {	/* Conversion structure 2 Byte <-> unsigned short */
    UBYTE c[2];
    USHORT s;
  }
  conv;

  UBYTE *p;

  p = bitstream + (startbit >> 3);

  conv.c[MSB_POS] = *p++;

  conv.c[LSB_POS] = *p;

  conv.s >>= (16 - ((startbit & 7) + bitlen));

  conv.s &= (USHORT) ccd_bitfun_mask[bitlen];

  *value = (UBYTE) conv.s;

  return ccdOK;
}
#endif /* !RUN_FLASH */

#ifndef RUN_FLASH
/*
+--------------------------------------------------------------------+
| PROJECT : CCD (6144)               MODULE  : CCD                   |
| STATE   : code                     ROUTINE : ccd_codeLong          |
+--------------------------------------------------------------------+

 PURPOSE:   encodes the value of (value) into a CPU-dependent
            bitstring. The length of the bitstring is specified
            throu (bitlen). The function copies the bitstring into
            the buffer (bitstream) at bit position (startbit).
            The bitlen may be between 1 and 32.

*/

BYTE CCDDATA_PREF(ccd_codeLong) (UBYTE *bitstream,
                                 USHORT startbit,
	                               USHORT bitlen,
                                 ULONG value)
{
  UBYTE *p;

  union
  {	/* Conversion structure 4 Byte <-> unsigned long */
    UBYTE c[4];
    ULONG l;
  }
  conv;

  p = bitstream + (startbit >> 3);
  startbit &= 7;

  conv.l = value & ccd_bitfun_mask[bitlen];
  conv.l <<= (32-bitlen-startbit);

  p[0] &= (UCHAR)~ccd_bitfun_mask[8-startbit];

  switch ((USHORT)(startbit+bitlen-1) >> 3)
  {
    case 0:
      p[0] |= conv.c[MSW_POS+MSB_POS];
      break;
    case 1:
      p[0] |= conv.c[MSW_POS+MSB_POS];
      p[1]  = conv.c[MSW_POS+LSB_POS];
      break;
    case 2:
      p[0] |= conv.c[MSW_POS+MSB_POS];
      p[1]  = conv.c[MSW_POS+LSB_POS];
      p[2]  = conv.c[LSW_POS+MSB_POS];
      break;
    case 3:
      p[0] |= conv.c[MSW_POS+MSB_POS];
      p[1]  = conv.c[MSW_POS+LSB_POS];
      p[2]  = conv.c[LSW_POS+MSB_POS];
      p[3]  = conv.c[LSW_POS+LSB_POS];
      break;
    default:
      p[0] |= conv.c[MSW_POS+MSB_POS];
      p[1]  = conv.c[MSW_POS+LSB_POS];
      p[2]  = conv.c[LSW_POS+MSB_POS];
      p[3]  = conv.c[LSW_POS+LSB_POS];
      p[4]  = (UBYTE) ((value & 0xff) << (8-startbit));
      break;
  }
  return ccdOK;
}
#endif /* !RUN_FLASH */

#ifndef RUN_FLASH
/*
+--------------------------------------------------------------------+
| PROJECT : CCD (6144)               MODULE  : CCD                   |
| STATE   : code                     ROUTINE : ccd_decodeLong        |
+--------------------------------------------------------------------+

 PURPOSE:   decodes (bitlen) bits from the (bitstream) at position
            (startbit) and converts them to a numeric value (value)
            The bitlen may be between 1 and 32.

*/

BYTE CCDDATA_PREF(ccd_decodeLong) (UBYTE *bitstream,
                                   USHORT startbit,
	                                 USHORT bitlen,
                                   ULONG *value)
{
  UBYTE *p;

  union
  {	/* Conversion structure 4 Byte <-> unsigned long */
    UBYTE c[4];
    ULONG l;
  }
  conv;

  p = bitstream + (startbit >> 3);
  startbit &= 7;

  conv.l = 0L;
  switch ((USHORT)(startbit+bitlen-1) >> 3)
  {
    case 0:
      conv.c[MSW_POS+MSB_POS] = p[0];
      conv.l <<= startbit;
      conv.l >>= (32-bitlen);
      break;
    case 1:
      conv.c[MSW_POS+MSB_POS] = p[0];
      conv.c[MSW_POS+LSB_POS] = p[1];
      conv.l <<= startbit;
      conv.l >>= (32-bitlen);
      break;
    case 2:
      conv.c[MSW_POS+MSB_POS] = p[0];
      conv.c[MSW_POS+LSB_POS] = p[1];
      conv.c[LSW_POS+MSB_POS] = p[2];
      conv.l <<= startbit;
      conv.l >>= (32-bitlen);
      break;
    case 3:
      conv.c[MSW_POS+MSB_POS] = p[0];
      conv.c[MSW_POS+LSB_POS] = p[1];
      conv.c[LSW_POS+MSB_POS] = p[2];
      conv.c[LSW_POS+LSB_POS] = p[3];
      conv.l <<= startbit;
      conv.l >>= (32-bitlen);
      break;
    default:
      conv.c[MSW_POS+MSB_POS] = p[0];
      conv.c[MSW_POS+LSB_POS] = p[1];
      conv.c[LSW_POS+MSB_POS] = p[2];
      conv.c[LSW_POS+LSB_POS] = p[3];
      conv.l <<= startbit;
      conv.l >>= (32-bitlen);
      conv.c[LSW_POS+LSB_POS] |= (p[4] >> (8-startbit));
      break;
  }
  *value = conv.l & ccd_bitfun_mask[bitlen];
  return ccdOK;
}
#endif /* !RUN_FLASH */

#ifndef RUN_FLASH
/*
+--------------------------------------------------------------------+
| PROJECT : CCD (6144)               MODULE  : CCD                   |
| STATE   : code                     ROUTINE : ccd_bitcopy           |
+--------------------------------------------------------------------+

 PURPOSE: copys bitlen bits from the source buffer to the destination
          buffer. offset contains the position of the first bit in
          the source bitfield. This function may perform a leftshift
          to adjust the most significant bit on byte boundarys of the
          first byte in dest.

*/

void CCDDATA_PREF(ccd_bitcopy) (UBYTE     *dest,
                                UBYTE     *source,
                                USHORT     bitlen,
                                USHORT     offset)
{
  union
  {	/* Conversion structure 2 Byte <-> unsigned short */
    UBYTE  c[2];
    USHORT s;
  }
  conv;

  USHORT l_shift       = offset & 7;
  USHORT bytes_to_copy = (bitlen >> 3);

  /*
   * go to the byte that contains the first valid bit.
   */
  source += (offset >> 3);


  if (l_shift)
  {
    /*
     * shift and copy each byte
     */
    while (bytes_to_copy--)
    {
      conv.c[MSB_POS] = *source;
      source++;
      conv.c[LSB_POS] = *source;
      conv.s <<= l_shift;
      *dest = conv.c[MSB_POS];
      dest++;
    }
  }
  else
  {
    /*
     * no shift operation, do a memcopy;
     */
    while (bytes_to_copy--)
    {
      *dest = *source;
      dest++;
      source++;
    }
  }
  /*
   * cutoff the garbage at the end of the bitstream
   */
 
  *(dest-1) &= (UCHAR)(~ccd_bitfun_mask[(8-(bitlen&7))&7]);
}
#endif /* !RUN_FLASH */