+
−/* 
+
−+----------------------------------------------------------------------------- 
+
−|  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 */