+
−/* 
+
−+----------------------------------------------------------------------------- 
+
−|  Project :  
+
−|  Modul   : cdc_com.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 common functions for encoding and decoding of
+
−|             GSM, GPRS or UMTS air interface messages
+
−+----------------------------------------------------------------------------- 
+
−*/ 
+
−
+
−#ifdef _MSDOS
+
−#include <dos.h>
+
−#include <conio.h>
+
−#endif
+
−
+
−/*
+
− * standard definitions like UCHAR, ERROR etc.
+
− */
+
−#include "typedefs.h"
+
−#include "header.h"
+
−#include <string.h>
+
−#include <stdlib.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
+
− */
+
−#include "ccdtable.h"
+
−#include "ccddata.h"
+
−
+
−/*
+
− * Prototypes and constants in the common part of ccd
+
− */
+
−#include "ccd.h"
+
−#include "ccd_codingtypes.h"
+
−
+
−/*
+
− * Need memory allocation functions for dynamic arrays (pointers)
+
− */
+
−#ifdef DYNAMIC_ARRAYS
+
−#include "vsi.h"
+
−#endif
+
−
+
−#ifndef RUN_FLASH
+
−const UBYTE padding_bits[8]      =    {0, 0, 1, 0, 1, 0, 1, 1};
+
−const UBYTE padding_bits_prev[8] =    {1, 0, 0, 1, 0, 1, 0, 1};
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/* Attention for RUN_...: static data (used in cdc_skipElem) */
+
−static UBYTE  dummy[256];
+
−#endif /* !RUN_FLASH */
+
−
+
−typedef struct unknownTag
+
−{
+
− U8  errCode;
+
− U8  tag;
+
− U16 bitpos;
+
− struct unknownTag *next;
+
−}T_UNKNOWN_TAG;
+
−
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CDC_COM             |
+
−| STATE   : code                       ROUTINE : cdc_init_ctx_table  |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : init the iei_ctx table. This must be done before decoding
+
−            a message.
+
−
+
−*/
+
−
+
−static void cdc_init_ctx_table (T_CCD_Globs *globs)
+
−{
+
−  int i;
+
−
+
−#ifdef DEBUG_CCD
+
−  TRACE_CCD (globs, "CONTEXT table init");
+
−#endif
+
−
+
−  for (i=0; i<MAX_RECURSIONS_PER_MSG; i++)
+
−  {
+
−    globs->iei_ctx[i].valid = FALSE;
+
−  }
+
−  globs->numEOCPending = 0;
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_INT_RAM
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CCD                 |
+
−| STATE   : code                       ROUTINE : cdc_BCD_decode      |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Decoding of an bitstream containing a BCD string
+
−            with k digits. If the first digit in the bitstream
+
−            is DIGIT_2, the digits are ordered
+
−            in the Bitstream as follow:
+
−
+
−            MSBit     LSBit
+
−            8 7 6 5 4 3 2 1
+
−            DIGIT_2 DIGIT_1    Octett n
+
−            DIGIT_4 DIGIT_3    Octett n+1
+
−            : : : : : : : :
+
−            DIGIT_Z DIGIT_X    Octett n+m
+
−
+
−            if the number of the digits is odd, the last
+
−            Octett contains the bit pattern 1111 in the
+
−            most significant nibble.
+
−
+
−            : : : : : : : :
+
−            1 1 1 1 DIGIT_X    Octett n+m
+
−
+
−  NOTE:     If the first digit in the bitstream is DIGIT_1,
+
−            the digits are ordered in a different way:
+
−
+
−            MSBit     LSBit
+
−            8 7 6 5 4 3 2 1
+
−            DIGIT_1 XXXXXXX    Octett n
+
−            DIGIT_3 DIGIT_2    Octett n+1
+
−            DIGIT_5 DIGIT_4    Octett n+2
+
−            : : : : : : : :
+
−            DIGIT_Z DIGIT_X    Octett n+m
+
−
+
−            In this case, if the number of the digits
+
−            is even, the last octett contains the bit
+
−            pattern 1111 in the most significant nibble.
+
−
+
−            : : : : : : : :
+
−            1 1 1 1 DIGIT_X    Octett n+m
+
−
+
−            The amount of digits may be constant or variable.
+
−
+
−  NOTE:     A special case (type BCD_NOFILL) is the encoding and
+
−            decoding of a BCD string starting with DIGIT_2 but
+
−            without setting/checking the most significant nibble
+
−            of Octet n+m. This nibble belongs to the next IE 
+
−            (usual coded by type BCD_MNC). 
+
−            Type BCD_NOFILL is coded by startDigit EQ 2.  
+
−*/
+
−
+
−void cdc_BCD_decode (const ULONG e_ref, UBYTE startDigit, T_CCD_Globs *globs)
+
−{
+
−  BOOL    is_variable;
+
−  UBYTE  *digits;
+
−  UBYTE  *addr_c_xxx;
+
−  ULONG   i, max_rep, nibbles_to_read, repeat;
+
−  ULONG   cix_ref, num_prolog_steps, prolog_step_ref;
+
−  int     k;
+
−
+
−#ifdef DEBUG_CCD
+
−  #ifndef CCD_SYMBOLS
+
−  TRACE_CCD (globs, "cdc_BCD_decode()");
+
−	#else
+
−	TRACE_CCD (globs, "cdc_BCD_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;
+
−
+
−  /*
+
−   * 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 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, &max_rep, globs);
+
−  }
+
−  else
+
−  {
+
−    repeat = 1;
+
−    is_variable = FALSE;
+
−  }
+
−  
+
−  /*
+
−   * setup the offset into the C-structure for this element
+
−   */
+
−  globs->pstructOffs = melem[e_ref].structOffs;
+
−
+
−  if (melem[e_ref].optional)
+
−  {
+
−    /*
+
−     * for optional elements set the valid-flag
+
−     */
+
−    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).
+
−     */
+
−    addr_c_xxx = (UBYTE *) (globs->pstruct + globs->pstructOffs++);
+
−    if (max_rep > 255)
+
−      globs->pstructOffs++;
+
−  }
+
−  else
+
−    addr_c_xxx = NULL;
+
−
+
−  digits = (UBYTE *) (globs->pstruct + globs->pstructOffs);
+
−
+
−
+
−  if (startDigit EQ 1)
+
−  {
+
−    /*
+
−     * read the BCD digits out of the bitstream.
+
−     * The read order is 1,X,3,2,5,4 ...
+
−     */
+
−    /*
+
−     * if the first digit is digit_1 read it and skip
+
−     * the next 4 bits, because they do not belong to
+
−     * the BCD stream.
+
−     */
+
−    digits[0] = bf_decodeByteNumber (4, globs);
+
−    bf_incBitpos (4, globs);
+
−    /*
+
−     * make a correction on the repeatvalue
+
−     */
+
−    if (melem[e_ref].repType NEQ ' ')
+
−    {
+
−      is_variable = ccd_calculateRep (e_ref, &repeat, &max_rep, globs);
+
−    }
+
−
+
−    k = 2;
+
−
+
−    for (i=0; i<repeat; i++)
+
−    {
+
−      digits[k] = bf_decodeByteNumber (4, globs);
+
−  #ifdef DEBUG_CCD
+
−      TRACE_CCD (globs, "BCD digit (%X) read", (USHORT) digits[k]);
+
−  #endif
+
−      k = ((k&1) EQ 0) ? (k-1) : (k+3);
+
−    }
+
−  }
+
−  else
+
−  {
+
−    /*
+
−     * read the BCD digits out of the bitstream.
+
−     * The read order is 2,1,4,3,6,5 ...
+
−     */
+
−    k = 1;
+
−
+
−    nibbles_to_read = repeat;
+
−
+
−    if (repeat & 1)
+
−      nibbles_to_read++;
+
−
+
−    for (i=0; i<nibbles_to_read; i++)
+
−    {
+
−      digits[k] = bf_decodeByteNumber (4, globs);
+
−  #ifdef DEBUG_CCD
+
−      TRACE_CCD (globs, "BCD digit (%X) read", (USHORT) digits[k]);
+
−  #endif
+
−      k = ((k&1) EQ 1) ? (k-1) : (k+3);
+
−    }
+
−  }
+
−
+
−  /*
+
−   * check the 1111 pattern and the even odd criteria
+
−   */
+
−
+
−  if (startDigit EQ 1)
+
−  {
+
−    if ((repeat & 1) EQ 0) 
+
−    {
+
−      /* even number of digits */
+
−      if (digits[repeat] NEQ 0xf)
+
−        repeat++;
+
−    }
+
−  }
+
−  else
+
−  {
+
−    if ((repeat & 1) EQ 1) 
+
−    {
+
−      /* odd number of digits */
+
−      if (digits[repeat] NEQ 0xf AND startDigit EQ 0)
+
−      {
+
−        /*
+
−         * if there is no 1111 pattern generate an error
+
−         */
+
−        ccd_setError (globs, ERR_PATTERN_MISMATCH,
+
−                      CONTINUE,
+
−                      (USHORT) (globs->bitpos-8), (USHORT) -1);
+
−      }
+
−    }
+
−
+
−    else
+
−    {
+
−      /* even number of digits - the last may be 0xf */
+
−      if (digits[repeat-1] EQ 0xf)
+
−        repeat--;   /* 0x0f dosn't belong to the coded digit string */
+
−    }
+
−  }
+
−
+
−  if (addr_c_xxx NEQ NULL)
+
−  {
+
−    /*
+
−     * store the number of digits into the 
+
−     * c_xxx variable if there is one.
+
−     */
+
−     if (max_rep > 65535)
+
−     {
+
−       ULONG *addr_c_xxx_u32;
+
−       addr_c_xxx_u32 = (ULONG *)addr_c_xxx;
+
−       *addr_c_xxx_u32 = repeat;
+
−     }
+
−     else if (max_rep > 255)
+
−     {
+
−       USHORT *addr_c_xxx_u16;
+
−       addr_c_xxx_u16 = (USHORT *)addr_c_xxx;
+
−       *addr_c_xxx_u16 = (USHORT) repeat;
+
−     }
+
−     else
+
−       *addr_c_xxx = (UBYTE) repeat;
+
−  }
+
−}
+
−#endif /* !RUN_INT_RAM */
+
−
+
−#ifndef RUN_INT_RAM
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CCD                 |
+
−| STATE   : code                       ROUTINE : cdc_BCD_encode      |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : encoding a Bytearray, that contain a BCD Number, into
+
−            bitstream.
+
−            The digits coded in the following order
+
−            into the Bitstream:
+
−
+
−            MSBit     LSBit   
+
−            7 8 6 5 4 3 2 1
+
−            DIGIT_2 DIGIT_1    Octett n
+
−            DIGIT_4 DIGIT_3    Octett n+1
+
−            : : : : : : : :
+
−            DIGIT_Z DIGIT_X    Octett n+m
+
−            
+
−            if the number of the digits are odd, the bit pattern 1111
+
−            will be coded in the most significant nibble of
+
−            the last Octett.
+
−            
+
−            : : : : : : : :
+
−            1 1 1 1 DIGIT_X    Octett n+m
+
−
+
−            The amount of digits may be constant or variable.
+
−*/
+
−void cdc_BCD_encode (const ULONG e_ref, UBYTE startDigit, T_CCD_Globs *globs)
+
−{
+
−  ULONG           repeat;
+
−  int             k;
+
−  register UBYTE *digits;
+
−  BOOL            fullBitsNeeded=FALSE;
+
−  ULONG           cix_ref, num_prolog_steps, prolog_step_ref;
+
−
+
−#ifdef DEBUG_CCD
+
−  #ifndef CCD_SYMBOLS
+
−  TRACE_CCD (globs, "cdc_BCD_encode()");
+
−	#else
+
−	TRACE_CCD (globs, "cdc_BCD_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;
+
−
+
−  /*
+
−   * 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);
+
−  }
+
−  
+
−  /*
+
−   * setup the offset into the C-structure for this element
+
−   */
+
−  globs->pstructOffs = melem[e_ref].structOffs;
+
−
+
−  if (melem[e_ref].optional)
+
−  {
+
−    /*
+
−     * for optional elements check the valid-flag
+
−     */
+
−    if (globs->pstruct[globs->pstructOffs++] == FALSE)
+
−      return;
+
−#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 this element is repeatable, and the number of
+
−   * repeats depends on another element, calculate the repeater
+
−   */
+
−  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, 
+
−                          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
+
−      repeat = 1; 
+
−
+
−  /* There seems to exist cases where address contains no digits. */
+
−  if (repeat EQ 0)
+
−    return;
+
−
+
−  /* 
+
−   * setup the read pointer to the byte array that contain
+
−   * the BCD number.
+
−   */
+
−  digits = (UBYTE *) (globs->pstruct + globs->pstructOffs);
+
−
+
−  if (startDigit EQ 1)
+
−  {
+
−    /*
+
−     * write the BCD digits into the bitstream.
+
−     * The write order is 1,X,3,2,5,4 ...
+
−     */
+
−    if ((repeat & 1) EQ 0)
+
−    {
+
−      /*
+
−       * for even digits store the 1111 pattern at last digit
+
−       */
+
−      fullBitsNeeded = TRUE;
+
−    }
+
−    /*
+
−     * if the first digit is digit_1 write it and skip
+
−     * the next 4 bits, because they does not belong to
+
−     * the BCD stream.
+
−     */
+
−    bf_codeByteNumber (4, digits[0], globs);
+
−
+
−  #ifdef DEBUG_CCD
+
−    TRACE_CCD (globs, "BCD digit (%X) written", (USHORT) digits[0]);
+
−    TRACE_CCD (globs, "skipping 4 bits");
+
−  #endif
+
−
+
−    bf_incBitpos (4, globs);
+
−    k = 2;
+
−
+
−    while (--repeat>1)
+
−    {
+
−      bf_codeByteNumber (4, digits[k], globs);
+
−  #ifdef DEBUG_CCD
+
−      TRACE_CCD (globs, "BCD digit (%X) written", (USHORT) digits[k]);
+
−  #endif
+
−      k = ((k&1) EQ 0) ? (k-1) : (k+3);
+
−    }
+
−    if (repeat)
+
−    {
+
−    if (fullBitsNeeded)
+
−    {
+
−      bf_codeByteNumber (4, 0xf, globs);
+
−      k = ((k&1) EQ 0) ? (k-1) : (k+3);
+
−      }
+
−      bf_codeByteNumber (4, digits[k], globs);
+
−   }
+
−    
+
−  }
+
−  else
+
−  {
+
−    /*
+
−     * store the BCD digits into the bitstream.
+
−     * The write order is 2,1,4,3,6,5 ...
+
−     */
+
−    if (repeat & 1)
+
−    {
+
−      /*
+
−       * for odd digits store the 1111 pattern at last digit
+
−       * in case of type BCD_NOFILL use 0 instead
+
−       */
+
−        fullBitsNeeded = TRUE;
+
−    }
+
−
+
−    k = 1;
+
−
+
−    while ( repeat-- > 1)
+
−    {
+
−      bf_codeByteNumber (4, digits[k], globs);
+
−#ifdef DEBUG_CCD
+
−      TRACE_CCD (globs, "BCD digit (%X) written", (USHORT) digits[k]);
+
−#endif
+
−      k = ((k&1) EQ 1) ? (k-1) : (k+3);
+
−    }
+
−    if (fullBitsNeeded)
+
−    {
+
−      bf_codeByteNumber (4, (UBYTE)((startDigit NEQ 2) ? 0xf : 0), globs);
+
−      k = ((k&1) EQ 1) ? (k-1) : (k+3);
+
−    }
+
−    bf_codeByteNumber (4, digits[k], globs);
+
−  }
+
−}
+
−#endif /* !RUN_INT_RAM */
+
−
+
−#ifndef RUN_FLASH
+
−/* Attention for RUN_...: static function */
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CDC_COM             |
+
−| STATE   : code                       ROUTINE : cdc_init_table      |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : init the iei_table for each new msg that is to be decoded.
+
−            The c_ref references a composition (msg). The function
+
−            initialises the table entrys only for the used iei for
+
−            this message.
+
−
+
−*/
+
−
+
−static void cdc_init_table (const ULONG c_ref, T_CCD_Globs *globs)
+
−
+
−{
+
−  ULONG  look_up;
+
−  ULONG  num_elems;
+
−  ULONG  ie_table_idx;
+
−  ULONG  rlevel = globs->ccd_recurs_level;
+
−
+
−  if (globs->iei_ctx[rlevel].valid AND rlevel < (ULONG) globs->last_level)
+
−  {
+
−    int i;
+
−    /*
+
−     * this iei context has been initialized before, so
+
−     * no action for this. All deeper levels must be set
+
−     * to invalid;
+
−     */
+
−    for (i=globs->last_level; i<MAX_RECURSIONS_PER_MSG; i++)
+
−       globs->iei_ctx[i].valid = FALSE;
+
− 
+
−#ifdef DEBUG_CCD
+
−    TRACE_CCD (globs, "TAG table init for old level %d", rlevel);
+
−#endif
+
−  }
+
−  else
+
−  {
+
−    /*
+
−     * this iei context has not been initialized before, so
+
−     * initialize the iei_table for this.
+
−     */
+
−#ifdef DEBUG_CCD
+
−  TRACE_CCD (globs, "TAG table init for new level %d", rlevel);
+
−#endif
+
−    look_up   = (ULONG) mcomp[c_ref].componentRef;
+
−    num_elems = (ULONG) mcomp[c_ref].numOfComponents;
+
−
+
−    /*
+
−     * store the startposition of the corresponding melem table and
+
−     * the number of elements in the IEtable
+
−     */
+
−    globs->iei_ctx[rlevel].melemStart   = (USHORT) look_up;
+
−    globs->iei_ctx[rlevel].ieTableLen   = (USHORT) num_elems;
+
−    globs->iei_ctx[rlevel].EOCPending   = FALSE;
+
−    globs->iei_ctx[rlevel].countSkipped = 0;
+
−
+
−    /* 
+
−     * for each element with an iei (ident) setup the 
+
−     * the iei_table-entry.
+
−     */
+
−    ie_table_idx = 0;
+
−
+
−    /*
+
−     * if the number of IE in this message is greater than 
+
−     * the allocated IEItable, generate an error.
+
−     */
+
−    if (num_elems > MAX_IE_PER_MSG)
+
−      ccd_setError (globs, ERR_INTERNAL_ERROR, BREAK, (USHORT) -1);
+
−
+
−    while (num_elems--)
+
−    {
+
−      if (melem[look_up].ident NEQ 0xffff)
+
−      {  
+
−        globs->iei_ctx[rlevel].iei_table[ie_table_idx].ident = (UBYTE) melem[look_up].ident;
+
−        
+
−        /*
+
−         * GSM1TV elements have only a 4 bit Tag (T). For this 
+
−         * elements we have to shift the ident into the upper nibble
+
−         * and set the lower nibble to zero. For GSM2T elements and
+
−         * GSM1TV elements set the MSBit (Bit7). 
+
−         */
+
−        if (melem[look_up].codingType EQ CCDTYPE_GSM1_TV)
+
−        {
+
−          /*
+
−           * shift into the upper nibble, clear the lower nibble
+
−           * and set the MSBit.
+
−           */
+
−          globs->iei_ctx[rlevel].iei_table[ie_table_idx].ident <<= 4;
+
−          globs->iei_ctx[rlevel].iei_table[ie_table_idx].ident |= 0x80;
+
−          globs->iei_ctx[rlevel].iei_table[ie_table_idx].ident &= 0xf0;
+
−        }
+
−        else
+
−        {
+
−          if (melem[look_up].codingType EQ CCDTYPE_GSM2_T)
+
−          {
+
−            /*
+
−             * Set the MSBit.
+
−             */
+
−            globs->iei_ctx[rlevel].iei_table[ie_table_idx].ident |= 0x80;
+
−          }
+
−        }
+
−        globs->iei_ctx[rlevel].iei_table[ie_table_idx].act_amount = 0;
+
−        globs->iei_ctx[rlevel].iei_table[ie_table_idx].exhausted = FALSE;
+
−
+
−        switch (melem[look_up].codingType)
+
−        {      
+
−          case CCDTYPE_GSM1_TV:
+
−
+
−          case CCDTYPE_GSM2_T:
+
−
+
−          case CCDTYPE_GSM3_TV:
+
−
+
−          case CCDTYPE_GSM4_TLV:
+
−
+
−          case CCDTYPE_GSM5_TV:
+
−
+
−          case CCDTYPE_GSM5_TLV:
+
−
+
−          case CCDTYPE_GSM1_ASN:
+
−
+
−          case CCDTYPE_GSM6_TLV:
+
−
+
−            globs->iei_ctx[rlevel].iei_table[ie_table_idx].valid = TRUE;
+
−            break;
+
−
+
−          default:
+
−            globs->iei_ctx[rlevel].iei_table[ie_table_idx].valid = FALSE;
+
−            break;
+
−        }
+
−      }
+
−      else
+
−        globs->iei_ctx[rlevel].iei_table[ie_table_idx].valid = FALSE;
+
−
+
−#ifdef DEBUG_CCD
+
−    TRACE_CCD (globs, "iei_table[%d] v=%d ident=%x level=%d",
+
−                ie_table_idx,
+
−                globs->iei_ctx[rlevel].iei_table[ie_table_idx].valid,
+
−                globs->iei_ctx[rlevel].iei_table[ie_table_idx].ident,
+
−                rlevel);
+
−#endif
+
−
+
−      look_up++;
+
−      ie_table_idx++;
+
−    }
+
−    globs->iei_ctx[rlevel].valid = TRUE;
+
−  }
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/* Attention for RUN_...: static function */
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CDC_COM             |
+
−| STATE   : code                       ROUTINE : cdc_search_table    |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : search on the iei_table for the given TAG (T).
+
−            if the TAG can be found (and - in case of CCDTYPE_GSM1_ASN - 
+
−            if the information element isn't exhausted), the table 
+
−            index was returned as a difference between the found index
+
−            and the aktIndex, -127 otherwise.
+
−  
+
−*/
+
−
+
−static int cdc_search_table 
+
−            ( 
+
−              int   akt_index,
+
−              ULONG t,
+
−              BOOL  limited,
+
−              BOOL  *nonTaggedFound,
+
−              T_CCD_Globs *globs
+
−            )
+
−{
+
−  int   tab_idx;
+
−  ULONG iei;
+
−  int   ret = -127;
+
−  ULONG rec_level = globs->ccd_recurs_level;
+
−  
+
−  /*
+
−   * search from the akt position to the end of the table.
+
−   * This is faster, because in correct messages the found Tag
+
−   * is at a later position in the table. 
+
−   */
+
−  tab_idx = akt_index;
+
−  
+
−  *nonTaggedFound = FALSE;
+
−
+
−  while (tab_idx < (int) globs->iei_ctx[rec_level].ieTableLen)
+
−  {
+
−#ifdef DEBUG_CCD
+
−    TRACE_CCD (globs, "looking for Tag(%x) iei_table[%d] v=%d ident=%x level=%d",
+
−                t, tab_idx,
+
−                globs->iei_ctx[rec_level].iei_table[tab_idx].valid,
+
−                globs->iei_ctx[rec_level].iei_table[tab_idx].ident,
+
−                rec_level);
+
−#endif
+
−
+
−    if (globs->iei_ctx[rec_level].iei_table[tab_idx].valid)
+
−    {
+
−      if (limited)
+
−      {
+
−        iei= (ULONG)(globs->iei_ctx[rec_level].iei_table[tab_idx].ident & 0x7f);
+
−      }
+
−      else
+
−      {
+
−        iei= (ULONG)(globs->iei_ctx[rec_level].iei_table[tab_idx].ident);
+
−      }
+
−      if ( iei EQ t )
+
−      {
+
−        if ( globs->iei_ctx[rec_level].iei_table[tab_idx].exhausted EQ FALSE )
+
−        {
+
−          return (tab_idx-akt_index);
+
−        }
+
−        else if ( (globs->iei_ctx[rec_level].melemStart + akt_index) 
+
−            EQ  (int) globs->iei_ctx[rec_level].melemLast)
+
−        {
+
−         /*
+
−          * allows multiple appearance of the repeated element is coded as 
+
−          * TLV0 TLV1 TLV2 ....
+
−          */
+
−          return (tab_idx-akt_index);
+
−        }
+
−        else 
+
−        {
+
−          ret = (tab_idx-akt_index);
+
−        }
+
−      }
+
−    }
+
−    else
+
−      *nonTaggedFound = TRUE;        
+
−    tab_idx++;
+
−  }
+
−
+
−  tab_idx = 0;
+
−
+
−  while (tab_idx < akt_index)
+
−  {
+
−#ifdef DEBUG_CCD
+
−    TRACE_CCD (globs, "looking for Tag(%x) iei_table[%d] v=%d ident=%x level=%d",
+
−                t, tab_idx,
+
−                globs->iei_ctx[rec_level].iei_table[tab_idx].valid,
+
−                globs->iei_ctx[rec_level].iei_table[tab_idx].ident,
+
−                rec_level);
+
−#endif
+
−    if (limited)
+
−    {
+
−      iei= (ULONG)(globs->iei_ctx[rec_level].iei_table[tab_idx].ident & 0x7f);
+
−    }
+
−    else
+
−    {
+
−      iei= (ULONG) globs->iei_ctx[rec_level].iei_table[tab_idx].ident;
+
−    }
+
−    if (globs->iei_ctx[rec_level].iei_table[tab_idx].valid
+
−    AND (iei EQ t) )
+
−    {
+
−      if ( globs->iei_ctx[rec_level].iei_table[tab_idx].exhausted EQ FALSE )
+
−      {
+
−        return (tab_idx-akt_index);
+
−      }
+
−      else 
+
−      {
+
−        ret = (tab_idx-akt_index);
+
−      }
+
−    }
+
−    tab_idx++;
+
−  }
+
− 
+
−  if (ret != -127)
+
−  {
+
−    globs->SequenceError = TRUE;
+
−  }
+
−    
+
−  return ret;
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/* Attention for RUN_...: static function */
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CDC_COM             |
+
−| STATE   : code                       ROUTINE : cdc_decode_L        |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Decode the length element of TLV and LV values
+
−*/
+
−
+
−static ULONG cdc_decode_L (const ULONG  e_ref, const ULONG len_l, T_CCD_Globs *globs)
+
−{
+
−  ULONG l;
+
−  
+
−  switch (melem[e_ref].codingType)
+
−  {
+
−    case CCDTYPE_GSM1_ASN:
+
−      l = (ULONG) bf_decodeByteNumber (8, globs);
+
−#ifdef DEBUG_CCD
+
−      TRACE_CCD (globs, "decoding 8 bits, l = (%x)", l);
+
−#endif
+
−      if (l EQ 0x80)
+
−        l = 0xFFFF;
+
−      else if (l EQ 0x81)
+
−      {
+
−        l = (ULONG) bf_decodeByteNumber (8, globs);
+
−#ifdef DEBUG_CCD
+
−        TRACE_CCD (globs, "decoding 8 bits after 0x81, l = (%x)", l);
+
−#endif
+
−      }
+
−      else if (l EQ 0x82)
+
−      {
+
−        l = bf_decodeShortNumber (16, globs);
+
−#ifdef DEBUG_CCD
+
−        TRACE_CCD (globs, "decoding 16 bits after 0x82, l = (%x)", l);
+
−#endif
+
−      }
+
−      break;
+
−  
+
−    case CCDTYPE_GSM5_TLV:
+
−      l = (ULONG) bf_decodeByteNumber (8, globs);
+
−
+
−      if (l EQ 0x81)
+
−      {
+
−        l = (ULONG) bf_decodeByteNumber (8, globs);
+
−#ifdef DEBUG_CCD
+
−        TRACE_CCD (globs, "decoding 8 bits after 0x81, l = (%x)", l);
+
−      }
+
−      else
+
−      {
+
−        TRACE_CCD (globs, "decoding 8 bits, l = (%x)", l);
+
−#endif
+
−      }
+
−      break;
+
−
+
−   case CCDTYPE_GSM6_TLV:
+
−      l = bf_decodeShortNumber (16, globs);
+
−#ifdef DEBUG_CCD
+
−      TRACE_CCD (globs, "decoding 16 bits, l = (%x)", l);
+
−#endif
+
−      break;  
+
−
+
−    default:
+
−      l = (ULONG) bf_decodeByteNumber (len_l, globs);
+
−#ifdef DEBUG_CCD
+
−      TRACE_CCD (globs, "decoding %d bits, l = (%x)", len_l, l);
+
−#endif
+
−      break;
+
−  }
+
−
+
−  /*
+
−   * Write the value of l at the end of UPN Stack.
+
−   * this could be read by an IE of the coding type NO_CODE.
+
−   */  
+
−  globs->KeepReg[0] = l ; 
+
−  return l;
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/* Attention for RUN_...: static function */
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CDC_COM             |
+
−| STATE   : code                       ROUTINE : cdc_tagged_LV_decode|
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : If the parameter lenL is set to a positive value,
+
−            this function decodes the L-component.
+
−            After this it decodes the element referenced
+
−            by eRef out of the bitstream into the C-Structure
+
−            (globs->pstruct) at position globs->pstructOffs.
+
−            If a repeat value is defined for this element,
+
−            this function decodes only one appeareance
+
−            of the element because it is a tagged 
+
−            element. In this case the decoded element is stored in
+
−            an array wich is indexed by eIndex;
+
−*/
+
−
+
−static BOOL cdc_tagged_LV_decode (const ULONG e_ref,
+
−                                  ULONG e_index,
+
−                                  const ULONG len_l,
+
−                                  T_CCD_Globs *globs)
+
−{
+
−  ULONG  amount, l;
+
−  USHORT act_maxBP, tmp_maxBP; 
+
−  BOOL   endOfComposition = FALSE;
+
−  BOOL   asn1=FALSE;
+
−  U32    offset=0;
+
−#ifdef DYNAMIC_ARRAYS
+
−  U8    *old_pstruct = NULL;
+
−#endif
+
−      
+
−  if (melem[e_ref].codingType EQ CCDTYPE_GSM1_ASN)
+
−    asn1 = TRUE;
+
− 
+
−  if (melem[e_ref].elemType NEQ 'S')
+
−  {
+
−    /*
+
−     * set the offset into the C-structure for this element. 
+
−     */
+
−    if (melem[e_ref].optional)
+
−    {
+
−      globs->pstruct[globs->pstructOffs++] = (UBYTE) TRUE;
+
−    }
+
−
+
−    if (melem[e_ref].repType EQ 'i')
+
−    {
+
−      /*
+
−       * The number of appearance of all repeatable IEs may
+
−       * differ in a message. So we have to store the number
+
−       * in a c_xxx counter into the C-Structure.
+
−       */
+
−      if (melem[e_ref].maxRepeat > 65535)
+
−        *(ULONG  *) (globs->pstruct + globs->pstructOffs++) = e_index;
+
−      else if (melem[e_ref].maxRepeat > 255)
+
−        *(USHORT *) (globs->pstruct + globs->pstructOffs++) = (USHORT) e_index;
+
−      else
+
−        globs->pstruct[globs->pstructOffs] = (UBYTE) e_index;
+
−
+
−      globs->pstructOffs++;
+
−
+
−      /*
+
−       * Recalculate the struct offset for repeatable IEs.
+
−       * New pointer types 'R' and 'F' are equivalent to 'V'.
+
−       */
+
−#ifdef DYNAMIC_ARRAYS
+
−      offset = (e_index-1) * ((melem[e_ref].elemType EQ 'V'
+
−                              OR melem[e_ref].elemType EQ 'R'
+
−                              OR melem[e_ref].elemType EQ 'F'
+
−                              ) ? mvar[melem[e_ref].elemRef].cSize
+
−			     : mcomp[melem[e_ref].elemRef].cSize
+
−                             );
+
−#else
+
−      offset = (e_index-1) * ((melem[e_ref].elemType EQ 'V')
+
−				      ? mvar[melem[e_ref].elemRef].cSize
+
−				      : mcomp[melem[e_ref].elemRef].cSize
+
−				      );
+
−#endif
+
−    }
+
−  }
+
−  /*
+
−   * If len_l > 0 read the l-Component out of the bistream.
+
−   */
+
−  if (len_l)
+
−  {
+
−    if( len_l <= (ULONG) (globs->maxBitpos - globs->bitpos) )
+
−    {
+
−      act_maxBP = globs->maxBitpos;
+
−      l = cdc_decode_L (e_ref, len_l, globs);
+
−
+
−      if (l EQ 0xFFFF)
+
−      {
+
−        /*
+
−         * For ASN1-BER encoding we must look for the special
+
−         * length 0x80 because it indicates the indefinite
+
−         * length. This needs a special handling with later EOC tags.
+
−         *
+
−         */
+
−        globs->iei_ctx[globs->ccd_recurs_level].EOCPending = TRUE;
+
−        globs->numEOCPending++;
+
−
+
−  #ifdef DEBUG_CCD
+
−        TRACE_CCD (globs, "implicit ASN1 length - EOC is pending");
+
−  #endif
+
−      }
+
−      else
+
−      {
+
−        /*
+
−         * Calculate the max bitpos for this element
+
−         */
+
−        tmp_maxBP = (USHORT) (globs->bitpos + (l*8));
+
−        if (globs->buflen < tmp_maxBP)
+
−        {
+
−          ccd_recordFault (globs, ERR_MSG_LEN, CONTINUE, (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
+
−        }
+
−        else if (globs->maxBitpos < tmp_maxBP)
+
−        {
+
−          ccd_recordFault (globs, ERR_ELEM_LEN, BREAK, (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
+
−        }
+
−        globs->maxBitpos = (USHORT)MINIMUM (globs->buflen, tmp_maxBP);
+
−        tmp_maxBP = globs->maxBitpos;
+
−      }
+
−    }
+
−    else 
+
−    {
+
−      ccd_recordFault (globs, ERR_ELEM_LEN, BREAK, (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
+
−    }
+
−  }
+
−#ifdef DYNAMIC_ARRAYS
+
−  /*
+
−   * Check for pointer types; allocate memory if necessary.
+
−   */
+
−  if ((melem[e_ref].elemType >= 'P' AND melem[e_ref].elemType <= 'R') OR
+
−      (melem[e_ref].elemType >= 'D' AND melem[e_ref].elemType <= 'F')) 
+
−  {
+
−    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
+
−		     );
+
−
+
−    /*
+
−     * 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 endOfComposition;
+
−    }
+
−    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;
+
−  }
+
−  else
+
−  {
+
−    globs->pstructOffs += offset;
+
−  }
+
−#else /* DYNAMIC_ARRAYS */
+
−  globs->pstructOffs += offset;
+
−#endif /* DYNAMIC_ARRAYS */
+
−
+
−
+
−  /*
+
−   * Decode the value. Keep caution with BER encoding of ASN1 integers.
+
−   * All other types can be decoded by a generic function.
+
−   */
+
−  if (asn1 AND melem[e_ref].elemType EQ 'V'
+
−      AND
+
−      melem[e_ref].repType EQ ' '
+
−      AND
+
−      l NEQ 0xFFFF
+
−     )
+
−  {
+
−#ifdef DEBUG_CCD
+
−#ifdef CCD_SYMBOLS
+
−    TRACE_CCD (globs, "BER decoding of ASN.1 integer %s",
+
−               ccddata_get_alias((USHORT) e_ref, 1));
+
−#else
+
−    TRACE_CCD (globs, "BER decoding of ASN.1 integer; e_ref = %d", melem[e_ref].elemRef);
+
−#endif
+
−#endif
+
−
+
−    if (mvar[melem[e_ref].elemRef].cType EQ 'X')
+
−      bf_readBitChunk (l*8, globs);
+
−    else
+
−      bf_readBits (l*8, globs);
+
−  }
+
−  else
+
−  {
+
−    amount = 1;
+
−    if (len_l)
+
−    {
+
−      if (l > 0)
+
−      {
+
−        cdc_decodeElemvalue (e_ref, &amount, globs);
+
−      }
+
−      else
+
−      {
+
−        amount = 0;
+
−      }
+
−    }
+
−    else
+
−    {
+
−      if (melem[e_ref].codingType != CCDTYPE_GSM2_T)
+
−        cdc_decodeElemvalue (e_ref, &amount, globs);
+
−    }
+
−  }
+
−#ifdef DYNAMIC_ARRAYS
+
−  /*
+
−   * Restore globs->pstruct for possible use below
+
−   */
+
−  if (old_pstruct NEQ NULL)
+
−    globs->pstruct     = old_pstruct;
+
−#endif
+
−
+
−  if (asn1 AND globs->numEOCPending AND !bf_endOfBitstream(globs))
+
−  {
+
−    UBYTE T = bf_decodeByteNumber (8, globs);
+
−#ifdef DEBUG_CCD
+
−    TRACE_CCD (globs, "looking for EOC decoding 8 bits T = (%x)", T);
+
−#endif
+
−
+
−    if (T EQ 0)
+
−    {
+
−#ifdef DEBUG_CCD
+
−      TRACE_CCD (globs, "First EOC octet found");
+
−#endif
+
−
+
−      if (globs->iei_ctx[globs->ccd_recurs_level].EOCPending) 
+
−      {
+
−#ifdef DEBUG_CCD
+
−        TRACE_CCD (globs, "End of ASN1 TLV");
+
−#endif
+
−        /*
+
−         * Skip the second EOC octet.
+
−         */
+
−        bf_incBitpos (8, globs);
+
−        globs->iei_ctx[globs->ccd_recurs_level].EOCPending = FALSE;
+
−        globs->numEOCPending--;
+
−      }
+
−      else
+
−      {
+
−        /*
+
−         * The read first EOC octet belongs to an ASN1 TLV of a 
+
−         * higher recursion level. Let it be read and evalauted later 
+
−         * again for that IE.
+
−         */
+
−        bf_setBitpos (globs->bitpos-8, globs);
+
−#ifdef DEBUG_CCD
+
−        TRACE_CCD (globs, "End of higer level ASN1 TLV");
+
−        TRACE_CCD (globs, "Decrementing bitpos by 8 to %d", globs->bitpos);
+
−#endif
+
−        endOfComposition = TRUE;
+
−      }
+
−    }
+
−    else
+
−    {
+
−      if (globs->iei_ctx[globs->ccd_recurs_level].EOCPending)
+
−      {
+
−        /*
+
−         * EOC element is pending but not found.
+
−         */
+
−        ccd_setError (globs, ERR_EOC_TAG_MISSING,
+
−                      BREAK,
+
−                      (USHORT) T,
+
−                      globs->bitpos-8,
+
−                      (USHORT) -1);
+
−
+
−        bf_setBitpos (globs->bitpos-8, globs);
+
−      }
+
−      else
+
−      {
+
−        /*
+
−         * normal TAG leave it in the bitstream
+
−         */
+
−#ifdef DEBUG_CCD
+
−        TRACE_CCD (globs, "Normal TAG - Decrementing bitpos by 8 to %d", globs->bitpos);
+
−#endif
+
−        bf_setBitpos (globs->bitpos-8, globs);
+
−      }
+
−    }
+
−  }
+
−
+
−  if (len_l)
+
−  {
+
−    if (!asn1)
+
−    {
+
−      if (globs->bitpos > tmp_maxBP)
+
−      {
+
−        ccd_recordFault (globs, ERR_ELEM_LEN, CONTINUE, (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
+
−      }
+
−      else
+
−      {
+
−        /*
+
−         * set the bitpos to the end of the LV or TLV element
+
−         */
+
−        bf_setBitpos (tmp_maxBP, globs);
+
−      }
+
−    }
+
−    /*
+
−     * set the maxBitpos to the next octet boundary if the 
+
−     * last non-spare IE does not end at an octet boundary.
+
−     * This is necessary for avoiding an early end of decoding.
+
−     */
+
−/*  
+
−    globs->maxBitpos = globs->buflen;
+
−*/
+
−    globs->maxBitpos = act_maxBP;
+
−  }
+
−
+
−  return endOfComposition;
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/* Attention for RUN_...: static function */
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CDC_COM             |
+
−| STATE   : code                       ROUTINE : cdc_normal_LV_decode|
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : If the parameter lenL is set, this function
+
−            decodes the L-component. After this it decodes
+
−            the element referenced by eRef from the
+
−            bitstream into the C-Structure (globs->pstruct)
+
−            at position globs->pstructOffs. 
+
−            If a repeat value is defined for this element
+
−            this function decodes the V-component multiple and stores
+
−            the values into an array.
+
−*/
+
−
+
−static BOOL cdc_normal_LV_decode (const ULONG  e_ref,
+
−                                  const ULONG  len_l,
+
−                                  T_CCD_Globs *globs)
+
−{
+
−  ULONG  l, repeat, amount, max_rep;
+
−  USHORT act_maxBP, tmp_maxBP; 
+
−  BOOL   is_variable;
+
−  BOOL   endOfComposition = FALSE;
+
−  BOOL   asn1;
+
−  BOOL   length_in_bits;
+
−#ifdef DYNAMIC_ARRAYS
+
−  U8    *old_pstruct = NULL;
+
−#endif  
+
−
+
−  switch (melem[e_ref].codingType)
+
−  {
+
−    case CCDTYPE_GSM1_ASN:
+
−      asn1 = TRUE;
+
−      length_in_bits = FALSE;
+
−      break;
+
−
+
−    case CCDTYPE_GSM7_LV:
+
−      asn1 = FALSE;
+
−      length_in_bits = TRUE;
+
−      break;
+
−
+
−    default:
+
−      asn1 = FALSE;
+
−      length_in_bits = FALSE;
+
−      break;
+
−  }
+
−
+
−  /* 
+
−   * 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, &max_rep, 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
+
−     */
+
−    if (melem[e_ref].optional)
+
−    {
+
−      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 (max_rep > 65535)
+
−        *(ULONG *) (globs->pstruct + globs->pstructOffs++) = repeat;
+
−      else if (max_rep > 255)
+
−        *(USHORT *) (globs->pstruct + globs->pstructOffs++) = (USHORT) repeat;
+
−      else
+
−        globs->pstruct[globs->pstructOffs] = (UBYTE) repeat;
+
−
+
−      globs->pstructOffs++;
+
−    }
+
−  }
+
−
+
−  /*
+
−   * if len_l > 0 read the l-Component out of the bistream.
+
−   */
+
−  if (len_l)
+
−  {
+
−    if( len_l <= (ULONG)(globs->maxBitpos - globs->bitpos) )
+
−    {
+
−      act_maxBP = globs->maxBitpos;
+
−
+
−      l = cdc_decode_L (e_ref, len_l, globs);
+
−
+
−      if (l EQ 0xFFFF)
+
−      {
+
−        /*
+
−         * for ASN1 element coding we must look for the special
+
−         * length 0x80 because it indicates the indefinite
+
−         * length. This needs a special handling with later EOC tags.
+
−         */
+
−        globs->iei_ctx[globs->ccd_recurs_level].EOCPending = TRUE;
+
−
+
−        globs->numEOCPending++;
+
−
+
−  #ifdef DEBUG_CCD
+
−        TRACE_CCD (globs, "implicit ASN1 length - EOC is pending");
+
−  #endif
+
−      }
+
−      else
+
−      {
+
−        /*
+
−         * calculate the max bitpos for this element
+
−         */
+
−        if (!length_in_bits)
+
−          l *= 8;
+
−
+
−        tmp_maxBP = (USHORT) (globs->bitpos + l);
+
−
+
−        if (globs->buflen < tmp_maxBP)
+
−        {
+
−          ccd_recordFault (globs, ERR_MSG_LEN, CONTINUE, (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
+
−        }
+
−        else if (globs->maxBitpos < tmp_maxBP)
+
−        {
+
−          ccd_recordFault (globs, ERR_ELEM_LEN, BREAK, (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
+
−        }
+
−        globs->maxBitpos = (USHORT)MINIMUM (globs->buflen, tmp_maxBP); 
+
−        tmp_maxBP = globs->maxBitpos;
+
−       
+
−        /*
+
−         * for bitfields which appear in TLV or LV elements
+
−         * we must calculate the length (repeat) from the l values
+
−         */
+
−         if (melem[e_ref].repType EQ 'b')
+
−           repeat = l;
+
−      }
+
−    }
+
−    else
+
−    {
+
−      ccd_recordFault (globs, ERR_ELEM_LEN, BREAK, (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
+
−    }
+
−  }
+
−#ifdef DYNAMIC_ARRAYS
+
−  /*
+
−   * MVJ: Dynamic array addition.
+
−   * Check for pointer types; allocate memory if necessary.
+
−   */
+
−  if ((melem[e_ref].elemType >= 'P' AND melem[e_ref].elemType <= 'R') OR
+
−      (melem[e_ref].elemType >= 'D' AND melem[e_ref].elemType <= 'F')) {
+
−    ULONG    cSize, rep;
+
−    U8      *addr;
+
−
+
−    /*
+
−     * Find size to allocate;
+
−     * - Read from mcomp or mvar according to type
+
−     * - Unbounded (0-terminated) ASN1-types are allocated with MAX repeat
+
−     */
+
−    if (globs->iei_ctx[globs->ccd_recurs_level].EOCPending) {
+
−      rep = (ULONG) melem[e_ref].maxRepeat;
+
−    } else {
+
−      rep = repeat;
+
−    }
+
−    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
+
−		     ) * rep;
+
−
+
−    /*
+
−     * 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 endOfComposition;
+
−    }
+
−    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
+
−
+
−  /*
+
−   * Decode the value. Keep caution with BER encoding of ASN1 integers.
+
−   * All other types can be decoded by a generic function.
+
−   */
+
−  if (asn1 AND melem[e_ref].elemType EQ 'V' 
+
−      AND 
+
−      melem[e_ref].repType EQ ' ' 
+
−      AND 
+
−      l NEQ 0xFFFF
+
−     )
+
−  {
+
−#ifdef DEBUG_CCD
+
−#ifdef CCD_SYMBOLS
+
−    TRACE_CCD (globs, "BER decoding of ASN.1 integer %s",
+
−               ccddata_get_alias((USHORT) e_ref, 1));
+
−#else
+
−    TRACE_CCD (globs, "BER decoding of ASN.1 integer; e_ref = %d", melem[e_ref].elemRef);
+
−#endif
+
−#endif
+
−    amount = l;
+
−    if (mvar[melem[e_ref].elemRef].cType EQ 'X')
+
−      bf_readBitChunk (l, globs);
+
−    else
+
−      bf_readBits (l, globs);
+
−  }
+
−  else
+
−  {
+
−    amount = repeat;
+
−    if (len_l)
+
−    {
+
−      if (l > 0)
+
−      {
+
−        cdc_decodeElemvalue (e_ref, &amount, globs);
+
−      }
+
−      else
+
−      {
+
−        amount = 0;
+
−      }
+
−    }
+
−    else
+
−    {
+
−      if (melem[e_ref].codingType != CCDTYPE_GSM2_T)
+
−        cdc_decodeElemvalue (e_ref, &amount, 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 number of decoded elements is not equal to the given
+
−     * 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++;
+
−
+
−    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);
+
−    }
+
−  }
+
−
+
−  if (asn1 AND globs->numEOCPending AND !bf_endOfBitstream(globs))
+
−  {
+
−    UBYTE T = bf_decodeByteNumber (8, globs);
+
−#ifdef DEBUG_CCD
+
−    TRACE_CCD (globs, "looking for EOC decoding 8 bits T = (%x)", T);
+
−#endif
+
−
+
−    if (T EQ 0)
+
−    {
+
−#ifdef DEBUG_CCD
+
−      TRACE_CCD (globs, "First EOC octet found");
+
−#endif
+
−
+
−      if (globs->iei_ctx[globs->ccd_recurs_level].EOCPending) 
+
−      {
+
−#ifdef DEBUG_CCD
+
−        TRACE_CCD (globs, "End of ASN1 TLV");
+
−#endif
+
−        /*
+
−         * Skip the second EOC octet.
+
−         */
+
−        bf_incBitpos (8, globs);
+
−        globs->iei_ctx[globs->ccd_recurs_level].EOCPending = FALSE;
+
−        globs->numEOCPending--;
+
−      }
+
−      else
+
−      {
+
−        /*
+
−         * The read first EOC octet belongs to an ASN1 TLV of a 
+
−         * higher recursion level. Let it be read and evalauted later 
+
−         * again for that IE.
+
−         */
+
−        bf_setBitpos (globs->bitpos-8, globs);
+
−#ifdef DEBUG_CCD
+
−        TRACE_CCD (globs, "End of higer level ASN1 TLV");
+
−        TRACE_CCD (globs, "Decrementing bitpos by 8 to %d", globs->bitpos);
+
−#endif
+
−        endOfComposition = TRUE;
+
−      }
+
−    }
+
−    else
+
−    {
+
−      if (globs->iei_ctx[globs->ccd_recurs_level].EOCPending)
+
−      {
+
−        /*
+
−         * EOC element is pending but not found.
+
−         */
+
−        ccd_setError (globs, ERR_EOC_TAG_MISSING,
+
−                      BREAK,
+
−                      (USHORT) T,
+
−                      globs->bitpos-8,
+
−                      (USHORT) -1);
+
−
+
−        bf_setBitpos (globs->bitpos-8, globs);
+
−      }
+
−      else
+
−      {
+
−        /*
+
−         * normal TAG leave it in the bitstream
+
−         */
+
−#ifdef DEBUG_CCD
+
−        TRACE_CCD (globs, "Normal TAG - Decrementing bitpos by 8 to %d", globs->bitpos);
+
−#endif
+
−        bf_setBitpos (globs->bitpos-8, globs);
+
−      }
+
−    }
+
−  }
+
−
+
−  if (len_l)
+
−  {
+
−    if (!asn1)
+
−    {
+
−      if (globs->bitpos > tmp_maxBP)
+
−      {
+
−        ccd_recordFault (globs, ERR_ELEM_LEN, CONTINUE, (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
+
−      }
+
−      else
+
−      {
+
−        /*
+
−         * set the bitpos to the end of the LV or TLV element
+
−         */
+
−         bf_setBitpos (tmp_maxBP, globs);
+
−      }
+
−    }
+
−
+
−    /*
+
−     * set the maxBitpos to the next octet boundary if the 
+
−     * last non-spare IE does not end at an octet boundary.
+
−     * This is necessary for avoiding an early end of decoding.
+
−     */
+
−/*
+
−    globs->maxBitpos = globs->buflen;
+
−*/
+
−    globs->maxBitpos = act_maxBP;
+
−  }
+
−
+
−  return endOfComposition;
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/* Attention for RUN_...: static function */
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CDC_COM             |
+
−| STATE   : code                       ROUTINE : cdc_skipElem        |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Skip an element referenced by eRef. This function
+
−            perform a decoding of this element, but not into
+
−            the target C-Structure. A dummy C-Structure is used
+
−            instead.
+
−            The complete decoding is necesary, because there is
+
−            no information about the length of this element.
+
−            B.t.w. for mandatory elements with fixed length, we can
+
−            calculate the length, for optional elements or for
+
−            variable sized arrays or bitbuffers it is impossible
+
−            without decoding the entire element.
+
−*/
+
−
+
−static void cdc_skipElem (const ULONG e_ref, const ULONG len_l, T_CCD_Globs *globs)
+
−{
+
−  UBYTE  *ActStructAddr;
+
−  U32    ActStructOffs;
+
−
+
−#ifdef DEBUG_CCD
+
−  TRACE_CCD (globs, "skipping element %d",
+
−             melem[e_ref].elemRef);
+
−#endif
+
−
+
−  ActStructAddr = globs->pstruct; 
+
−  ActStructOffs = globs->pstructOffs; 
+
−
+
−  globs->pstruct     = dummy; 
+
−  globs->pstructOffs = 0;
+
−  
+
−  cdc_tagged_LV_decode (e_ref, 1, len_l, globs);
+
−
+
−  globs->pstruct     = ActStructAddr; 
+
−  globs->pstructOffs = ActStructOffs; 
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CDC_COM             |
+
−| STATE   : code                       ROUTINE : cdc_tlv_decode      |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Decoding of the T-components of T TV and TLV typed
+
−            information elements. The len determines the
+
−            length of the T component. This function returns the
+
−            index (reference) of the rigth element. If the
+
−            iei is not known in this composition (msg or submsg)
+
−            an error handling is done and NO_REF is returned. 
+
−
+
−*/
+
−
+
−SHORT cdc_tlv_decode (const ULONG c_ref,
+
−                      const ULONG e_ref,
+
−                      const T_TLV_SORT  *tlv_inf,
+
−                            T_CCD_Globs *globs)
+
−{
+
−  ULONG  repeat, max_rep;
+
−  ULONG  ie_amount, l, len_l, len_t, t;
+
−  BOOL   is_variable, nonTagged, limitSearch=FALSE;
+
−  UBYTE  CR=FALSE;
+
−  SHORT  IdxOffset = 0;
+
−  int    ieTableIdx;
+
−  BOOL   asn1, non_std_tag;
+
−  SHORT  ret;
+
−  ULONG  cix_ref, num_prolog_steps, prolog_step_ref;
+
−  /* .../src/linux/include/asm/current.h defines a macro 'current' */
+
−  T_UNKNOWN_TAG *first, *currentTag;
+
−
+
−
+
−  /*
+
−   * Set the flag for the type of extension which is to expect
+
−   * at the end of the message.
+
−   */
+
−  globs->SeekTLVExt = TRUE;
+
−
+
−  /* Set ref number for calcidx table. */
+
−  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;
+
−
+
−  len_t = 8; 
+
−  switch (melem[e_ref].codingType)
+
−  {
+
−    case CCDTYPE_GSM1_ASN:
+
−      asn1        = TRUE;
+
−      non_std_tag = FALSE;
+
−      len_l        = 8;
+
−      break;
+
−
+
−    case CCDTYPE_GSM5_TV:
+
−    case CCDTYPE_GSM5_TLV:
+
−      non_std_tag = TRUE;
+
−      asn1        = FALSE;
+
−      len_l        = 8;
+
−      break;
+
−
+
−    case CCDTYPE_GSM6_TLV:
+
−      non_std_tag = FALSE;
+
−      asn1        = FALSE;
+
−      len_l        = 16;
+
−      break;
+
−
+
−    case CCDTYPE_GSM7_LV:
+
−      non_std_tag = FALSE;
+
−      asn1        = FALSE;
+
−      len_l        = 7;
+
−      break;
+
−
+
−    default:
+
−      asn1        = FALSE;
+
−      non_std_tag = FALSE;
+
−      len_l        = 8;
+
−      break;
+
−  }
+
−
+
−  /*
+
−   * 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 (tlv_inf->gotTag)
+
−  {
+
−    /* 
+
−     * tagged element
+
−     */
+
−    len_t = 8;
+
−    /*
+
−     * initialize the iei_table for each new message
+
−     */
+
−    if (globs->ccd_recurs_level NEQ globs->last_level)
+
−    {
+
−      cdc_init_table (c_ref, globs);
+
−      globs->TagPending    = FALSE;
+
−      globs->SequenceError = FALSE;
+
−      globs->last_level    = globs->ccd_recurs_level;
+
−    }
+
−
+
−    /*
+
−     * calculate the index into the ieTable for this element
+
−     */
+
−    ieTableIdx = (int)(e_ref - globs->iei_ctx[globs->ccd_recurs_level].melemStart);
+
−
+
−    if (globs->TagPending)
+
−    {
+
−      /*
+
−       * if we previously read a t value and does not processed it
+
−       * get this pending tag.
+
−       */
+
−      t = (ULONG) globs->PendingTag;
+
−      globs->TagPending = FALSE;
+
−    }
+
−    else
+
−    {
+
−      /*
+
−       * read the information element identifier out of the bitstream.
+
−       * If the first bit (MSBit) of the t-component is set, it is
+
−       * a Tag of a TYPE1 or TYPE2 element.
+
−       */
+
−      
+
−      t = (ULONG) bf_decodeByteNumber (8, globs);
+
−
+
−
+
−
+
−      if (!asn1 AND !non_std_tag AND (t & 0x80) EQ 0x80 AND (t & 0xA0) NEQ 0xA0)
+
−      {
+
−        ULONG Tag4 = t & 0xf0;        
+
−        /*
+
−         * MSBit is set. We have to check if the Tag value can
+
−         * be found as a 4 bit or 8 bit value in the IEI-table.
+
−         */
+
−        if (cdc_search_table (ieTableIdx, Tag4, limitSearch, &nonTagged, globs) NEQ -127) 
+
−        {
+
−          /*
+
−           * Tag found as a 4 bit value. Decrement the readpointer
+
−           * of the bitstream by 4, because we have read out 4 bits
+
−           * to much.
+
−           */
+
−          bf_setBitpos (globs->bitpos-4, globs);
+
−          t = Tag4;
+
−          len_t =4;
+
−#ifdef DEBUG_CCD
+
−          TRACE_CCD (globs, "4 bit Tag decrementing bitpos by 4 to %d", globs->bitpos);
+
−#endif
+
−        }
+
−      }
+
−    }
+
−
+
−#ifdef DEBUG_CCD
+
−    TRACE_CCD (globs, "reading t = 0x%X", t);
+
−#endif
+
−
+
−    if (melem[e_ref].codingType EQ CCDTYPE_GSM5_TLV)
+
−    {
+
−      limitSearch = TRUE;  
+
−      CR = (UBYTE) (((t & 0x80) EQ 0x80) ? TRUE : FALSE);
+
−      t &= 0x7f;
+
−    }
+
−
+
−
+
−    if (asn1 AND t EQ 0x00)
+
−    {
+
−      /*
+
−       * This is for ASN1 element coding the special
+
−       * End Of Component Tag (EOC). The following length must be zero.
+
−       */
+
−      bf_setBitpos (globs->bitpos-8, globs);
+
−
+
−#ifdef DEBUG_CCD
+
−      TRACE_CCD (globs, "ASN1 End of Component found belongs to higher TLV");
+
−      TRACE_CCD (globs, "leaving this level and decrementing bitpos by 8 to %d", globs->bitpos);
+
−#endif
+
−
+
−      return END_OF_COMPOSITION; /* skip the remaining elements in this level */
+
−    } /* asn1 and EOC */
+
−    else
+
−    {
+
−      if ((IdxOffset = (SHORT) cdc_search_table (ieTableIdx, t, limitSearch, &nonTagged, globs)) == -127)
+
−      {
+
−        /*
+
−         * t (iei) not defined in this composition (msg or submsg)
+
−         */
+
−        if (asn1)
+
−        {
+
−          if (melem[mcomp[c_ref].componentRef + mcomp[c_ref].numOfComponents -1].codingType == CCDTYPE_GSM5_V)
+
−          {
+
−            /* Restore the old bitposition (before the 'TAG') and return
+
−             * IdxOffset to jump to last element of the composition.
+
−             * The coding type of this elements is CCDTYPE_GSM5_V
+
−             */
+
−            bf_setBitpos (globs->bitpos-8, globs);
+
−            IdxOffset = (SHORT)(mcomp[c_ref].numOfComponents - ieTableIdx - 1);
+
−            return (IdxOffset);
+
−          }
+
−
+
−          /*
+
−           * for recursive ASN.1 structs it is possible that the foreign
+
−           * tag belongs to a upper level composition of element.
+
−           *
+
−           * 
+
−           * Restore the old bitposition (before the TAG) and return
+
−           * END_OF_COMPOSITION to leave this composition level
+
−           */
+
−          bf_setBitpos (globs->bitpos-8, globs);
+
−#ifdef DEBUG_CCD
+
−          TRACE_CCD (globs, "Unknown Tag. It may belong to upper ASN.1 comp -> dec. bitpos by 8 to %d", globs->bitpos);
+
−#endif
+
−
+
−          return END_OF_COMPOSITION; /* skip the remaining elements in this level */
+
−        }
+
−        else if (nonTagged)
+
−        {
+
−          U16 actBitpos;
+
−          actBitpos = globs->bitpos-8;
+
−
+
−          if (melem[mcomp[c_ref].componentRef + mcomp[c_ref].numOfComponents -1].codingType == CCDTYPE_GSM5_V &&
+
−              melem[e_ref].codingType EQ CCDTYPE_GSM5_TLV)
+
−          {
+
−#if defined (CCD_TEST)
+
−            currentTag = (T_UNKNOWN_TAG *) malloc(sizeof(T_UNKNOWN_TAG));
+
−#else
+
−            currentTag = (T_UNKNOWN_TAG *) D_ALLOC(sizeof(T_UNKNOWN_TAG));
+
−#endif
+
−            first = currentTag;
+
−            currentTag->bitpos = globs->bitpos-8;
+
−            currentTag->errCode = ERR_NO_MORE_ERROR;
+
−            currentTag->next = NULL;
+
−
+
−            /* unknown GSM Type TLV -> skip 'l' bytes */
+
−            /* at least 8 bits must remain for following expeceted tagged element */
+
−            while (globs->maxBitpos - 8 - globs->bitpos >= 8)
+
−            {
+
−              currentTag->bitpos = globs->bitpos-8;
+
−              currentTag->tag    = (UBYTE) t;
+
−
+
−              /* 
+
−               * Expecting a CCDTYPE_GSM5_TLV type we get an unknown tag with MSB set.
+
−               * Store bitpos and t for the application (SAT) for the handling of 
+
−               * comprehension required elements.
+
−               */
+
−
+
−              if (CR)
+
−              { // save (ERR_COMPREH_REQUIRED; globs->bitpos-len_t) 
+
−                currentTag->errCode =  ERR_COMPREH_REQUIRED;
+
−              }
+
−              else 
+
−              { // save (ERR_IE_NOT_EXPECTED; globs->bitpos-len_t) 
+
−                currentTag->errCode =  ERR_IE_NOT_EXPECTED;
+
−              }
+
−
+
−              l = (ULONG) bf_decodeByteNumber (8, globs);
+
−              bf_incBitpos ((l << 3) , globs);
+
−              
+
−              t = (ULONG) bf_decodeByteNumber (8, globs);
+
−
+
−              limitSearch = TRUE;  
+
−              CR = (UBYTE) (((t & 0x80) EQ 0x80) ? TRUE : FALSE);
+
−              t &= 0x7f;
+
−
+
−              if (cdc_search_table (ieTableIdx, t, limitSearch, &nonTagged, globs) != -127)
+
−              {
+
−                bf_setBitpos (globs->bitpos-8, globs);
+
−                // set all ccd Errors
+
−                do 
+
−                {
+
−                  currentTag = first;
+
−                  ccd_setError (globs, currentTag->errCode,
+
−                                CONTINUE,
+
−                                (USHORT) currentTag->tag,
+
−                                currentTag->bitpos,
+
−                                (USHORT) -1);
+
−                  first = currentTag->next;
+
−#if defined (CCD_TEST)
+
−                  free(currentTag);
+
−#else                
+
−                  D_FREE(currentTag);
+
−#endif               
+
−                }
+
−                while (first != NULL );
+
−
+
−                return 0;
+
−              }
+
−              else
+
−              {                
+
−#if defined (CCD_TEST)
+
−                currentTag->next = (T_UNKNOWN_TAG *) malloc(sizeof(T_UNKNOWN_TAG));
+
−#else                
+
−                currentTag->next = (T_UNKNOWN_TAG *) D_ALLOC(sizeof(T_UNKNOWN_TAG));
+
−#endif               
+
−                currentTag = currentTag->next;
+
−                currentTag->next = NULL;
+
−              }
+
−            }
+
−
+
−            do
+
−            {
+
−              currentTag = first;
+
−              first = currentTag->next;
+
−#if defined (CCD_TEST)
+
−              free(currentTag);
+
−#else                
+
−              D_FREE(currentTag);
+
−#endif               
+
−            }
+
−            while (first != NULL );
+
−          }
+
−
+
−            /*
+
−             * a non tagged element is possible in the message. If the tag 
+
−             * can not be found, the tag may be the beginning of the non  tagged
+
−             * element. E.g. rest octetts in sysinfo 4
+
−             * 
+
−             * Restore the old bitposition (before the TAG) and return 1 to 
+
−             * go to the next element.
+
−             */
+
−          
+
−          bf_setBitpos (actBitpos, globs);
+
−#ifdef DEBUG_CCD
+
−          TRACE_CCD (globs, "Unknown Tag but mand. IE possible -> dec. bitpos by 8 to %d", globs->bitpos);
+
−#endif
+
−
+
−          return 1;
+
−        }
+
−
+
−
+
−        /*
+
−         * Otherwise look if it is a type 1,2 or 4 Element
+
−         */
+
−        if ((t & 0x80) EQ 0x80)
+
−        {
+
−          /* MSBit set -> GSM Type 1 or Type2 -> skip 1 byte */
+
−          /* position already incremented by decoding the TAG value */
+
−        }
+
−        /* Just another reason for getting IdxOffset equal to 0. */
+
−        else if (globs->ccd_recurs_level >= MAX_RECURSIONS_PER_MSG)
+
−        {
+
−          ccd_setError (globs, ERR_INTERNAL_ERROR, BREAK, (USHORT) -1);
+
−        }
+
−        else
+
−        {
+
−          /* 
+
−           * Expecting a CCDTYPE_GSM5_TLV type we get an unknown tag with MSB set.
+
−           * Store bitpos and t for the application (SAT) for the handling of 
+
−           * comprehension required elements.
+
−           */
+
−          if (CR)
+
−          {
+
−            ccd_setError (globs, ERR_COMPREH_REQUIRED,
+
−                          CONTINUE,
+
−                          (USHORT) t,
+
−                          (USHORT) globs->bitpos-len_t,
+
−                          (USHORT) -1);
+
−          }
+
−          /* 
+
−           * Expecting other types than CCDTYPE_GSM5_TLV we get an unknown tag with
+
−           * comprehension required bits (5, 6, 7 and 8 of IEI according to GSM0407)
+
−           * are set to zero.
+
−           * Store bitpos and t for the application for the handling of comprehension
+
−           * required elements.
+
−           */
+
−          else if ((t & 0x70) EQ 0 AND
+
−                    melem[e_ref].codingType NEQ CCDTYPE_GSM5_TLV)
+
−          {
+
−            ccd_setError (globs, ERR_COMPREH_REQUIRED,
+
−                          CONTINUE,
+
−                          (USHORT) t,
+
−                          (USHORT) globs->bitpos-len_t,
+
−                          (USHORT) -1);
+
−          }
+
−          /* 
+
−           * We get an unknown tag and any sort of comprehension required flag is set.
+
−           * Store bitpos and t for the application
+
−           */
+
−          else 
+
−          {
+
−            ccd_setError (globs, ERR_IE_NOT_EXPECTED,
+
−                          CONTINUE,
+
−                          (USHORT) t,
+
−                          (USHORT) globs->bitpos-len_t,
+
−                          (USHORT) -1);
+
−          }
+
−          
+
−          /* MSBit cleared -> GSM Type TLV -> skip 'l' bytes */
+
−          if (globs->maxBitpos - globs->bitpos >= 8)
+
−          {
+
−            l = (ULONG) bf_decodeByteNumber (8, globs);
+
−            bf_incBitpos ((l << 3) , globs);
+
−          }
+
−          else
+
−          {
+
−            ccd_recordFault (globs,
+
−                             ERR_ELEM_LEN,
+
−                             BREAK,
+
−                             (USHORT) e_ref,
+
−                             globs->pstruct + globs->pstructOffs);
+
−          }
+
−        }
+
−
+
−        /*
+
−         * return 0 -> that means try it again with this actual element
+
−         * referenced by e_ref
+
−         */
+
−        return 0;
+
−      } /* tag not found */
+
−      else
+
−      {
+
−        T_IEI_TABLE *iei_tbl = &globs->iei_ctx[globs->ccd_recurs_level].iei_table[ieTableIdx];
+
−        /*
+
−         * element definition for this iei found
+
−         */
+
−        if (IdxOffset NEQ 0)
+
−        {
+
−          /*
+
−           * found index differs from the actual index
+
−           */
+
−          globs->TagPending    = TRUE;
+
−          globs->PendingTag    = (UBYTE) t;
+
−
+
−          if (!asn1 AND IdxOffset < 0)
+
−          {
+
−            /*
+
−             * found an element in wrong sequence
+
−             * (for ASN1 elements the sequence order is not relevant)
+
−             */
+
−            ccd_setError (globs, ERR_IE_SEQUENCE,
+
−                          (UBYTE) ((asn1) ? BREAK : CONTINUE),
+
−                          (USHORT) t,
+
−                          (USHORT) globs->bitpos-len_t,
+
−                          (USHORT) -1);
+
−
+
−            globs->SequenceError = TRUE;
+
−          }
+
−          if (globs->SequenceError)
+
−          {
+
−            globs->RefBeforeError = (USHORT) e_ref;
+
−          }
+
−          if (asn1) 
+
−          {
+
−            globs->iei_ctx[globs->ccd_recurs_level].countSkipped += IdxOffset;
+
−          }
+
−          /*
+
−           * skip to the found element
+
−           */
+
−          return (IdxOffset);
+
−        }
+
−        else
+
−        {
+
−          globs->iei_ctx[globs->ccd_recurs_level].melemLast = (USHORT) e_ref;
+
−
+
−          if (iei_tbl->act_amount == 0)
+
−          {
+
−            /*
+
−             * first apearance of this iei
+
−             * calculate the upper and lower boundaries and the
+
−             * facility of multiple appearance of this tagged element
+
−             * in the bitstream.
+
−             */
+
−
+
−            /*
+
−             * The element is repeatable. There are three kinds of 
+
−             * repeat definitions valid for standard elements:
+
−             *  [5]    - The element is repeated 5 times.
+
−             *  [0..5] - The element is repeated 0 to 5 times.
+
−             *  [a..5] - The element is repeated "the value of a" times.
+
−             *
+
−             * For tagged elements the following processing is defined:
+
−             *
+
−             *  [5]    - The t-Component is decoded
+
−             *           (maybe the l-Component too (if defined one).
+
−             *           After this the V-component of the element
+
−             *           is decoded 5 times.
+
−             *
+
−             *  [0..5] - The t- and maybe the l-Component are decoded.
+
−             *           After this one V-Component is decoded and it
+
−             *           is stored as an array entry into
+
−             *           the target C-Structure. In this case the
+
−             *           parameter ieIndex gives the index into
+
−             *           this array, where the element has to
+
−             *           be written into.
+
−             *
+
−             *  [a..5] - The t- and maybe the l-Component are decoded.            
+
−             *           After this one V-Component is decoded
+
−             *           "a" times and is stored into the C-Structure
+
−             *           as an array.
+
−             *           
+
−             */
+
−            switch (melem[e_ref+IdxOffset].repType)
+
−            {
+
−              case 'i':
+
−                /* 
+
−                 * multiapearance of this element. The V-component is 
+
−                 * repeated once
+
−                 */
+
−                is_variable = ccd_calculateRep (e_ref+IdxOffset,
+
−                                  &repeat,
+
−                                  &max_rep,
+
−                                  globs);
+
−
+
−                iei_tbl->max_amount = (UBYTE) max_rep;
+
−                iei_tbl->multiple   = TRUE;
+
−                break;
+
−
+
−              case 'v':
+
−              case 'b':
+
−              default:
+
−                /* 
+
−                 * if this element is repeatable, and the number of
+
−                 * repeats depends on another element, the valid amount
+
−                 * of this element is 1 and the V-component will be
+
−                 * repeated.
+
−                 */
+
−                iei_tbl->max_amount = 1;
+
−                iei_tbl->multiple   = FALSE;
+
−                break;
+
−            }
+
−            iei_tbl->act_amount = 1;
+
−          }
+
−
+
−          if (iei_tbl->act_amount <= iei_tbl->max_amount)
+
−          {
+
−            /*
+
−             * process only the max_amount appearances of each element.
+
−             * All additional IEs are ignored.
+
−             */
+
−            ie_amount = (ULONG)(iei_tbl->act_amount)++;
+
−          }
+
−          else
+
−          {
+
−            if (asn1)
+
−            {
+
−              /* For ASN1 elements the sequence order is not relevant.
+
−               * It is possible that the tag belongs to an upper level 
+
−               * composition of elements. 
+
−               * Restore the old bitposition (before the TAG) and return
+
−               * END_OF_COMPOSITION to leave this composition level
+
−               */
+
−              bf_setBitpos (globs->bitpos-8, globs);
+
−#ifdef DEBUG_CCD
+
−          TRACE_CCD (globs, "Tag may belong to upper ASN.1 comp -> dec. bitpos by 8 to %d", globs->bitpos);
+
−#endif
+
−
+
−              return END_OF_COMPOSITION; /* skip the remaining elements in this level */
+
−            }
+
−            else
+
−            {
+
−              ie_amount = 0;
+
−              ccd_setError (globs, ERR_MAX_IE_EXCEED,
+
−                            CONTINUE,
+
−                            (USHORT) t,
+
−                            (USHORT) globs->bitpos-len_t,
+
−                            (USHORT) -1);
+
−            }
+
−          }
+
−
+
−          /*
+
−           * The t-component matches with the defined identifier for
+
−           * the actual element definition (e_ref).
+
−           */
+
−
+
−          if (globs->SequenceError)
+
−          {
+
−            globs->SequenceError = FALSE;
+
−
+
−            if (asn1)
+
−            {
+
−              /* For ASN1 elements the sequence order is not relevant.
+
−               * It is possible that the tag belongs to an upper level 
+
−               * composition of elements. 
+
−               * Restore the old bitposition (before the TAG) and return
+
−               * END_OF_COMPOSITION to leave this composition level
+
−               */
+
−              bf_setBitpos (globs->bitpos-8, globs);
+
−#ifdef DEBUG_CCD
+
−          TRACE_CCD (globs, "Tag may belong to upper ASN.1 comp -> dec. bitpos by 8 to %d", globs->bitpos);
+
−#endif
+
−
+
−              return END_OF_COMPOSITION; /* skip the remaining elements in this level */
+
−            }
+
−            else
+
−            {
+
−              /* found an element in wrong sequence */
+
−              
+
−              cdc_skipElem (e_ref, (tlv_inf->gotLen ? len_l:0), globs);
+
−              return (SHORT)(globs->RefBeforeError - e_ref);
+
−            }
+
−          }
+
−
+
−          /* 
+
−           * if this element is conditional, check the condition
+
−           */
+
−          if (calcidx[cix_ref].numCondCalcs NEQ 0
+
−            AND ! ccd_conditionOK (e_ref, globs))
+
−          {
+
−            /*
+
−             * if the condition for this element is not valid
+
−             * but this element appears in the message, generate 
+
−             * an error and skip the element
+
−             */
+
−            ccd_setError (globs, ERR_IE_NOT_EXPECTED,
+
−                          CONTINUE,
+
−                          (USHORT) t,
+
−                          (USHORT) globs->bitpos-len_t,
+
−                          (USHORT) -1);
+
−
+
−            cdc_skipElem (e_ref, (tlv_inf->gotLen ? len_l:0), globs);
+
−
+
−            return 0;
+
−          }
+
−
+
−          /*
+
−           * check for a valid index
+
−           */
+
−          if (ie_amount EQ 0)
+
−          {
+
−            /*
+
−             * The max number of repeats are reached
+
−             * In this case we must skip this element.
+
−             */
+
−            cdc_skipElem (e_ref, (tlv_inf->gotLen ? len_l:0), globs);
+
−
+
−            return 0;
+
−          }
+
−
+
−     
+
−          if (iei_tbl->multiple)
+
−          {
+
−            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;
+
−            }
+
−            ret = cdc_tagged_LV_decode (e_ref, ie_amount,
+
−                                       (tlv_inf->gotLen ? len_l:0), globs);
+
−          }
+
−          else
+
−          {
+
−            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;
+
−            }
+
−            ret = cdc_normal_LV_decode (e_ref, 
+
−                                       (tlv_inf->gotLen ? len_l:0), globs);
+
−          }
+
−          globs->SeekTLVExt = TRUE;
+
−          iei_tbl->exhausted  = TRUE;
+
−
+
−          if (ret)
+
−            return END_OF_COMPOSITION;
+
−
+
−          /*
+
−           * if more then one IE of this type are allowed, a ret of 0
+
−           * indicates the calling function (ccd_decodeComposition())
+
−           * to leave the pointer to the actual element definition on
+
−           * this element. If the value of ret is greater then 0 the
+
−           * calling function will increment the pointer by the value
+
−           * of ret.
+
−           * cdc_T_decode() has found the expected element definition.
+
−           * Go to the next definition or stay at this definition,
+
−           * if the occurance of this element is more than one. 
+
−           */
+
−          if (iei_tbl->act_amount > iei_tbl->max_amount)
+
−          {
+
−            iei_tbl->act_amount = 0;
+
−          }
+
−          if (iei_tbl->max_amount > 1)
+
−          {
+
−            return (0);
+
−          }
+
−          else 
+
−          {
+
−            if (globs->iei_ctx[globs->ccd_recurs_level].countSkipped)
+
−            {
+
−              ret = (-1) * (globs->iei_ctx[globs->ccd_recurs_level].countSkipped);
+
−              (globs->iei_ctx[globs->ccd_recurs_level].countSkipped) = 0;
+
−              return (ret);
+
−            }
+
−            else 
+
−            {
+
−              return (1);
+
−            }
+
−          }
+
−        } /* IdxOffset == 0 */
+
−      } /* tag found */
+
−    }  /* no asn1, no EOC */
+
−  } /* got tag */
+
−  else
+
−  {
+
−    /* 
+
−     * element has no t-component, process the l- and V-components
+
−     */
+
−    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;
+
−    }
+
−    ret = cdc_normal_LV_decode (e_ref, len_l, globs) ? END_OF_COMPOSITION : 1;
+
−    globs->SeekTLVExt = TRUE;
+
−    return ret;
+
−  }
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CDC_COM             |
+
−| STATE   : code                       ROUTINE : cdc_tlv_encode      |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : if T_len > 0 this function encodes the T-Component of
+
−            this element. If L_len > 0 it encodes the number
+
−            of bytes uses for this element. After all the function
+
−            encodes the V-component referenced by eRef from the
+
−            C-Structure (globs->pstruct) at position globs->pstructOffs
+
−            into the bitstream.
+
−
+
−*/
+
−
+
−void cdc_tlv_encode  (const ULONG  e_ref,
+
−                            UBYTE  lenT,
+
−                            UBYTE  lenL,
+
−                            T_CCD_Globs *globs)
+
−{
+
−  ULONG  posL=0, t_repeat, v_repeat, repeat;
+
−  ULONG  cSize, startOffset=0;
+
−  BOOL   multAppear;
+
−  U8     *old_pstruct = NULL;
+
−  ULONG  i;
+
−  ULONG  cix_ref, num_prolog_steps, prolog_step_ref;
+
−
+
−  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;
+
−
+
−  /*
+
−   * If this element have a defined Prolog,
+
−   * we have to process it before decoding the bit stream.
+
−   */
+
−  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 offset into the C-structure for this element.
+
−     * 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 ( ! cdc_isPresent(e_ref, globs) )
+
−      return;
+
−
+
−    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++;
+
−
+
−      multAppear = (melem[e_ref].repType EQ 'i');
+
−    }
+
−    else
+
−    {
+
−      /*
+
−       * Field of constant length: repType EQ 'c'  
+
−       * or bit-field allocated with 
+
−       * given maximum length: repType EQ 'b' (often cType='X')
+
−       */
+
−      repeat = (ULONG)((melem[e_ref].repType EQ 'c' 
+
−                         OR melem[e_ref].repType EQ 'b')
+
−                        ? melem[e_ref].maxRepeat 
+
−                        : 1 );
+
−      multAppear = FALSE;
+
−    }
+
−
+
−    /*
+
−     * Perform pointer dereference for pointer types.
+
−     * Also, check optionality for these types.
+
−     */
+
−#ifdef DYNAMIC_ARRAYS
+
−    if ((melem[e_ref].elemType >= 'P' AND melem[e_ref].elemType <= 'R') OR
+
−	(melem[e_ref].elemType >= 'D' AND melem[e_ref].elemType <= 'F')) 
+
−    {
+
−      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;
+
−      }
+
−
+
−      /*
+
−       * 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
+
−
+
−    /*
+
−     * 20010621 MVJ: Dynamic array addition.
+
−     * Types 'R' and 'F' point to base types (just as type 'V') and
+
−     * read sizes from the same table.
+
−     */
+
−    cSize = (ULONG)((melem[e_ref].elemType EQ 'V'
+
−#ifdef DYNAMIC_ARRAYS
+
−                      OR melem[e_ref].elemType EQ 'R'
+
−                      OR melem[e_ref].elemType EQ 'F'
+
−#endif
+
−                     ) ? mvar[melem[e_ref].elemRef].cSize
+
−                     : mcomp[melem[e_ref].elemRef].cSize
+
−                     );
+
−
+
−    startOffset = globs->pstructOffs;
+
−  }
+
−  else
+
−  {
+
−    repeat = (ULONG)((melem[e_ref].repType EQ 'c') 
+
−                      ? melem[e_ref].maxRepeat
+
−                      : 1);
+
−
+
−    multAppear = FALSE;
+
−
+
−    cSize = 0;
+
−  }
+
−
+
−  if (multAppear AND lenT)
+
−  {
+
−    /*
+
−     * multiple appearance of the repeated element is coded as 
+
−     * TLV0 TLV1 TLV2 ....
+
−     */
+
−    t_repeat = repeat;
+
−    v_repeat = 1;
+
−  }
+
−  else
+
−  {
+
−    t_repeat = 1;
+
−    v_repeat = repeat;
+
−  }
+
−
+
−  /*
+
−   * single appearance of the repeated element is coded as 
+
−   * TLV0V1V2V3 ....
+
−   */
+
−
+
−  for (i=0; i < t_repeat; i++)
+
−  {
+
−    if (lenT)
+
−    {
+
−      /*
+
−       * encode the T-component
+
−       */
+
−      bf_codeByteNumber (lenT, (UBYTE) melem[e_ref].ident, globs);
+
−#ifdef DEBUG_CCD
+
−      TRACE_CCD (globs, "encoding %d bits T-value (%x)", lenT, melem[e_ref].ident);
+
−#endif
+
−    }
+
−
+
−    /*
+
−     * if lenL > 0 remember the position of the L-component, because
+
−     * we know it after encoding the entire element. for GSM5TLV elements
+
−     * it could be necessary to use 2 bytes for the length information.
+
−     */
+
−    if (lenL)
+
−    {
+
−      posL = (ULONG) globs->bitpos;
+
−      bf_incBitpos (lenL, globs);
+
−#ifdef DEBUG_CCD
+
−      TRACE_CCD (globs, "skipping %d bits for L-value at byte %d.%d", lenL, globs->bytepos, globs->byteoffs);
+
−#endif
+
−    }
+
−
+
−    if (cSize)
+
−    {
+
−      /*
+
−       * calculate the offset if it is not a spare
+
−       */
+
−      globs->pstructOffs = (ULONG)(startOffset + (i * cSize));
+
−    }
+
−
+
−    /*
+
−     * Encode the value. Keep caution with BER encoding of ASN1 integers.
+
−     * All other types can be encoded by a generic function.
+
−     */
+
−    if (melem[e_ref].codingType EQ CCDTYPE_GSM1_ASN
+
−        AND 
+
−        melem[e_ref].elemType EQ 'V'
+
−        AND melem[e_ref].repType EQ ' '
+
−       )
+
−    {
+
−#ifdef DEBUG_CCD
+
−#ifdef CCD_SYMBOLS
+
−      TRACE_CCD (globs, "BER encoding of ASN.1 integer %s",
+
−               ccddata_get_alias((USHORT) e_ref, 1));
+
−#else
+
−      TRACE_CCD (globs, "BER encoding of ASN.1 integer; e_ref= %d", melem[e_ref].elemRef);
+
−#endif
+
−#endif
+
−
+
−      switch (mvar[melem[e_ref].elemRef].cType)
+
−      {
+
−        case 'B': bf_writeBits (8, globs);
+
−          break;
+
−        case 'S':
+
−        {
+
−          if (*(U16 *) (globs->pstruct+globs->pstructOffs) <= (U16)0xFF)
+
−            bf_writeBits (8, globs);
+
−          else
+
−            bf_writeBits (16, globs);
+
−        }
+
−          break;
+
−        case 'L': 
+
−        {          
+
−          U32 tmpVal= *(U32 *) (globs->pstruct+globs->pstructOffs);
+
−        
+
−          if ( tmpVal <= (U32)0xFF)
+
−            bf_writeBits (8, globs);
+
−          else if ( tmpVal <= (U32)0xFFFF)
+
−            bf_writeBits (16, globs);
+
−          else if ( tmpVal <= (U32)0xFFFFFF)
+
−            bf_writeBits (24, globs);
+
−          else
+
−            bf_writeBits (32, globs);
+
−        }
+
−          break;
+
−        case 'X': 
+
−        {   
+
−          U16 ValLen= *(U16 *) (globs->pstruct+globs->pstructOffs);
+
−          
+
−          if ( mvar[melem[e_ref].elemRef].bSize >= ValLen)
+
−            bf_writeBitChunk (ValLen, globs);
+
−          else
+
−          {
+
−#ifdef DEBUG_CCD
+
−            TRACE_CCD (globs, "value length (%d) exceeds defined bSize!", ValLen);
+
−#endif
+
−          }
+
−
+
−        }
+
−          break;
+
−      }
+
−    }
+
−    else
+
−    {
+
−      cdc_encodeElemvalue (e_ref, v_repeat, globs);
+
−    }
+
−
+
−    /*
+
−     * calculate the bitlen if it is an TLV element and write the
+
−     * L-value.
+
−     */
+
−
+
−    if (lenL)
+
−    {
+
−      switch (melem[e_ref].codingType)
+
−      {
+
−        case CCDTYPE_GSM5_TLV:
+
−        {
+
−          USHORT L = (((USHORT)((globs->bitpos - posL)-lenL)+7) >> 3);
+
−
+
−
+
−#ifdef DEBUG_CCD
+
−          TRACE_CCD (globs, "recoding the 8 bit L-value (%d)", L);
+
−#endif
+
−
+
−          if (L > 127)
+
−          {
+
−            /*
+
−             * if the length is > 127 we code the first byte to
+
−             * 0x81, shift the whole stuff rightwise by 8 and 
+
−             * encode the length in the next byte (16 bits for L)
+
−             */
+
−            bf_rShift8Bit ((USHORT) (posL+8), (USHORT) (L<<3), globs);
+
−            bf_incBitpos (8, globs);
+
−            bf_recodeByteNumber ((USHORT) posL, lenL, (UBYTE) 0x81, globs);
+
−            bf_recodeByteNumber ((USHORT) (posL+8), lenL, (UBYTE) L, globs);
+
−            /*
+
−             * set the bitpos to a 8 bit aligned position
+
−             * corresponding the L value
+
−             */
+
−            bf_setBitpos (posL+(L*8)+16, globs);
+
−          }
+
−          else
+
−          {
+
−            bf_recodeByteNumber ((USHORT) posL, lenL, (UBYTE) L, globs);
+
−            /*
+
−             * set the bitpos to a 8 bit aligned position
+
−             * corresponding the L value
+
−             */
+
−            bf_setBitpos (posL+(L*8)+8, globs);
+
−          }
+
−          break;
+
−        }
+
−
+
−        case CCDTYPE_GSM6_TLV:
+
−        {
+
−          USHORT L = ((USHORT)(((globs->bitpos - posL)-lenL)+7) >> 3);
+
−
+
−#ifdef DEBUG_CCD
+
−          TRACE_CCD (globs, "recoding the 16 bit L-value (%d)", L);
+
−#endif
+
−          bf_recodeShortNumber ((USHORT)posL, lenL, L, globs);
+
−          /*
+
−           * set the bitpos to a 8 bit aligned position
+
−           * corresponding the L value
+
−           */
+
−          bf_setBitpos (posL+(L*8)+16, globs);
+
−          break;
+
−        }
+
−
+
−        case CCDTYPE_GSM7_LV:
+
−        {
+
−          USHORT L = (USHORT) ((globs->bitpos - posL)-lenL);
+
−
+
−#ifdef DEBUG_CCD
+
−          TRACE_CCD (globs, "recoding the 7 bit L-value (bitlength) (%d)", L);
+
−#endif
+
−          bf_recodeShortNumber ((USHORT)posL, lenL, L, globs);
+
−
+
−          bf_setBitpos (posL+L+7, globs);
+
−          break;
+
−        }
+
−
+
−        default:
+
−        {
+
−          USHORT L = ((USHORT)(((globs->bitpos - posL)-lenL)+7) >> 3);
+
−
+
−#ifdef DEBUG_CCD
+
−          TRACE_CCD (globs, "recoding the 8 bit L-value (%d)", L);
+
−#endif
+
−          bf_recodeByteNumber ((USHORT)posL, lenL, (UBYTE) L, globs);
+
−          /*
+
−           * Set the bitpos to a 8 bit aligned position
+
−           * corresponding the L value
+
−           */
+
−          bf_setBitpos (posL+(L*8)+8, globs);
+
−          break;
+
−        }
+
−      }
+
−    }
+
−  }
+
−
+
−  /*
+
−   * Restore globs->pstruct if overwritten by pointer dereference.
+
−   */
+
−  if (old_pstruct)
+
−    globs->pstruct = old_pstruct;
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CDC_COM             |
+
−| STATE   : code                       ROUTINE : cdc_GSM_start       |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Initialize the GSM specific codec part for each msg. 
+
−
+
−*/
+
−
+
−void cdc_GSM_start (T_CCD_Globs *globs)
+
−{
+
−  globs->Swap1V_inProgress = FALSE;
+
−  globs->last_level       = 255;
+
−  cdc_init_ctx_table (globs);
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_INT_RAM
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)              MODULE  : CDC_COM                |
+
−| STATE   : code                    ROUTINE : cdc_isPresent          |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : For optional elements check the valid-flag in the C-struct.
+
−            Spare elements in PER do not have a corresponding valid flag.
+
−            In case of Dynamic Arrays:
+
−            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.
+
−*/
+
−U16 cdc_isPresent (const ULONG e_ref, T_CCD_Globs *globs)
+
−{
+
−  if (melem[e_ref].optional)
+
−  {
+
−#ifdef DYNAMIC_ARRAYS
+
−    if (melem[e_ref].elemType < 'P' OR melem[e_ref].elemType > 'R')
+
−    {
+
−      if(globs->pstruct[globs->pstructOffs++] == FALSE)
+
−        return FALSE;
+
−#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
+
−    }
+
−    else
+
−    { /*If elemType is P, Q or R - check the pointer value*/
+
−      if(*(void**) &globs->pstruct[globs->pstructOffs] == NULL)
+
−        return FALSE;
+
−    }
+
−#else
+
−    if (globs->pstruct[globs->pstructOffs++] == FALSE)
+
−      return FALSE;
+
−#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
+
−#endif
+
−  }
+
−  return TRUE;
+
−}
+
−#endif /* !RUN_INT_RAM */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)              MODULE  : CDC_COM                |
+
−| STATE   : code                    ROUTINE : is_pointer_type        |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Return TRUE for pointer elements.
+
−
+
−*/
+
−BOOL is_pointer_type (const ULONG e_ref)
+
−{
+
−  return ((melem[e_ref].elemType >= 'P' AND melem[e_ref].elemType <= 'R') OR
+
−	  (melem[e_ref].elemType >= 'D' AND melem[e_ref].elemType <= 'F'));
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)              MODULE  : CDC_COM                |
+
−| STATE   : code                    ROUTINE : is_variable_type       |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Return TRUE for elements with variable character.
+
−
+
−*/
+
−BOOL is_variable_type (const ULONG e_ref)
+
−{
+
−  return ((melem[e_ref].elemType == 'F') || ( melem[e_ref].elemType == 'R') ||
+
−	  (melem[e_ref].elemType == 'V'));
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_INT_RAM
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)              MODULE  : CDC_COM                |
+
−| STATE   : code                    ROUTINE : PER_CommonBegin        |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Common settings done by most of the encoding or decoding 
+
−            functions for UNALIGNED PER (UMTS).
+
−            It handles position of pointer to the C-structure, 
+
−            valid flag for optional elements and length determinant 
+
−            for array of elements.
+
−*/
+
−SHORT PER_CommonBegin (const ULONG e_ref, ULONG *max_rep, T_CCD_Globs *globs)
+
−{
+
−  /*
+
−   * Set the offset in the C-structure on the value for this element
+
−   */
+
−  globs->pstructOffs = melem[e_ref].structOffs;
+
−
+
−  /* For optional elements we have already set the valid flag in the
+
−   * C-structure while processing ASN1_SEQ.
+
−   */
+
−  if ( ! cdc_isPresent(e_ref, globs) )
+
−    return (SHORT)ccdError;
+
−   
+
−  switch (melem[e_ref].repType)
+
−  {
+
−    case ' ':
+
−      /*
+
−       * Element is not an array.
+
−       */
+
−      *max_rep = 1;
+
−      break;
+
−    case 'c':
+
−    case 'C':
+
−      /*
+
−       * Read the size for an array of fixed length.
+
−       */
+
−      *max_rep = (ULONG) melem[e_ref].maxRepeat; 
+
−      break;                
+
−    case 'j':
+
−    case 'J':
+
−    {
+
−      /*
+
−       * Read the size for an array of variable length.
+
−       * Read the value of the last encoded element. It is the length
+
−       * indicator.
+
−       * Hint 1: globs->pstruct[melem[e_ref-1].structOffs is 0, since
+
−       *   fields of variable length are projected on a COMP made of an
+
−       *   ASN1_INTEGER for the lenght indicator and the field elements
+
−       *   (sequences, integers, octets or bits). 
+
−       * Hint 2: The current version of UMTS does not use length
+
−       *   indicators larger than 64K. Hence the use of USHORT for repeat.
+
−       */
+
−      switch (mvar[melem[e_ref-1].elemRef].cType)
+
−      {
+
−      case 'B':  *max_rep = (ULONG)  globs->pstruct[melem[e_ref-1].structOffs];
+
−      	         break;
+
−      case 'S':  *max_rep = (ULONG) *(USHORT *) (globs->pstruct+melem[e_ref-1].structOffs);
+
−	               break;
+
−      default:   *max_rep = 0;
+
−	               break;
+
−      }
+
−      break;
+
−    }
+
−    default:
+
−      ccd_recordFault (globs, ERR_DEFECT_CCDDATA, BREAK, (USHORT) e_ref,
+
−                     globs->pstruct + globs->pstructOffs);
+
−      break;
+
−  }
+
−
+
−  /*
+
−   * There is nothing to be encoded. 
+
−   */
+
−  if (*max_rep EQ 0)
+
−  {
+
−    return (SHORT)ccdError;
+
−  }
+
−  /* 
+
−   * Check the validity of the lenght information.
+
−   */
+
−  else if (melem[e_ref].maxRepeat AND *max_rep > melem[e_ref].maxRepeat)
+
−  {
+
−    ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE, (USHORT) e_ref,
+
−                     globs->pstruct + globs->pstructOffs);
+
−  }
+
−
+
−  return (SHORT)ccdOK;
+
−}
+
−#endif /* !RUN_INT_RAM */
+
−
+
−
+
−#ifdef DYNAMIC_ARRAYS
+
−#ifndef RUN_INT_RAM
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)              MODULE  : CDC_COM                |
+
−| STATE   : code                    ROUTINE : PER_allocmem           |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Allocate memory for pointer types (dynamic array addition)
+
−            Returns address of freshly allocated memory
+
−            or ccdError in case no memory is available.
+
−*/
+
−U8 *PER_allocmem(const ULONG e_ref, ULONG repeat, T_CCD_Globs *globs)
+
−{
+
−  /*
+
−   * Check for pointer types; allocate memory if necessary.
+
−   */
+
−  if ( is_pointer_type(e_ref) ) {
+
−    ULONG   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'
+
−		     OR melem[e_ref].elemType EQ 'F')
+
−		    ? mvar[melem[e_ref].elemRef].cSize
+
−		    : mcomp[melem[e_ref].elemRef].cSize
+
−		    );
+
−
+
−#ifdef DEBUG_CCD
+
−    TRACE_CCD (globs, "PER_allocmem(): alloc%5d x%5d bytes (type '%c'); "
+
−	       "elem%5d ('%s')",
+
−	       repeat, cSize, melem[e_ref].elemType, e_ref,
+
−#ifdef CCD_SYMBOLS
+
−	       mcomp[melem[e_ref].elemRef].name
+
−#else
+
−	       ""
+
−#endif
+
−	       );
+
−#endif
+
−    /*
+
−     * Allocate additional memory - append to existing mem chain
+
−     */
+
−
+
−    cSize *= repeat;
+
−    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 (U8 *)ccdError;
+
−    }
+
−    else
+
−      memset (addr, 0, (size_t)cSize);
+
−    return addr;
+
−  }
+
−  return (U8 *)ccdError;
+
−}
+
−#endif /* !RUN_INT_RAM */
+
−
+
−#ifndef RUN_INT_RAM
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)              MODULE  : CDC_COM                |
+
−| STATE   : code                    ROUTINE : PER_allocmem_and_update|
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Allocate memory for pointer types (dynamic array addition)
+
−            Updates global variables after allocation
+
−            (globs->pstruct and globs->pstructOffs).
+
−            Assumes that these global variables are saved by the
+
−            calling function.
+
−            Returns ccdOK or ccdError in case no memory is available.
+
−*/
+
−USHORT PER_allocmem_and_update(const ULONG e_ref, ULONG repeat, T_CCD_Globs *globs)
+
−{
+
−  U8    *addr;
+
−
+
−  /* Allocate memory */
+
−  addr = PER_allocmem(e_ref, repeat, globs);
+
−
+
−  /* No memory ? */
+
−  if ( addr != (U8 *)ccdError ) {
+
−    /*
+
−     * Memory allocated;
+
−     * 1. Store pointer to freshly allocated memory area in structure
+
−     * 2. Initialize pstruct to point to the freshly allocated memory area.
+
−     * 3. Initialize pstructOffs to 0 to start decoding at offset 0
+
−     *    in the new memory area.
+
−     * Assumes that globs->pstruct is saved in the calling function.
+
−     */
+
−    *(U8 **)(globs->pstruct + globs->pstructOffs) = addr;
+
−    globs->pstruct     = addr;
+
−    globs->pstructOffs = 0;
+
−    return ccdOK;
+
−  } else {
+
−    /* No memory - Return error */
+
−    return ccdError;
+
−  }
+
−}
+
−#endif /* !RUN_INT_RAM */
+
−#endif
+
−
+
−#ifndef RUN_INT_RAM
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)              MODULE  : CDC_COM                |
+
−| STATE   : code       ROUTINE : Read_NormallySmallNonNegativeWholeNr|
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Read a normally small non-negative whole number as defined
+
−            by ASN.1 PER. Function is used to read elements such as:
+
−			a) bit-map field of SEQUENCE extensions,
+
−			b) index of CHOICE extension or
+
−			c) extension value of extensible INTEGER or ENUMERATED.
+
−*/
+
−U32 Read_NormallySmallNonNegativeWholeNr (T_CCD_Globs *globs)
+
−{
+
−  U32 value_length=0;
+
−
+
−  /* Read the first bit. If set to 0 it means the value is encoded
+
−   * in the following five bits. Else read a normally small ...nr.
+
−   */
+
−  if (bf_readBit (globs) EQ 0)
+
−  {
+
−    return ((U32) bf_getBits (6, globs));
+
−  }
+
−  else 
+
−  {
+
−    /*
+
−     * Do not handle the theoretical case that value length 
+
−     * needs more than 63 bits.
+
−     */
+
−    bf_incBitpos (1, globs);
+
−
+
−    /* 
+
−     * Read the value length first. 
+
−     * Then use the length to read the value.
+
−     */
+
−    value_length = (U32) bf_getBits (6, globs);
+
−    return ((U32) bf_getBits (value_length, globs));
+
−  }
+
−}
+
−#endif /* !RUN_INT_RAM */
+
−
+
−#ifndef RUN_INT_RAM
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)              MODULE  : CDC_COM                |
+
−| STATE   : code      ROUTINE : Write_NormallySmallNonNegativeWholeNr|
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Write a normally small non-negative whole number as defined
+
−            by ASN.1 PER. Function is used to encode elements such as:
+
−			a) bit-map field of SEQUENCE extensions,
+
−			b) index of CHOICE extension or
+
−			c) extension value of extensible INTEGER or ENUMERATED.
+
−*/
+
−void Write_NormallySmallNonNegativeWholeNr (U32 Value, T_CCD_Globs *globs)
+
−{
+
−  /* For small numbers write 0 in the first bit. 
+
−   * Then encode that number in the succeeding five bits.
+
−   */
+
−  if (Value < 64)
+
−  {
+
−  	bf_writeBit (0, globs);
+
−	  bf_writeVal (Value, 6, globs);
+
−  }
+
−  /*
+
−   * Encode the number under the assumption that its length is 
+
−   * given by less than 63 bits. Hence encode also the length as a 
+
−   * normally small...
+
−   */
+
−  else 
+
−  {
+
−	  /* Set flag bits:
+
−	   * 1 means "length determinant encoded before the value itself"
+
−	   * 0 means "length determinant encoded only in five bits"
+
−	   */
+
−	  bf_writeVal (2, 2, globs);
+
−	  bf_writeVal (bitSize[Value], 5, globs);
+
−
+
−	  /* Encode the number itself */
+
−	  bf_writeVal (Value, bitSize[Value], globs);
+
−  }
+
−
+
−  return;
+
−}
+
−#endif /* !RUN_INT_RAM */
+
−
+
−#ifndef RUN_INT_RAM
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)              MODULE  : CDC_COM                |
+
−| STATE   : code                    ROUTINE : Read_OpenTpye_Length   |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Read length of an ASN.1 open type.
+
−            Open types are normally found in encoding of 
+
−            parametrized information objects and extension types.
+
−*/
+
−U32 Read_OpenTpye_Length (T_CCD_Globs *globs)
+
−{
+
−  U32 Value;
+
−
+
−  /* 
+
−   * Flag bit is 0 for "Value < 128" which means
+
−   * "encoding fits in the current octet"
+
−   */
+
−  if (bf_readBit (globs) EQ 0)
+
−  {
+
−	  Value = bf_getBits (7, globs);
+
−  }
+
−  /* 
+
−   * Flag bits are 10 for 128 "< Value < 16K".
+
−   * 1 means "encoding does not fit in the current octet".
+
−   * 0 means "encoding needs only one further octet".
+
−   */
+
−  else if (bf_readBit (globs) EQ 0)
+
−  {
+
−  	Value = bf_getBits (14, globs);
+
−  } 
+
−  /* Currently no support for bigger values is required. */
+
−  else 
+
−  {
+
−    /* force error detection */
+
−    Value = 0;
+
−  }
+
−
+
−  return Value;
+
−}
+
−#endif /* !RUN_INT_RAM */
+
−
+
−#ifndef RUN_INT_RAM
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)              MODULE  : CDC_COM                |
+
−| STATE   : code                    ROUTINE : Write_OpenTpye_Length  |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Write length of an ASN.1 open type.
+
−            Open types are normally found in encoding of 
+
−            parametrized information objects and extension types.
+
−*/
+
−void Write_OpenTpye_Length (U32 Value, T_CCD_Globs *globs)
+
−{
+
−
+
−  if (Value < 128)
+
−  {
+
−	  bf_writeVal (Value, 8, globs);
+
−  }
+
−  else if (Value < 0x8000)
+
−  {
+
−	  /* Set flag bits:
+
−	   * 1 means "encoding does not fit in the current octet"
+
−	   * 0 means "encoding needs only one further octet"
+
−	   */
+
−	  bf_writeVal (2, 2, globs);
+
−	  bf_writeVal (Value, 14, globs);
+
−  } 
+
−  /* Currently no support for bigger values is required. */
+
−  else 
+
−  {}
+
−
+
−  return;
+
−}
+
−#endif /* !RUN_INT_RAM */