+
−/* 
+
−+----------------------------------------------------------------------------- 
+
−|  Project :  
+
−|  Modul   : ccd.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 - 
+
−|             Definition of encoding and decoding functions of 
+
−|             air interface messages
+
−+----------------------------------------------------------------------------- 
+
−*/ 
+
−
+
−#define CCD_C
+
−
+
−#include <stdio.h>
+
−#include <stdlib.h>
+
−#include <stdarg.h>
+
−#include <string.h>
+
−#include <setjmp.h>
+
−
+
−#ifdef _MSDOS
+
−  #include <dos.h>
+
−  #include <conio.h>
+
−#endif
+
−
+
−/*
+
− * Standard definitions like UCHAR, ERROR etc.
+
− */
+
−
+
−#include "typedefs.h"
+
−#include "header.h"
+
−
+
−/*
+
− * Types and constants used by CCD
+
− */
+
−#include "ccd_globs.h"
+
−
+
−/*
+
− * Type definitions for CCD data tables
+
− */
+
−#include "ccdtable.h"
+
−
+
−/*
+
− * Function prototypes of CCD-CCDDATA interface 
+
− */
+
−#include "ccddata.h"
+
−
+
−/*
+
− * Error codes and prototypes of exported functions by 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 "bitfun.h"
+
−
+
−
+
−/*
+
− * Prototypes of ccd internal functions
+
− */
+
−#include "ccd.h"
+
−
+
−#if !(defined (CCD_TEST))
+
−#include "vsi.h"
+
−#include "os.h"
+
−#endif
+
−
+
−#ifdef SHARED_VSI
+
−  #define VSI_CALLER 0,
+
−#else
+
−  #define VSI_CALLER
+
−#endif
+
−
+
−#ifndef RUN_FLASH
+
−/* task_null is used in ccd_signup. It must have the same RUN_... setting. */
+
−static T_CCD_TASK_TABLE task_null;
+
−#endif /* !RUN_FLASH */
+
−
+
−//TISH modified for MSIM
+
−#if defined (CCD_TEST) || defined (_TOOLS_) || defined (WIN32)
+
−/* For the DLL and for all simple environment define the task list locally */
+
−/* 10 entries should be more than enough */
+
−#define MAX_ENTITIES 10
+
−T_CCD_TASK_TABLE* ccd_task_list[MAX_ENTITIES];
+
−#else
+
−extern T_CCD_TASK_TABLE* ccd_task_list[];
+
−#endif
+
−
+
−#ifndef RUN_FLASH
+
−const T_CCD_VarTabEntry*   mvar;
+
−const T_CCD_SpareTabEntry* spare;
+
−const T_CCD_CalcTabEntry*  calc;
+
−const T_CCD_CompTabEntry*  mcomp;
+
−const T_CCD_ElemTabEntry*  melem;
+
−const T_CCD_CalcIndex*     calcidx;
+
−const T_CCD_ValTabEntry*   mval;
+
−#else
+
−extern const T_CCD_VarTabEntry*   mvar;
+
−extern const T_CCD_SpareTabEntry* spare;
+
−extern const T_CCD_CalcTabEntry*  calc;
+
−extern const T_CCD_CompTabEntry*  mcomp;
+
−extern const T_CCD_ElemTabEntry*  melem;
+
−extern const T_CCD_CalcIndex*     calcidx;
+
−extern const T_CCD_ValTabEntry*   mval;
+
−#endif
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
− * Attention: if one of the following static data shall be used in
+
− * both, internal as well as external RAM, they must be made global.
+
− */
+
−static USHORT max_message_id;
+
−
+
−/*
+
− * CCD internal buffer for decoded message
+
− */
+
−static UBYTE *ccd_decMsgBuffer; 
+
−/*
+
− * Layer-specific cache for the bitlength of the message-identifier;
+
− * A value of 0 indicates an empty (undetermined) entry
+
− */
+
−static UBYTE *mi_length; 
+
−
+
−/*
+
− * CCD internal variables used in each call to code or decode message
+
− */
+
−
+
−static U8 aim_rrc_rcm;
+
−static U8 aim_rrlp;
+
−static U8 aim_sat;
+
−
+
−static T_CCD_Globs globs_all;
+
−#endif /* !RUN_FLASH */
+
−
+
−/*
+
− * CCD will call its encoding/decoding functions through a jump table. 
+
− */
+
−#include "ccd_codingtypes.h"
+
−#ifndef RUN_FLASH
+
−T_FUNC_POINTER  codec[MAX_CODEC_ID+1][2];
+
−#else
+
−extern T_FUNC_POINTER  codec[MAX_CODEC_ID+1][2];
+
−#endif
+
−
+
−#ifndef RUN_FLASH
+
−/* initialized is used in ccd_signup. It must have the same RUN_... setting. */
+
−/*
+
− * Initialising flag
+
− */
+
−BOOL initialized = FALSE;
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifdef SHARED_CCD
+
−  /*
+
−   * If CCD is used in a premptive multithreaded system we need
+
−   * a semaphore to protect the coding and decoding sections.
+
−   */
+
−  #ifndef RUN_FLASH
+
−    T_HANDLE semCCD_Codec, semCCD_Buffer;
+
−  #else
+
−    extern T_HANDLE semCCD_Codec, semCCD_Buffer;
+
−  #endif /* RUN_FLASH */
+
−#endif /* SHARED_CCD */
+
−
+
−static U8* mempat;
+
−#define LOWSEGMASK 0xFFFFF000
+
−
+
−#ifndef RUN_FLASH
+
−#ifdef DEBUG_CCD
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CCD                 |
+
−| STATE   : code                       ROUTINE : TRACE_CCD           |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Error processing of the CCD.
+
−
+
−*/
+
−
+
−void TRACE_CCD (T_CCD_Globs *globs, char *format, ...)
+
−{
+
−  va_list varpars;
+
−  char trace_buf[256];
+
−  int i=0;
+
−
+
−  if (!globs->TraceIt)
+
−    return;
+
−
+
−  va_start (varpars, format); /* Initialize variable arguments. */
+
−#if defined CCD_TEST
+
−  /*
+
−   * use vsi_o_trace - prefix the tracestring with [CCD]
+
−   * so the PCO can display it in a CCD window
+
−   */
+
−  strcpy (trace_buf, "~CCD~");
+
−  i = 5; 
+
−#endif /* CCD_TEST */
+
−  vsprintf (trace_buf+i, format, varpars);
+
−  va_end (varpars);              /* Reset variable arguments.   */
+
−
+
−#ifdef CCD_TEST
+
−  printf ("\n%s\n", trace_buf);
+
−#else
+
−  vsi_o_ttrace (globs->me, TC_CCD, trace_buf);
+
−#endif /* CCD_TEST */
+
−
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#endif
+
−
+
−/*
+
− * Stack operations
+
− */
+
−#define ST_CLEAR(globs) globs->SP=0;globs->StackOvfl=FALSE;
+
−
+
−#define ST_OK(globs) (globs->StackOvfl EQ FALSE)
+
−
+
−#define ST_CHECK(A, globs) {if (!(globs->StackOvfl) AND globs->SP < MAX_UPN_STACK_SIZE)\
+
−                    {(A);}\
+
−                    else\
+
−                    {globs->StackOvfl = TRUE;}}
+
−
+
−#define ST_PUSH(A, globs) ST_CHECK ((globs->Stack[globs->SP++] = (A)), globs)
+
−
+
−#define ST_POP(A, globs)  ST_CHECK ((A = globs->Stack[--(globs->SP)]), globs)
+
−
+
−#define ST_TOP(A, globs)  ST_CHECK ((A = globs->Stack[globs->SP-1]), globs)
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
− * Attention: if the static function calcUPN shall be used in
+
− * both, internal as well as external RAM, it must be made global.
+
− */
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CCD                 |
+
−| STATE   : code                       ROUTINE : calcUPN             |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : calculates the UPN-term for an element.
+
−
+
−*/
+
−LOCAL BOOL calcUPN  (ULONG        op,
+
−                     ULONG        num_ops,
+
−                     ULONG       *result,
+
−                     T_CCD_Globs *globs)
+
−{
+
−  BOOL   opError;
+
−  ULONG  op1=0,op2=0;
+
−
+
−  opError = FALSE;
+
−  
+
−#ifdef DEBUG_CCD
+
−  TRACE_CCD (globs, "Calculation of UPN-term ");
+
−#endif
+
−
+
−  while (num_ops-- AND !opError AND ST_OK(globs))
+
−  {
+
−    switch (calc[op].operation)
+
−    {
+
−      case '+':
+
−        /*
+
−         * get the upper two elements from the stack, add them
+
−         * and push the result on the stack
+
−         */
+
−        if (globs->SP >= 2)
+
−        {
+
−          ST_POP(op2, globs);
+
−          ST_POP(op1, globs);
+
−          ST_PUSH ((op1 + op2), globs);
+
−        }
+
−#ifdef DEBUG_CCD
+
−        else
+
−          TRACE_CCD (globs, "Control parameter '+' causes invalid calculation");
+
−#endif
+
−        break;
+
−      case '-':
+
−        /*
+
−         * get the upper two elements from the stack, subtract them
+
−         * and push the result on the stack
+
−         */
+
−        if (globs->SP >= 2)
+
−        {
+
−          ST_POP(op2, globs);
+
−          ST_POP(op1, globs);
+
−          ST_PUSH ((op1 - op2), globs);
+
−        }
+
−#ifdef DEBUG_CCD
+
−        else
+
−          TRACE_CCD (globs, "Control parameter '-' causes invalid calculation");
+
−#endif
+
−        break;
+
−      case '*':
+
−        /*
+
−         * get the upper two elements from the stack, multiply them
+
−         * and push the result on the stack
+
−         */
+
−        if (globs->SP >= 2)
+
−        {
+
−          ST_POP(op2, globs);
+
−          ST_POP(op1, globs);
+
−          ST_PUSH ((op1 * op2), globs);
+
−        }
+
−#ifdef DEBUG_CCD
+
−        else
+
−          TRACE_CCD (globs, "Control parameter '*' causes invalid calculation");
+
−#endif
+
−        break;
+
−      case '/':
+
−        /*
+
−         * get the upper two elements from the stack, divide them
+
−         * and push the result on the stack
+
−         */
+
−        if (globs->SP >= 2)
+
−        {
+
−          ST_POP(op2, globs);
+
−          if (!op2)
+
−          {
+
−            ccd_setError (globs, ERR_DEFECT_CCDDATA, BREAK, 
+
−                        (USHORT) (globs->bitpos), (USHORT) -1);
+
−          }
+
−          else
+
−          {
+
−            ST_POP(op1, globs);
+
−            ST_PUSH ((op1 / op2), globs);
+
−          }
+
−        }
+
−#ifdef DEBUG_CCD
+
−        else
+
−          TRACE_CCD (globs, "Control parameter '/' causes invalid calculation");
+
−#endif
+
−        break;
+
−      case '&':
+
−        /*
+
−         * get the upper two elements from the stack, perform a
+
−         * binary AND
+
−         * and push the result on the stack
+
−         */
+
−        if (globs->SP >= 2)
+
−        {
+
−          ST_POP(op2, globs);
+
−          ST_POP(op1, globs);
+
−          ST_PUSH ((op1 & op2), globs);
+
−        }
+
−#ifdef DEBUG_CCD
+
−        else
+
−          TRACE_CCD (globs, "Control parameter '&' causes invalid calculation");
+
−#endif
+
−        break;
+
−      case '|':
+
−        /*
+
−         * get the upper two elements from the stack, perform a
+
−         * binary OR
+
−         * and push the result on the stack
+
−         */
+
−        if (globs->SP >= 2)
+
−        {
+
−          ST_POP(op2, globs);
+
−          ST_POP(op1, globs);
+
−          ST_PUSH ((op1 | op2), globs);
+
−        }
+
−#ifdef DEBUG_CCD
+
−        else
+
−          TRACE_CCD (globs, "Control parameter '|' causes invalid calculation");
+
−#endif
+
−        break;
+
−      case 'A':
+
−        /*
+
−         * get the upper two elements from the stack, perform a
+
−         * logical AND
+
−         * and push a TRUE or FALSE on the stack
+
−         */
+
−        if (globs->SP >= 2)
+
−        {
+
−          ST_POP(op2, globs);
+
−          ST_POP(op1, globs);
+
−          ST_PUSH ((op1 AND op2), globs);
+
−        }
+
−#ifdef DEBUG_CCD
+
−        else
+
−          TRACE_CCD (globs, "Control parameter 'AND' causes invalid calculation");
+
−#endif
+
−        break;
+
−      case 'O':
+
−        /*
+
−         * get the upper two elements from the stack, perform a
+
−         * logical OR
+
−         * and push a TRUE or FALSE on the stack
+
−         */
+
−        if (globs->SP >= 2)
+
−        {
+
−          ST_POP(op2, globs);
+
−          ST_POP(op1, globs);
+
−          ST_PUSH ((op1 OR op2), globs);
+
−        }
+
−#ifdef DEBUG_CCD
+
−        else
+
−          TRACE_CCD (globs, "Control parameter 'OR' causes invalid calculation");
+
−#endif
+
−        break;
+
−      case 'X':
+
−        /*
+
−         * get the upper two elements from the stack, perform a
+
−         * logical XOR
+
−         * and push a TRUE or FALSE on the stack
+
−         */
+
−        if (globs->SP >= 2)
+
−        {
+
−          ST_POP(op2, globs);
+
−          ST_POP(op1, globs);
+
−          ST_PUSH ( ((op1 AND !op2) OR (!op1 AND op2)) , globs);
+
−        }
+
−#ifdef DEBUG_CCD
+
−        else
+
−          TRACE_CCD (globs, "Control parameter 'XOR' causes invalid calculation");
+
−#endif
+
−        break;
+
−      case '=':
+
−        /*
+
−         * get the upper two elements from the stack, look if they
+
−         * are equal
+
−         * and push a TRUE or FALSE on the stack
+
−         */
+
−        if (globs->SP >= 2)
+
−        {
+
−          ST_POP(op2, globs);
+
−          ST_POP(op1, globs);
+
−          ST_PUSH ((op1 EQ op2), globs);
+
−        }
+
−#ifdef DEBUG_CCD
+
−        else
+
−          TRACE_CCD (globs, "Control parameter '=' causes invalid calculation");
+
−#endif
+
−        break;
+
−      case '#':
+
−        /*
+
−         * get the upper two elements from the stack, look if they
+
−         * are different
+
−         * and push a TRUE or FALSE on the stack
+
−         */
+
−        if (globs->SP >= 2)
+
−        {
+
−          ST_POP(op2, globs);
+
−          ST_POP(op1, globs);
+
−          ST_PUSH ((op1 NEQ op2), globs);
+
−        }
+
−#ifdef DEBUG_CCD
+
−        else
+
−          TRACE_CCD (globs, "Control parameter '#' causes invalid calculation");
+
−#endif
+
−        break;
+
−      case '>':
+
−        /*
+
−         * get the upper two elements from the stack, look if
+
−         * op1 > op2
+
−         * and push a TRUE or FALSE on the stack
+
−         */
+
−        if (globs->SP >= 2)
+
−        {
+
−          ST_POP(op2, globs);
+
−          ST_POP(op1, globs);
+
−          ST_PUSH ((op1 > op2), globs);
+
−        }
+
−#ifdef DEBUG_CCD
+
−        else
+
−          TRACE_CCD (globs, "Control parameter '>' causes invalid calculation");
+
−#endif
+
−        break;
+
−      case '<':
+
−        /*
+
−         * get the upper two elements from the stack, look if
+
−         * op1 < op2
+
−         * and push a TRUE or FALSE on the stack
+
−         */
+
−        if (globs->SP >= 2)
+
−        {
+
−          ST_POP(op2, globs);
+
−          ST_POP(op1, globs);
+
−          ST_PUSH ((op1 < op2), globs);
+
−        }
+
−#ifdef DEBUG_CCD
+
−        else
+
−          TRACE_CCD (globs, "Control parameter '<' causes invalid calculation");
+
−#endif
+
−        break;
+
−      case 'P':
+
−        /*
+
−         * push a constant on the stack
+
−         */
+
−        ST_PUSH (calc[op].operand, globs);
+
−#ifdef DEBUG_CCD
+
−        if (globs->StackOvfl == TRUE)
+
−          TRACE_CCD (globs, "Constant can't be pused on UPN stack");
+
−#endif
+
−        break;
+
−      case ':':
+
−        /*
+
−         * duplicate the upper element on the stack
+
−         */
+
−        if (globs->SP >= 1)
+
−        {
+
−          ST_TOP (op1, globs);
+
−          ST_PUSH (op1, globs);
+
−        }
+
−#ifdef DEBUG_CCD
+
−        else
+
−          TRACE_CCD (globs, "No UPN stack element to duplicate");
+
−#endif
+
−        break;
+
−      case 'R':
+
−        /*
+
−         * push the content of a C-structure variable on the stack
+
−         */
+
−      {
+
−        /* if no register available some compilers may react with 
+
−           a warning like this: identifier p not bound to register
+
−        */
+
−        UBYTE *p;
+
−        ULONG           value;
+
−
+
−        /*
+
−         * normaly we have to check if the element is a VAR
+
−         * and not an array/substructure.
+
−         * - but this must be done by ccdgen
+
−         */
+
−
+
−        /*
+
−         * setup the read pointer to the element in the C-structure
+
−         */
+
−        p = globs->pstruct + melem[(USHORT) calc[op].operand].structOffs;
+
−
+
−        /*
+
−         * Get the element table entry from the element to read.
+
−         * if the element of the condition is conditional too
+
−         * then look for the valid flag of this element.
+
−         * if the element is not valid,
+
−         * we dont need to check the contents of it
+
−         */
+
−        if (melem[(USHORT) calc[op].operand].optional)
+
−        {
+
−          if (*(UBYTE *) p EQ FALSE)
+
−          {
+
−            ST_PUSH (0L, globs);
+
−            break;
+
−          }
+
−          else
+
−            p++;
+
−        }
+
−
+
−        /*
+
−         * read the contents of the element
+
−         */
+
−        switch (mvar[melem[(USHORT) calc[op].operand].elemRef].cType)
+
−        {
+
−          case 'B':
+
−            value = (ULONG) * p;
+
−            break;
+
−          case 'S':
+
−            value = (ULONG) * (USHORT *) p;
+
−            break;
+
−          case 'L':
+
−            value = *(ULONG *) p;
+
−            break;
+
−          default:
+
−            value = 0L;
+
−        }
+
−        ST_PUSH (value, globs);
+
−        break;
+
−      }
+
−      case 'S':
+
−        /*
+
−         * get the upper element from the stack an
+
−         * set the position of the bitstream pointer to this
+
−         * value
+
−         */
+
−        if (globs->SP >= 1)
+
−        {
+
−          ST_POP(op1, globs);
+
−#ifdef DEBUG_CCD
+
−          TRACE_CCD (globs, "SETBITPOS %d (byte %d.%d)",
+
−                     (USHORT) op1, (USHORT) (op1 / 8), (USHORT) (op1 % 8));
+
−#endif
+
−          bf_setBitpos ((USHORT) op1, globs);
+
−        }
+
−#ifdef DEBUG_CCD
+
−        else
+
−          TRACE_CCD (globs, "Control parameter 'SETBITPOS' causes invalid calculation");
+
−#endif
+
−        break;
+
−      case 'G':
+
−        /*
+
−         * push the position of the bitstream pointer on the
+
−         * stack
+
−         */
+
−        ST_PUSH ((ULONG) globs->bitpos, globs);
+
−#ifdef DEBUG_CCD
+
−        TRACE_CCD (globs, "GETBITPOS %d (byte %d.%d)", 
+
−                   (USHORT) globs->bitpos, globs->bytepos, globs->byteoffs);
+
−#endif
+
−        break;
+
−      case '^':
+
−        /*
+
−         * swap the upper two elements of the stack
+
−         */
+
−        if (globs->SP >= 2)
+
−        {
+
−          ST_POP(op1, globs);
+
−          ST_POP(op2, globs);
+
−          ST_PUSH(op1, globs);
+
−          ST_PUSH(op2, globs);
+
−        }
+
−#ifdef DEBUG_CCD
+
−        else
+
−          TRACE_CCD (globs, "Control parameter '^' causes invalid calculation");
+
−#endif
+
−        break;
+
−      case 'K':
+
−        /*
+
−         * Keep a value in the KEEP register.
+
−         */
+
−        if (globs->SP >= 1)
+
−        {
+
−          ST_POP(op1, globs);
+
−          globs->KeepReg[calc[op].operand] = op1;
+
−        }
+
−#ifdef DEBUG_CCD
+
−        else
+
−          TRACE_CCD (globs, "Control parameter 'KEEP' causes invalid calculation");
+
−#endif
+
−        break;
+
−      case 'L':
+
−        /*
+
−         * Copy the L part of a TLV element from the KEEP register to the UPN stack.
+
−         */          
+
−        ST_PUSH(globs->KeepReg[0]*8, globs);
+
−#ifdef DEBUG_CCD
+
−        if (globs->StackOvfl == TRUE)
+
−          TRACE_CCD (globs, "Control parameter 'LTAKE' causes invalid calculation");
+
−#endif
+
−        break;
+
−      case 'T':
+
−        /*
+
−         * Take a value from the KEEP register and push it on the UPN stack.
+
−         */          
+
−        ST_PUSH(globs->KeepReg[calc[op].operand], globs);
+
−#ifdef DEBUG_CCD
+
−        if (globs->StackOvfl == TRUE)
+
−          TRACE_CCD (globs, "Control parameter 'TAKE' causes invalid calculation");
+
−#endif
+
−        break;
+
−      case 'C':
+
−        /*
+
−         * Compare the value on the UPN stack with the one stored in the KEEP register.
+
−         * Push the higher value in the KEEP register.
+
−         */
+
−        if (globs->SP >= 1)
+
−        {          
+
−          ST_POP(op1, globs);
+
−          if ((globs->KeepReg[calc[op].operand]) < op1)
+
−          {
+
−            globs->KeepReg[calc[op].operand] = op1;
+
−          }
+
−        }
+
−#ifdef DEBUG_CCD
+
−        else
+
−          TRACE_CCD (globs, "Control parameter 'MAX' causes invalid calculation");
+
−#endif
+
−        break;
+
−      case 'Z':
+
−        /*
+
−         *  Used to mark presence of an address information part error label
+
−         */          
+
−        globs->errLabel = ERR_ADDR_INFO_PART;
+
−          break;
+
−      case 'D':
+
−        /*
+
−         *  Used to mark presence of a distribution part error label
+
−         */          
+
−        globs->errLabel = ERR_DISTRIB_PART;
+
−          break;
+
−      case 'N':
+
−        /*
+
−         *  Used to mark presence of a non distribution part error label
+
−         */          
+
−        globs->errLabel = ERR_NON_DISTRIB_PART;
+
−          break;
+
−      case 'M':
+
−        /*
+
−         *  Used to mark presence of a message escape error label
+
−         */          
+
−        globs->errLabel = ERR_MESSAGE_ESCAPE;
+
−          break;
+
−      case 'I':
+
−        /*
+
−         *  Used to mark presence of an ignore error label
+
−         */          
+
−        globs->errLabel = ERR_IGNORE;
+
−          break;
+
−      case 'l':
+
−        /*
+
−         * Take a value from the CCD STO register and push it on the UPN stack.
+
−         */
+
−        opError = ccd_getStore (globs, calc[op].operand, &op1);
+
−        if (!opError)
+
−        {
+
−          ST_PUSH(op1, globs);
+
−#ifdef DEBUG_CCD
+
−          TRACE_CCD (globs, "Push CCD STORE register [%d] value to UPN stack",
+
−                     calc[op].operand);
+
−        }
+
−        else
+
−        {
+
−          TRACE_CCD (globs, "Reading from CCD STORE register [%d] impossible",
+
−                     calc[op].operand);
+
−#endif
+
−        }
+
−        break;
+
−      case 's':
+
−        /*
+
−         * Store a value in the CCD STO register.
+
−         */
+
−        if (globs->SP >= 1)
+
−        {
+
−          ST_POP(op1, globs);
+
−          opError =  ccd_writeStore (globs, calc[op].operand, op1);
+
−#ifdef DEBUG_CCD
+
−          TRACE_CCD (globs, "Store value in CCD STO register [%d]",
+
−                     calc[op].operand);
+
−        }
+
−        else
+
−        {
+
−          TRACE_CCD (globs, "Control parameter 'STORE' causes invalid calculation");
+
−#endif
+
−        }
+
−        break;
+
− 
+
−      default:
+
−        opError = TRUE;
+
−        break;
+
−    }
+
−    op++;
+
−  }
+
−
+
−  if (!opError AND ST_OK(globs))
+
−  {
+
−    if (result NEQ (ULONG *) NULL)
+
−      ST_POP (*result, globs);
+
−    return (ST_OK(globs));
+
−  }
+
−  else
+
−  {
+
−#ifdef DEBUG_CCD
+
−    if(opError)
+
−      TRACE_CCD (globs, "Calculation of UPN-term failed ");
+
−    else
+
−      TRACE_CCD (globs, "Calculation of UPN-term failed due to stack overflow");
+
−#endif
+
−    return FALSE;
+
−  }
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CCD                 |
+
−| STATE   : code                       ROUTINE : ccd_conditionOK     |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Check if the conditions for an element are true.
+
−            The elemRef references an element entry from the elem tab.
+
−            The function returns TRUE if the defined
+
−            conditions are TRUE.
+
−
+
−*/
+
−
+
−BOOL ccd_conditionOK (const ULONG e_ref, T_CCD_Globs *globs)
+
−{
+
−  ULONG result, cond_calc_ref, num_cond_calcs, cix_ref;
+
−
+
−  cix_ref = melem[e_ref].calcIdxRef;
+
−  num_cond_calcs = calcidx[cix_ref].numCondCalcs;
+
−  cond_calc_ref  = calcidx[cix_ref].condCalcRef;
+
−
+
−
+
−  if (! calcUPN (cond_calc_ref,
+
−                 num_cond_calcs,
+
−                 &result,
+
−                 globs))
+
−    return FALSE;
+
−
+
−  return (result EQ TRUE);
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CCD                 |
+
−| STATE   : code                       ROUTINE : ccd_calculateRep    |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : For a given element (referenced by elemRef) calculate the
+
−            repeat value.
+
−
+
−*/
+
−
+
−BOOL ccd_calculateRep  (const ULONG  e_ref,
+
−                              ULONG *repeat,
+
−                              ULONG *max_repeat,
+
−                              T_CCD_Globs *globs)
+
−{
+
−  ULONG cix_ref, result;
+
−  ULONG remaining_repeats=0;
+
−  ULONG rep_calc_ref, num_rep_calcs;
+
−
+
−  BOOL   is_variable;
+
−
+
−  cix_ref = melem[e_ref].calcIdxRef;
+
−  num_rep_calcs = calcidx[cix_ref].numRepCalcs;
+
−  rep_calc_ref  = calcidx[cix_ref].repCalcRef;
+
−
+
−  *max_repeat  = (ULONG) melem[e_ref].maxRepeat;
+
−
+
−  if (num_rep_calcs EQ 0)
+
−  {
+
−    if (melem[e_ref].repType EQ 'i')
+
−    {
+
−      switch (melem[e_ref].elemType)
+
−      {
+
−        case 'S':
+
−          remaining_repeats = (ULONG)((globs->maxBitpos-globs->bitpos)
+
−                           / spare[melem[e_ref].elemRef].bSize);
+
−          break;
+
−        case 'F': /* Code transparent pointer to base type */
+
−        case 'R': /* Pointer to base type */
+
−        case 'V':
+
−          remaining_repeats = (ULONG)((globs->maxBitpos-globs->bitpos)
+
−                           / mvar[melem[e_ref].elemRef].bSize);
+
−          break;
+
−        case 'D': /* Code transparent pointer to composition */
+
−        case 'P': /* Pointer to composition */
+
−        case 'C':
+
−          /* for repeated compositions the remaining repeats
+
−             are set to the max repeats because of the unknown
+
−             size of one composition */
+
−          remaining_repeats = (ULONG) melem[e_ref].maxRepeat;
+
−          break;
+
−        default:
+
−          ccd_setError (globs, ERR_INVALID_CALC, BREAK, (USHORT) -1);
+
−          break;
+
−      }
+
−
+
−      *repeat   = MINIMUM (*max_repeat, remaining_repeats);
+
−      is_variable = TRUE;
+
−    }
+
−    else
+
−    {
+
−      if (melem[e_ref].repType EQ 'b')
+
−      {
+
−        remaining_repeats = (ULONG)(globs->maxBitpos-globs->bitpos);
+
−        *repeat   = MINIMUM (*max_repeat, remaining_repeats);
+
−      }
+
−      else
+
−      {
+
−        *repeat     =  MINIMUM (*max_repeat,
+
−                                (ULONG) calcidx[cix_ref].repCalcRef);
+
−        if (*repeat < (ULONG) calcidx[cix_ref].repCalcRef) 
+
−          ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE, 
+
−                           (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
+
−      }
+
−      is_variable = FALSE;
+
−    }
+
−  }
+
−  else
+
−  {
+
−    is_variable = FALSE;
+
−    if (! calcUPN (rep_calc_ref,
+
−                   num_rep_calcs,
+
−                   &result,
+
−                   globs))
+
−    {
+
−      *repeat = *max_repeat = 0;
+
−
+
−      ccd_setError (globs, ERR_INVALID_CALC, BREAK, (USHORT) -1);
+
−    }
+
−    else
+
−    {
+
−      if ((melem[e_ref].repType != 'b') && (melem[e_ref].repType != 's'))
+
−      {
+
−        is_variable = TRUE;
+
−      }
+
−      if (melem[e_ref].repType EQ 'i')
+
−      {
+
−        switch (melem[e_ref].elemType)
+
−        {
+
−          case 'S':
+
−            remaining_repeats = (ULONG)((globs->maxBitpos-globs->bitpos)
+
−                             / spare[melem[e_ref].elemRef].bSize);
+
−            break;
+
−          case 'F': /* Code transparent pointer to base type */
+
−          case 'R': /* Pointer to base type */
+
−          case 'V':
+
−            remaining_repeats = (ULONG)((globs->maxBitpos-globs->bitpos)
+
−                             / mvar[melem[e_ref].elemRef].bSize);
+
−            break;
+
−          default:
+
−            ccd_setError (globs, ERR_INVALID_CALC, BREAK, (USHORT) -1);
+
−            break;
+
−        }
+
−        *repeat = MINIMUM (result, remaining_repeats);
+
−      }
+
−      else
+
−      {
+
−        *repeat = MINIMUM (result, *max_repeat);
+
−        if (*repeat < result) 
+
−          ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE, 
+
−                           (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
+
−      }
+
−    }
+
−  }
+
−  return (is_variable);
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)               MODULE  : CCD                   |
+
−| STATE   : code                     ROUTINE : ccd_performOperations |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Perform the operation for an element. This operations
+
−            are executed before an element is encoded or decoded.
+
−            The Operations work with the UPN-Stack.
+
−
+
−*/
+
−
+
−void ccd_performOperations (ULONG        num_of_ops,
+
−                            ULONG        op_def_ref,
+
−                            T_CCD_Globs *globs)
+
−{
+
−  if (! calcUPN (op_def_ref,
+
−                 num_of_ops,
+
−                 NULL,
+
−                 globs))
+
−    ccd_setError (globs, ERR_INVALID_CALC, BREAK, (USHORT) -1);
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
− * Attention: if the static function ccd_isOptional shall be used in
+
− * both, internal as well as external RAM, it must be made global.
+
− */
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)               MODULE  : CCD                   |
+
−| STATE   : code                     ROUTINE : ccd_isOptional        |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Checks if a given element is optional. If the element is
+
−            not optional and is a composition,
+
−            a recursive call is performed in order to check
+
−            if the composition contains only optional elements.
+
−            In this case the whole composition is optional.
+
−
+
−            In case of components concatenated with a CSN1 coding 
+
−            rules the meaning of the word <optional> differs from the 
+
−            traditional TI tool chain conventions. So far some coding 
+
−            types (like tagged types, e.g. GSM3_TV) characterise 
+
−            optional elements inherently. The value of their valid 
+
−            flag indicates the presence or absence of such an element.
+
−            Components concatenated with a CSN1 coding type cause 
+
−            these valid flags in the C header structure too. If you 
+
−            find a bit in the received message stream indicating 
+
−            optional values not included in the message (e. g. a 
+
−            CSN1_S1 element is represented by ??, CCD will set the 
+
−            valid flag to zero. But the whole element represented by 
+
−            the flag is present; only the value is absent! Therefor 
+
−            the valid flag in the C structure is not an indication of 
+
−            an element’s absence.
+
−*/
+
−
+
−LOCAL BOOL ccd_isOptional (ULONG e_ref, T_CCD_Globs *globs)
+
−{
+
−  ULONG  cix_ref;
+
−  
+
−  switch (melem[e_ref].codingType)
+
−  {
+
−  case CCDTYPE_CSN1_S1: /* Fall through. */
+
−  case CCDTYPE_CSN1_S0:
+
−  case CCDTYPE_CSN1_SHL:
+
−  
+
−    cix_ref = melem[e_ref].calcIdxRef;
+
−    /*
+
−     * If this element is conditional, check the condition.
+
−     */
+
−    if (calcidx[cix_ref].numCondCalcs NEQ 0
+
−    AND ! ccd_conditionOK (e_ref, globs))
+
−      return TRUE;
+
−      
+
−    if (melem[e_ref].repType == 'i' AND 
+
−        calcidx[melem[e_ref].calcIdxRef].repCalcRef == 0)
+
−      return TRUE;
+
−    else 
+
−      return FALSE;
+
−//    break;
+
−//    PATCH FROM M18
+
−   case CCDTYPE_CSN1_CONCAT:
+
−      return TRUE;
+
−
+
−  default:
+
−    break;
+
−  }
+
−  
+
−  if (! melem[e_ref].optional)
+
−  {
+
−    /*
+
−     * if the element is an array with an interval [0..x]
+
−     * it can be handled like an optional element
+
−     */
+
−    if ( ! (melem[e_ref].repType EQ 'i'
+
−        AND calcidx[melem[e_ref].calcIdxRef].repCalcRef EQ 0))
+
−    {
+
−      /*
+
−       * if the element is not optional but it is a composition
+
−       * we check recursive if the composition consists only of
+
−       * optional elements
+
−       */
+
−      if (melem[e_ref].elemType EQ 'C' OR
+
−	      melem[e_ref].elemType EQ 'D' OR
+
−	      melem[e_ref].elemType EQ 'P')
+
−      {
+
−        ULONG el, lel, c_ref;
+
−        
+
−        c_ref = melem[e_ref].elemRef;
+
−
+
−        el = (ULONG) mcomp[c_ref].componentRef;
+
−        lel = el + mcomp[c_ref].numOfComponents;
+
−   
+
−        while (el < lel)
+
−        {
+
−          if (! ccd_isOptional (el, globs))
+
−            return FALSE;
+
−          el++;
+
−        }
+
−      }
+
−      else
+
−        return FALSE;
+
−    }
+
−  }
+
−  return TRUE; 
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)               MODULE  : CCD                   |
+
−| STATE   : code                     ROUTINE : ccd_decodeComposition |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : decodes the bitstream to a C-Structure.The decoding
+
−            rules contains the element definitions for the
+
−            elements of this message.
+
−            This function may called recursivly because of a
+
−            substructured element definition.
+
−*/
+
−
+
−void ccd_decodeComposition (const ULONG c_ref, T_CCD_Globs *globs)
+
−{
+
−  /*
+
−   * index in table melem
+
−   */
+
−  ULONG  e_ref;       /* element reference */
+
−  ULONG  l_ref;       /* reference to the last element of a component */
+
−  SHORT  codecRet;
+
−  BOOL   ExtendedGroupActive = FALSE;
+
−  BOOL   GroupExtended       = FALSE;
+
−  BOOL   MoreData;
+
−  BOOL   SetPosExpected = FALSE;
+
−  int    i;
+
−  ULONG  act_err_label;
+
−
+
−#ifdef DEBUG_CCD
+
−  #ifndef CCD_SYMBOLS
+
−  TRACE_CCD (globs, "ccd_decodeComposition()");
+
−  #else
+
−  TRACE_CCD (globs, "ccd_decodeComposition(): Composition = %s",
+
−               mcomp[c_ref].name);
+
−  #endif
+
−#endif
+
−
+
−  act_err_label = (ULONG) globs->errLabel;
+
−  globs->ccd_recurs_level++;
+
−
+
−  /*
+
−   * setup the index in the melem table for this composition.
+
−   * If this function is called for the first time
+
−   * (ccd_recurs_level == 1) the elem-table entry for the msg_type
+
−   * was skipped.
+
−   */
+
−
+
−  l_ref = mcomp[c_ref].componentRef
+
−           + mcomp[c_ref].numOfComponents;
+
−
+
−  e_ref  = mcomp[c_ref].componentRef
+
−           + ((globs->ccd_recurs_level EQ 1) ? 1 : 0);
+
−
+
−  /*
+
−   * decode all elements
+
−   */
+
−  while (e_ref < l_ref)
+
−  {
+
−#ifdef ERR_TRC_STK_CCD
+
−    /* save the value for tracing in error case */
+
−    globs->error_stack[globs->ccd_recurs_level] = (USHORT) e_ref;
+
−#endif /* ERR_TRC_STK_CCD */
+
−
+
−    if (melem[e_ref].extGroup != ' ' && GroupExtended && !ExtendedGroupActive)
+
−    {
+
−      /*
+
−       * the last read extension bit signals an
+
−       * extension of the group but there are no
+
−       * more elements defined for this group.
+
−       * This indicates a protocol extension, that must be
+
−       * skipped by ccd.
+
−       */
+
−
+
−      do
+
−      {
+
−        /*
+
−         * read the ext-bit to determine the extension
+
−         * of this group
+
−         */
+
−        GroupExtended = (bf_readBit (globs) EQ 0);
+
−        /*
+
−         * skip to next octett
+
−         */
+
−#ifdef DEBUG_CCD
+
−        TRACE_CCD (globs, "skipping 7 bits");
+
−#endif
+
−        bf_incBitpos (7, globs);
+
−      } while (GroupExtended);
+
−    }
+
−
+
−    /*
+
−     * check if the bitstream has ended
+
−     */
+
−    if (bf_endOfBitstream(globs) AND !globs->TagPending)
+
−    {
+
−        ULONG  cix_ref, num_prolog_steps;
+
−        
+
−        cix_ref = melem[e_ref].calcIdxRef;
+
−        num_prolog_steps = calcidx[cix_ref].numPrologSteps;
+
−        
+
−      /* End of the bit stream is not reached if a call to bf_setBitpos()
+
−       * is expected for the next element of the current substructure. 
+
−       * An instructive example is an empty "mob_id"
+
−       */
+
−      if (num_prolog_steps)
+
−      {
+
−        ULONG prolog_step_ref = calcidx[cix_ref].prologStepRef;
+
−        
+
−        i = (int) (prolog_step_ref + num_prolog_steps);
+
−        
+
−        while (i >= (int) prolog_step_ref)
+
−        {
+
−          if (calc[i].operation == 'S')
+
−          {
+
−            SetPosExpected = TRUE;
+
−            break;
+
−          }
+
−          i--;
+
−        }
+
−      }
+
−
+
−     if (SetPosExpected EQ FALSE)
+
−     {
+
−       /*
+
−        * no more bits to decode.
+
−        * If at least one mandatory element is to decode
+
−        * generate an error.
+
−        */
+
−
+
−        while (e_ref < l_ref)
+
−        {
+
−          if (! ccd_isOptional (e_ref, globs))
+
−            ccd_setError (globs, ERR_MAND_ELEM_MISS, BREAK, (USHORT) -1);
+
−
+
−          e_ref++;
+
−        }
+
−        /* after the while loop the recursion level will be decremented. */
+
−        break;
+
−      }
+
−    }
+
−
+
−    /*
+
−     * look for extension group processing
+
−     */
+
−    if (melem[e_ref].extGroup NEQ ' ')
+
−    {
+
−      /*
+
−       * extended group symbol found
+
−       */
+
−      switch (melem[e_ref].extGroup)
+
−      {
+
−        case '+':
+
−          /*
+
−           * start of an extended group
+
−           */
+
−          ExtendedGroupActive = TRUE;
+
−          /*
+
−           * read the extension bit to determine the extension
+
−           * of this group
+
−           */
+
−          GroupExtended = (bf_readBit (globs) EQ 0);
+
−          /*
+
−           * use the jump-table for selecting the decode function
+
−           */
+
−          codecRet =
+
−            codec[melem[e_ref].codingType][DECODE_FUN](c_ref,
+
−                                                         (USHORT)e_ref, globs);
+
−          if (codecRet NEQ 0x7f)
+
−          {
+
−            /*
+
−             * set the e_ref to the next or the same element
+
−             */
+
−            e_ref += codecRet;
+
−          }
+
−          break;
+
−
+
−        case '-':
+
−          /*
+
−           * end of one extension,
+
−           * decode first and the read the extension bit.
+
−           */
+
−          /*
+
−           * use the jump-table for selecting the decode function
+
−           */
+
−          codecRet =
+
−            codec[melem[e_ref].codingType][DECODE_FUN](c_ref,
+
−                                                         (USHORT)e_ref, globs);
+
−          if (codecRet NEQ 0x7f)
+
−          {
+
−            /*
+
−             * set the e_ref to the next or the same element
+
−             */
+
−            e_ref += codecRet;
+
−          }
+
−
+
−          /*
+
−           * look if the previously readed extension bit
+
−           * alows an extension of this group
+
−           */
+
−          if (!GroupExtended)
+
−          {
+
−
+
−            ExtendedGroupActive = FALSE;
+
−            /*
+
−             * overread the following elements in the group
+
−             */
+
−            /*
+
−             * search the last element of the extended group
+
−             */
+
−            while (e_ref < l_ref
+
−            AND melem[e_ref].extGroup NEQ '*')
+
−            {
+
−#ifdef DEBUG_CCD
+
−#ifdef CCD_SYMBOLS
+
−              if (melem[e_ref].elemType EQ 'V')
+
−                TRACE_CCD (globs, "Skipping ext-group element %s",
+
−                           ccddata_get_alias((USHORT) e_ref, 1));
+
−              else if (melem[e_ref].elemType EQ 'C')
+
−                TRACE_CCD (globs, "Skipping ext-group element %s",
+
−                           mcomp[melem[e_ref].elemRef].name);
+
−              else
+
−                TRACE_CCD (globs, "Skipping ext-group spare");
+
−#else
+
−              TRACE_CCD (globs, "Skipping ext-group element %c-%d",
+
−                         melem[e_ref].elemType,
+
−                         e_ref);
+
−
+
−#endif
+
−#endif
+
−              e_ref++;
+
−            }
+
−            /*
+
−             * skip the last element
+
−             */
+
−            e_ref++;
+
−          }
+
−          else
+
−          {
+
−            /*
+
−             * read the extension bit to determine if the group
+
−             * extension holds on
+
−             */
+
−            GroupExtended = (bf_readBit (globs) EQ 0);
+
−          }
+
−          break;
+
−
+
−        case '*':
+
−          if (!ExtendedGroupActive)
+
−          {
+
−            /*
+
−             * this is a single element extended group
+
−             * often used for later extension of the protocol
+
−             */
+
−            /*
+
−             * read the extension bit to determine if a group
+
−             * extension is present
+
−             */
+
−            GroupExtended = (bf_readBit (globs) EQ 0);
+
−          }
+
−          ExtendedGroupActive = FALSE;
+
−
+
−          /*
+
−           * use the jump-table for selecting the decode function
+
−           */
+
−          codecRet =
+
−            codec[melem[e_ref].codingType][DECODE_FUN](c_ref, e_ref, globs);
+
−          if (codecRet NEQ 0x7f)
+
−          {
+
−            /*
+
−             * set the e_ref to the next or the same element
+
−             */
+
−            e_ref += codecRet;
+
−          }
+
−          break;
+
−
+
−        case '!': /* Moredata bit */
+
−        case '#':
+
−          if ((MoreData = bf_readBit (globs)) EQ 1)
+
−          {
+
−            /*
+
−             * moredata-bit is set to 1
+
−             * process this element.
+
−             */
+
−
+
−            /*
+
−             * use the jump-table for selecting the decode function
+
−             */
+
−            codecRet =
+
−              codec[melem[e_ref].codingType][DECODE_FUN](c_ref, e_ref, globs);
+
−
+
−            if (melem[e_ref].extGroup EQ '#')
+
−            {
+
−              /*
+
−               * if more data are signaled with an additional
+
−               * bit but there are no
+
−               * more elements defined for this group.
+
−               * This indicates a protocol extension, that must be
+
−               * skipped by ccd.
+
−               */
+
−
+
−              do
+
−              {
+
−                /*
+
−                 * read the ext-bit to determine the extension
+
−                 * of this group
+
−                 */
+
−                GroupExtended = (bf_readBit (globs) EQ 1);
+
−                /*
+
−                 * skip to next octett
+
−                 */
+
−          #ifdef DEBUG_CCD
+
−                TRACE_CCD (globs, "skipping 7 bits");
+
−          #endif
+
−                bf_incBitpos (7, globs);
+
−              } while (!bf_endOfBitstream(globs) AND GroupExtended);
+
−
+
−            }
+
−
+
−            if (codecRet NEQ 0x7f)
+
−            {
+
−              /*
+
−               * set the elemRef to the next or the same element(USHORT)
+
−               */
+
−              e_ref += codecRet;
+
−            }
+
−          }
+
−
+
−          if (!MoreData)
+
−          {
+
−            /*
+
−             * more data bit is cleared,
+
−             * overread the following elements in the group
+
−             * search the last element of the extended group
+
−             */
+
−            while (e_ref < l_ref
+
−            AND melem[e_ref].extGroup NEQ '#')
+
−            {
+
−#ifdef DEBUG_CCD
+
−#ifdef CCD_SYMBOLS
+
−              if (melem[e_ref].elemType EQ 'V')
+
−                TRACE_CCD (globs, "Skipping ext-group element %s",
+
−                           ccddata_get_alias((USHORT) e_ref, 1));
+
−              else if (melem[e_ref].elemType EQ 'C')
+
−                TRACE_CCD (globs, "Skipping ext-group element %s",
+
−                           mcomp[melem[e_ref].elemRef].name);
+
−              else
+
−                TRACE_CCD (globs, "Skipping ext-group spare");
+
−#else
+
−              TRACE_CCD (globs, "Skipping ext-group element %c-%d",
+
−                         melem[e_ref].elemType,
+
−                         e_ref);
+
−
+
−#endif
+
−#endif
+
−              e_ref++;
+
−            }
+
−
+
−            /*
+
−             * skip the last element of the moredata group
+
−             */
+
−            e_ref++;
+
−          }
+
−          break;
+
−        default:
+
−          ccd_setError (globs, ERR_DEFECT_CCDDATA, BREAK, 
+
−                        (USHORT) (globs->bitpos), (USHORT) -1);
+
−          break;
+
−      }
+
−    }
+
−    else
+
−    {
+
−      /*
+
−       * no processing action for an extended group
+
−       */
+
−
+
−      /*
+
−       * use the jump-table for selecting the decode function
+
−       */
+
−      codecRet =
+
−        codec[melem[e_ref].codingType][DECODE_FUN](c_ref, e_ref, globs);
+
−      if (codecRet NEQ 0x7f)
+
−      {
+
−        /*
+
−         * set the e_ref to the next or the same element
+
−         */
+
−        e_ref += codecRet;
+
−      }
+
−    }
+
−  }
+
−
+
−  /* Reset indicator of exhaustion in the IEI table*/
+
−  for (i = 0; globs->iei_ctx[globs->ccd_recurs_level].iei_table[i].valid== TRUE; i++)
+
−  {
+
−    globs->iei_ctx[globs->ccd_recurs_level].iei_table[i].exhausted = FALSE;
+
−    globs->iei_ctx[globs->ccd_recurs_level].iei_table[i].act_amount = 0;
+
−
+
−  }
+
−
+
−  globs->iei_ctx[globs->ccd_recurs_level].countSkipped = 0;
+
−  globs->ccd_recurs_level--;
+
−  globs->errLabel  = (U8) act_err_label;
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
− * Attention: if this static function shall be used in
+
− * both, internal as well as external RAM, it must be made global.
+
− */
+
−static void SkipExtensionOctets (ULONG *e_ref, ULONG l_ref)
+
−{
+
−  /* The extended group is terminated. Skip over its IEs. */
+
−  while (*e_ref < l_ref && melem[*e_ref].extGroup != '*')
+
−    (*e_ref)++;
+
−  if (*e_ref < l_ref)
+
−    (*e_ref)++;
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
− * Attention: if this static function shall be used in
+
− * both, internal as well as external RAM, it must be made global.
+
− */
+
−LOCAL BOOL CheckBP_RecodeXB (ULONG ExtBitPos1, ULONG ExtBitPos2, 
+
−                             ULONG ExtBitPos3, T_CCD_Globs *globs)
+
−{
+
−  /* Absence due to validity flag, condition or a ccdWarning. */
+
−  if (ExtBitPos3 == globs->bitpos )
+
−  {
+
−    globs->bitpos --;    
+
−    if (ExtBitPos1 NEQ ExtBitPos2)
+
−      bf_recodeBit ((USHORT) ExtBitPos1, 1, globs);
+
−    return FALSE;
+
−  }
+
−  return TRUE;
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)               MODULE  : CCD                   |
+
−| STATE   : code                     ROUTINE : ccd_encodeComposition |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : codes the content of a C-Structure into a bitstream.
+
−            This function may be called recursivly if an IE in the
+
−            structure is itself a structured IE.
+
−
+
−            For extended octet groups the following rules apply.
+
−            
+
−            Any IE within an extension octet is characterised by its 
+
−            extGroup which is one of the following:
+
−            
+
−            
+
−            '+'    octet begins with this IE.
+
−            ' '    octet continues with this IE or a new octet begins.
+
−            '-'    octet ends with this IE.
+
−            '*'    octet group ends with this IE.
+
−            
+
−            An octet may begin with '+', '-', ' ' or '*'.
+
−            An octet beginning with '-' or '*' is made of only one IE (7 bits).
+
−            A group made of one octet has only one IE with '*'.
+
−            If '+' is present, next IEs ending with '*' or '-' are present too.
+
−            If the beginning IE  with ' ' is not IE
+
−
+
−            Examples of extended group configurations.
+
−             _ _      _ _ _ 
+
−            | | |    | | | |
+
−            |+|*|    |+| |*|  one octet
+
−            |_|_|    |_|_|_|
+
−
+
−             _ _ _ _      _ _ _      _ _ _ _ 
+
−            | | | | |    | | | |    | | | | |
+
−            |+|-| |*|    |+|-|*|    |+| |-|*|  two octets
+
−            |_|_|_|_|    |_|_|_|    |_|_|_|_|
+
−
+
−
+
−             _ _ _ _ _ _ _ _ _ _ 
+
−            | | | | | | | | | | |
+
−            |+| | |-| |-| |-| |*|   four octets
+
−            |_|_|_|_|_|_|_|_|_|_|
+
−            
+
−            Also groups after groups are possible.
+
−             _ _ _ _ _ _ _ _ _
+
−            | | | | | | | | | |
+
−            |+| |-| |*|+|*|*|*|
+
−            |_|_|_|_|_|_|_|_|_|
+
−            
+
−            The status of encoding is given as follows:
+
−
+
−            ExtendedGroupActive is set to 1 if '+' is present in the encoding.
+
−            ExtendedGroupActive is changed from 1 to 0 when encoding '*'.
+
−            ExtendedGroupActive is set to 0 if an octet beginning with ' ' is
+
−            not present.
+
−            OpenNewOctet is set to 1 after encoding an IE with '-'.
+
−            ExtBitPos1 is set to the globs->bitpos when writing extension bit:
+
−            1) for '+' or 
+
−            2) for ' ' after '-'
+
−
+
−            Extension bit is set to 0 if a further octet is encoded for
+
−            the group. If an octet is the last one within a group, the 
+
−            extension bit is set to 1.
+
−
+
−            While processing the first IE of an octet (e.g. for '+'),
+
−            if the IE is absent, CCD will skip over all IEs up to the
+
−            ending '*'.
+
−            When processing IEs with ' ' and for ExtendedGroupActive=1 the valid
+
−            flag is set to 1 in order to compensate probable mistakes in PS.
+
−
+
−*/
+
−
+
−void ccd_encodeComposition (const ULONG c_ref, T_CCD_Globs *globs)
+
−{
+
−  ULONG  e_ref;
+
−  ULONG  l_ref;
+
−  BOOL   ExtendedGroupActive = FALSE, OpenNewOctet = FALSE;
+
−  ULONG  ext_bit_pos1=0, ext_bit_pos2=0, ext_bit_pos3=0, more_data_bit_pos=0;
+
−  int    ext_bit_pending=0;
+
−  UBYTE  codecRet;
+
−
+
−
+
−#ifdef DEBUG_CCD
+
−  #ifndef CCD_SYMBOLS
+
−    TRACE_CCD (globs, "ccd_encodeComposition()");
+
−  #else
+
−    TRACE_CCD (globs, "ccd_encodeComposition(): Composition = %s",
+
−               mcomp[c_ref].name);
+
−    #endif
+
−#endif
+
−
+
−  globs->ccd_recurs_level++;
+
−
+
−  /*
+
−   * setup the index in the melem table for this composition.
+
−   * If this function is called for the first time
+
−   * (ccd_recurs_level == 1) the elem-table entry for the msg_type
+
−   * was skipped.
+
−   */
+
−
+
−  l_ref = (USHORT)(mcomp[c_ref].componentRef
+
−           + mcomp[c_ref].numOfComponents);
+
−
+
−  e_ref  = (USHORT)(mcomp[c_ref].componentRef
+
−           + ((globs->ccd_recurs_level EQ 1) ? 1 : 0));
+
−
+
−  /*
+
−   * code all elements
+
−   */
+
−  while (e_ref < l_ref)
+
−  {
+
−#ifdef ERR_TRC_STK_CCD
+
−    /* 
+
−     * Save the value for tracing in error case.
+
−     */
+
−    globs->error_stack[globs->ccd_recurs_level] = (USHORT) e_ref;
+
−#endif /* ERR_TRC_STK_CCD */
+
−
+
−    /*
+
−     * look for extension group processing
+
−     */
+
−    if (melem[e_ref].extGroup NEQ ' ')
+
−    {
+
−      /*
+
−       * extended group symbol found
+
−       */
+
−      switch (melem[e_ref].extGroup)
+
−      {
+
−        case '+':
+
−
+
−          /*
+
−           * remember the position of the extension bit
+
−           * because we maybe have to recode it.
+
−           */
+
−          ext_bit_pos1 = ext_bit_pos2 = (ULONG) globs->bitpos;
+
−
+
−
+
−          /*
+
−           * write the extension bit. It may overwritten
+
−           * later. (ext=0 -> group extended)
+
−           */
+
−          bf_writeBit (0, globs);
+
−          ext_bit_pos3 = (USHORT) globs->bitpos;
+
−
+
−#if defined(_TOOLS_)
+
−      if (ccd_patch (globs, 0))
+
−        codecRet = 1;
+
−      else
+
−#endif /* _TOOLS_ */
+
−          /* Use the jump-table for selecting encode function. */
+
−          codecRet = (UBYTE)
+
−            codec[melem[e_ref].codingType][ENCODE_FUN](c_ref, e_ref, globs);
+
−
+
−          /* Absence due to validity flag, conditions or a ccdWarning. */
+
−          if (!CheckBP_RecodeXB (ext_bit_pos1, ext_bit_pos2, ext_bit_pos3, globs))
+
−          {
+
−            ExtendedGroupActive = FALSE;
+
−            SkipExtensionOctets (&e_ref, l_ref);
+
−            continue;
+
−          }
+
−          /* Start of an extended group */
+
−          else
+
−          {
+
−            OpenNewOctet = FALSE;
+
−          }
+
−
+
−          ExtendedGroupActive = TRUE;
+
−          ext_bit_pending = 1;
+
−
+
−          if (codecRet NEQ 0x7f)
+
−          {
+
−            /* Set the elemRef to the next or the same element. */
+
−            e_ref += codecRet;
+
−          }
+
−          break;
+
−
+
−        /* End of one extension octet. */
+
−        case '-':
+
−          /* IE must be present if the previous one was not with '-'. */
+
−          if (OpenNewOctet == FALSE)
+
−          {
+
−#ifdef DEBUG_CCD
+
−            if (globs->pstruct [melem[e_ref].structOffs] != TRUE)
+
−            {
+
−              TRACE_CCD (globs, "Wrong value for valid flag!\n...changed to 1 for ccdID=%d",
+
−                         e_ref);
+
−            }
+
−#endif
+
−            /* IE has to be present. Don't trust PS code. */
+
−            globs->pstruct [melem[e_ref].structOffs] = TRUE;
+
−          }
+
−          ext_bit_pos3 = (USHORT) globs->bitpos;
+
−
+
−#if defined(_TOOLS_)
+
−      if (ccd_patch (globs, 0))
+
−        codecRet = 1;
+
−      else
+
−#endif /* _TOOLS_ */
+
−          /* Use the jump-table for selecting encode function. */
+
−          codecRet = (UBYTE)
+
−            codec[melem[e_ref].codingType][ENCODE_FUN](c_ref, e_ref, globs);
+
−
+
−          if (OpenNewOctet == TRUE)
+
−          {
+
−            /* Absence due to validity flag, conditions or a ccdWarning. */
+
−            if (!CheckBP_RecodeXB (ext_bit_pos1, ext_bit_pos2, ext_bit_pos3, globs))
+
−            {
+
−              ExtendedGroupActive = FALSE;
+
−              SkipExtensionOctets (&e_ref, l_ref);
+
−              continue;
+
−            }
+
−          }
+
−          
+
−          if (codecRet NEQ 0x7f)
+
−          {
+
−          /* Set the elemRef to the next or the same element. */
+
−            e_ref += codecRet;
+
−          }
+
−
+
−          /* IE with '-' belongs to the first octet. */
+
−          if (ext_bit_pending EQ 1)
+
−          {
+
−            ext_bit_pending++;
+
−          }
+
−          /*
+
−           * At least one octet has been encoded for the current group.
+
−           * Swap the stored positions of the extension bits.
+
−           */
+
−          else
+
−          {
+
−            ext_bit_pos1 = ext_bit_pos2;
+
−          }
+
−
+
−          /*
+
−           * Store the position of the extension bit
+
−           * because we maybe have to recode it.
+
−           */
+
−          ext_bit_pos2 = (ULONG) globs->bitpos;
+
−          /*
+
−           * write the extension bit. It may overwritten
+
−           * later. (ext=0 -> group extended)
+
−           */
+
−          bf_writeBit (0, globs);
+
−          OpenNewOctet = TRUE;
+
−
+
−          break;
+
−
+
−        case '*':
+
−          if (!ExtendedGroupActive)
+
−          {
+
−            /*
+
−             * This is a single element extended group, often
+
−             * used for later extension of the protocol
+
−             * Write '1' in extension bit since group is not extended yet.
+
−             */
+
−            bf_writeBit (1, globs);
+
−            ext_bit_pos3 = (USHORT) globs->bitpos;
+
−
+
−#if defined(_TOOLS_)
+
−      if (ccd_patch (globs, 0))
+
−        codecRet = 1;
+
−      else
+
−#endif /* _TOOLS_ */
+
−            /* Use the jump-table for selecting encode function. */
+
−            codecRet = (UBYTE)
+
−              codec[melem[e_ref].codingType][ENCODE_FUN](c_ref, e_ref, globs);
+
−            /* Absence due to the valid flag or a ccdWarning. */
+
−            if (ext_bit_pos3 == globs->bitpos)
+
−            {
+
−              globs->bitpos --;
+
−            }
+
−
+
−            if (codecRet NEQ 0x7f)
+
−            {
+
−              /* Set the elemRef to the next or the same element. */
+
−              e_ref += codecRet;
+
−            }
+
−          }
+
−          else
+
−          {
+
−            ExtendedGroupActive = FALSE;
+
−            /* IE must be present if the previous one was not with '-'. */
+
−            if (OpenNewOctet == FALSE)
+
−            {
+
−#ifdef DEBUG_CCD
+
−              if (globs->pstruct [melem[e_ref].structOffs] != TRUE)
+
−              {
+
−                TRACE_CCD (globs, "Wrong value for valid flag!\n...changed to 1 for ccdID=%d",
+
−                           e_ref);
+
−              }
+
−#endif
+
−              /* IE has to be present. Don't trust PS code. */
+
−              globs->pstruct [melem[e_ref].structOffs] = TRUE;
+
−            }
+
−
+
−#if defined(_TOOLS_)
+
−      if (ccd_patch (globs, 0))
+
−        codecRet = 1;
+
−      else
+
−#endif /* _TOOLS_ */
+
−             /* Use the jump-table for selecting the encode function. */
+
−            codecRet = (UBYTE)
+
−              codec[melem[e_ref].codingType][ENCODE_FUN](c_ref, e_ref, globs);
+
−            ext_bit_pos3 = (USHORT) globs->bitpos;
+
−
+
−            if (codecRet NEQ 0x7f)
+
−            {
+
−              /* Set the elemRef to the next or the same element. */
+
−              e_ref += codecRet;
+
−            }
+
−
+
−            if ((ext_bit_pos3-1) NEQ ext_bit_pos2)
+
−            {
+
−              /*
+
−               * if the writepointer (ext_bit_pos3) have incremented
+
−               * since the first extension bit (NEQ ext_bit_pos1)
+
−               * at least one element of this group is valid
+
−               * and written into the bitstream.
+
−               */
+
−              /*
+
−               * the extended group is terminated,
+
−               * so we have to switch the previously written
+
−               * extBit from 0 to 1
+
−               */
+
−              bf_recodeBit ((USHORT) ext_bit_pos2, 1, globs);
+
−            }
+
−            else
+
−            {
+
−              /*
+
−               * break of an extended group, no element are coded
+
−               * since the last extension bit.
+
−               */
+
−              /*
+
−               * the extended group is terminated,
+
−               * so we have to switch the previously written
+
−               * extBit from 0 to 1
+
−               */
+
−              if (ext_bit_pos1 NEQ ext_bit_pos2)
+
−              {
+
−                bf_recodeBit ((USHORT) ext_bit_pos1, 1, globs);
+
−              }
+
−              /*
+
−               * delete the written ext-bit because the extended
+
−               * group ended.
+
−               */
+
−              bf_setBitpos ((USHORT) ext_bit_pos2, globs);
+
−            }
+
−          }
+
−          break;
+
−        case '!':
+
−        case '#':
+
−          more_data_bit_pos = (ULONG) globs->bitpos;
+
−          bf_writeBit (1, globs);
+
−
+
−#if defined(_TOOLS_)
+
−      if (ccd_patch (globs, 0))
+
−        codecRet = 1;
+
−      else
+
−#endif /* _TOOLS_ */
+
−          /*
+
−           * use the jump-table for selecting the encode function
+
−           */
+
−          codecRet = (UBYTE)
+
−            codec[melem[e_ref].codingType][ENCODE_FUN](c_ref, e_ref, globs);
+
−          if (codecRet NEQ 0x7f)
+
−          {
+
−            if (more_data_bit_pos+1 EQ globs->bitpos)
+
−            {
+
−              /*
+
−               * rewrite the written moredata bit to 0
+
−               */
+
−              bf_setBitpos (more_data_bit_pos, globs);
+
−              bf_writeBit (0, globs);
+
−              /*
+
−               * no coding performed -> extension group ended
+
−               * We skip all elements in this group
+
−               */
+
−              while (melem[e_ref].extGroup EQ '!')
+
−                e_ref++;
+
−
+
−              if (melem[e_ref].extGroup EQ '#')
+
−                e_ref++;
+
−            }
+
−            else
+
−            {
+
−              if (melem[e_ref].extGroup EQ '#')
+
−              {
+
−                /*
+
−                 * code a zero bit for the last element
+
−                 */
+
−                bf_writeBit (0, globs);
+
−              }
+
−              e_ref++;
+
−            }
+
−          }
+
−          break;
+
−        default:
+
−          ccd_setError (globs, ERR_DEFECT_CCDDATA, BREAK, 
+
−                      (USHORT) (globs->bitpos), (USHORT) -1);
+
−        break;
+
−      }
+
−    }
+
−    else
+
−    {
+
−      if (ExtendedGroupActive)
+
−      {
+
−        ext_bit_pos3 = (USHORT) globs->bitpos;
+
−
+
−        /* IE in the middle part of an ext-octet. */
+
−        if (OpenNewOctet == FALSE)
+
−        {
+
−#ifdef DEBUG_CCD
+
−          if (globs->pstruct [melem[e_ref].structOffs] != TRUE)
+
−          {
+
−            TRACE_CCD (globs, "Wrong value for valid flag!\n...changed to 1 for ccdID=%d",
+
−                       e_ref);
+
−          }
+
−#endif
+
−          globs->pstruct [melem[e_ref].structOffs] = TRUE;
+
−        }
+
−      }
+
−
+
−#if defined(_TOOLS_)
+
−      if (ccd_patch (globs, 0))
+
−        codecRet = 1;
+
−      else
+
−#endif /* _TOOLS_ */
+
−      /* Use the jump-table for selecting encode function. */
+
−      codecRet = (UBYTE)
+
−        codec[melem[e_ref].codingType][ENCODE_FUN](c_ref, e_ref, globs);
+
−
+
−      /* The following is only meant for IEs after an IE with '-'. */
+
−      if (ExtendedGroupActive)
+
−      {
+
−        if (OpenNewOctet == TRUE)
+
−        {
+
−          /* Absence due to validity flag, conditions or a ccdWarning. */
+
−          if (!CheckBP_RecodeXB (ext_bit_pos1, ext_bit_pos2, ext_bit_pos3, globs))
+
−          {
+
−            ExtendedGroupActive = FALSE;
+
−            SkipExtensionOctets (&e_ref, l_ref);
+
−            continue;
+
−          }
+
−          /* Start of an extension octet */
+
−          else
+
−          {
+
−            OpenNewOctet = FALSE;
+
−          }
+
−        }
+
−      }
+
−
+
−      if (codecRet NEQ 0x7f)
+
−      {
+
−        /* Set the elemRef to the next or the same element. */
+
−        e_ref += codecRet;
+
−      }
+
−    }
+
−  }
+
−
+
−  globs->ccd_recurs_level--;
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−/* ---------------------------------------------------------------- */
+
−/* GLOBAL FUNCTIONS                                                 */
+
−/* ---------------------------------------------------------------- */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
−+------------------------------------------------------------------------------
+
−|  Function     :  ccd_check_pointer
+
−+------------------------------------------------------------------------------
+
−|  Description  :  This function checks the validity of a pointer
+
−|
+
−|  Parameters   :  ptr - the pointer
+
−|
+
−|  Return       :  ccdOK if pointer valid, otherwise ccdError
+
−+------------------------------------------------------------------------------
+
−*/
+
−int ccd_check_pointer (U8* ptr)
+
−{
+
−  if (!ptr || ptr == mempat
+
−#ifdef WIN32
+
−      /* For windows: check also if ptr is too small */
+
−      || !(ptr && LOWSEGMASK)
+
−#endif
+
−     )
+
−  {
+
−    return ccdError;
+
−  }
+
−  return ccdOK;
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)               MODULE  : CCD                   |
+
−| STATE   : code                     ROUTINE : ccd_begin             |
+
−+--------------------------------------------------------------------+
+
−
+
−
+
−  PARAMETERS:  none
+
−
+
−  PURPOSE:     Returns the address of the CCD buffer for decoded
+
−               messages and locks it until ccd_end() is called
+
−
+
−*/
+
−
+
−UBYTE* CCDDATA_PREF(ccd_begin) (void)
+
−{
+
−#ifdef SHARED_CCD
+
−  /*
+
−   * if the CCD is used in a premptive multithreaded system
+
−   * we must lock this critical section
+
−   */
+
−  vsi_s_get (VSI_CALLER semCCD_Buffer);
+
−#endif
+
−
+
−#ifdef DEBUG_CCD
+
−{
+
−  #ifndef _TMS470
+
−  T_CCD_Globs globs;
+
−  globs.me = 0;
+
−  globs.TraceIt = 1;
+
−  TRACE_CCD (&globs, "CCD Begin");
+
−  #endif
+
−}
+
−#endif
+
−  return ccd_decMsgBuffer;
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)               MODULE  : CCD                   |
+
−| STATE   : code                     ROUTINE : ccd_end               |
+
−+--------------------------------------------------------------------+
+
−
+
−
+
−  PARAMETERS:  none
+
−
+
−  PURPOSE:     Unlocks the CCD buffer for decoded
+
−               messages
+
−
+
−*/
+
−
+
−void CCDDATA_PREF(ccd_end) (void)
+
−{
+
−#ifdef SHARED_CCD
+
−  /*
+
−   * if the CCD is used in a premptive multithreaded system
+
−   * we must unlock this critical section of accessing the
+
−   * decoded message buffer
+
−   */
+
−  vsi_s_release (VSI_CALLER semCCD_Buffer);
+
−#endif
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)               MODULE  : CCD                   |
+
−| STATE   : code                     ROUTINE : ccd_GetGlobVars       |
+
−+--------------------------------------------------------------------+
+
−
+
−
+
−  PARAMETERS:  
+
−
+
−  PURPOSE:     Determines which set of global variables to use
+
−               and locks the CCD buffer (semaphore) if necessary.
+
−
+
−*/
+
−T_CCD_Globs* ccd_GetGlobVars (T_CCD_ERR_LIST_HEAD** eentry, T_CCD_STORE_LIST** stoentry)
+
−{
+
−  T_CCD_TASK_TABLE* tentry;
+
−#ifndef SHARED_CCD
+
−  int me = 0;
+
−#else
+
−  T_HANDLE me;
+
−  me = vsi_e_handle (0, NULL);
+
−  if (me == VSI_ERROR)
+
−    me = 0;
+
−#endif /* !SHARED_CCD */
+
−
+
−  tentry = ccd_task_list[me];
+
−  tentry->ccd_globs->me = me;
+
−  *eentry = tentry->ccd_err_list;
+
−  *stoentry = tentry->ccd_store;
+
−#ifdef SHARED_CCD
+
−  if (tentry->ccd_globs == &globs_all)
+
−  {
+
−    /*
+
−     * if the CCD is used in a premptive multithreaded system
+
−     * we must lock this critical section
+
−     */
+
−    vsi_s_get (VSI_CALLER semCCD_Codec);
+
−  }
+
−#endif /* SHARED_CCD */
+
−  return tentry->ccd_globs;
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)               MODULE  : CCD                   |
+
−| STATE   : code                     ROUTINE : ccd_FreeGlobVars      |
+
−+--------------------------------------------------------------------+
+
−
+
−
+
−  PARAMETERS:  none
+
−
+
−  PURPOSE:     Unlocks the CCD buffer for decoded messages 
+
−               if the entity is not GRR and if 
+
−               the CCD is used in a premptive multithreaded system.
+
−
+
−*/
+
−void ccd_FreeGlobVars (T_CCD_Globs* globs)
+
−{
+
−#ifdef SHARED_CCD
+
−  if (globs == &globs_all)
+
−  {   
+
−    vsi_s_release (VSI_CALLER semCCD_Codec);
+
−  }
+
−#endif /* SHARED_CCD */
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−#ifdef DEBUG_CCD
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)               MODULE  : CCD                   |
+
−| STATE   : code                     ROUTINE : ccd_dump_msg          |
+
−+--------------------------------------------------------------------+
+
−
+
−  PARAMETERS:  U16 l_buf
+
−                - Number of bits in the encoded message or IE.
+
−
+
−               U16 o_buf
+
−                - Offset of the bitstream buffer in bits.
+
−
+
−               U8 *buf
+
−                - Bitstream buffer of the encoded message or IE.
+
−
+
−               T_CCD_Globs globs
+
−                - Pointer to global variables
+
−
+
−  PURPOSE:     Dump contents of air interface message - for debugging
+
−
+
−*/
+
−void ccd_dump_msg (U16 l_buf, U16 o_buf, U8 *buf, T_CCD_Globs *globs)
+
−{
+
−
+
−  if (!globs->TraceIt)
+
−    return;
+
−  else
+
−  {
+
−    int  i, j, buflen;
+
−    char s[64], c[4];
+
−
+
−    buflen = (l_buf + o_buf + 7) >> 3;
+
−    TRACE_CCD (globs, "-------------------------------------------------");
+
−    TRACE_CCD (globs, " CCD: Decode Message");
+
−    TRACE_CCD (globs, " Before DECODING: lbuf= %d, obuf= %d", l_buf, o_buf);
+
−    TRACE_CCD (globs, " Hex dump of message to be decoded:");
+
−
+
−    s[0] = '\0';
+
−    for (i = o_buf>>3; i < buflen; i+=16)
+
−    {
+
−      for (j = 0; j < 16; j++)
+
−      {
+
−	if ((i+j) < buflen)
+
−	{
+
−	  sprintf(c, " %02x", buf[i+j]);
+
−	  strcat (s, c);
+
−	}
+
−      }
+
−      TRACE_CCD (globs, "%s", s);
+
−      s[0] = '\0';
+
−    }
+
−  }
+
−}
+
−#endif /* DEBUG_CCD */
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)               MODULE  : CCD                   |
+
−| STATE   : code                     ROUTINE : ccd_common_decode_init|
+
−+--------------------------------------------------------------------+
+
−
+
−  PARAMETERS:  
+
−
+
−  PURPOSE:     Perform common CCD initialization before message decode.
+
−
+
−*/
+
−void ccd_common_decode_init(U16 l_buf, U16 o_buf, U8 *buf, T_CCD_Globs *globs)
+
−{
+
−#if defined (DEBUG_CCD)
+
−  /* to avoid the vsprintf if the traces won't appear anyhow */
+
−  ULONG mask;
+
−  if (vsi_gettracemask (globs->me, globs->me, &mask) != VSI_ERROR)
+
−  {
+
−    globs->TraceIt = mask & TC_CCD;
+
−  }
+
−#endif
+
−
+
−  /*
+
−   * no call to setjmp() done. So ccd_Error performs no longjmp in
+
−   * case of an error
+
−   */
+
−  globs->jmp_mark_set = FALSE;
+
−
+
−  /* setup the bitbuffer */
+
−  globs->bitbuf = buf;
+
−  globs->bitpos = 0;
+
−
+
−  /* cleanup the read-caches */
+
−  globs->lastbytepos16 = globs->lastbytepos32 = 0xffff;
+
−
+
−  /* setup the bitoffset */
+
−  globs->bitoffs = o_buf;
+
−
+
−  
+
−  bf_incBitpos (o_buf, globs);
+
−
+
−  /*
+
−   * calclate the max bitpos to read
+
−   */
+
−  globs->buflen = l_buf + o_buf;
+
−  globs->maxBitpos = globs->buflen;
+
−  globs->msgLen = globs->buflen;
+
−  globs->errLabel = 0;
+
−  globs->continue_array = TRUE;
+
−  globs->SeekTLVExt = TRUE;
+
−
+
−  globs->ccd_recurs_level = 0;
+
−  globs->CCD_Error = ccdOK;
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
− * Attention: if this static function shall be used in
+
− * both, internal as well as external RAM, it must be made global.
+
− */
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)               MODULE  : CCD                   |
+
−| STATE   : code                     ROUTINE : SeekForGSMExtensions  |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE:     Check if there are elements left in the air message
+
−               without being decoded. Assume that the next IE has the
+
−               type T, TV or a TLV. Seek for Comprehension Required
+
−               extensions.
+
−               1) Rules to distinguish between the types:
+
−               handling of unknown IEs (GSM 04.07, section 11.2.4)
+
−               "Bit 8 of the IEI octet is set to "1" indicates a TV 
+
−               formatted type 1 standard IE or a T formatted type 2 
+
−               IEs, and to "0" indicates a TLV formatted type 4 IE. 
+
−               Hence, a 1 valued bit 8 indicates that the whole IE is 
+
−               one octet long, and a 0 valued bit 8 indicates that the
+
−               following octet is a length octet.
+
−               1) Rules to read the length:
+
−               For TLV4 encode L in one byte.
+
−               For TLV5 and ASN.1 encode in one byte or more. Use
+
−               0x81, 0x82 etc in the first byte to say L is encoded
+
−               in one, two etc bytes.
+
−               For ASN.1 BER type use 0x80 in the first byte and
+
−               two otets of 0 bits after the encoded IE.
+
−               For all the three types it is possible to encode L
+
−               in only one byte.
+
−               TLV6 is not supported. TLV6 is not a GSM standard 
+
−               type. It has been defined in g23net software.
+
−*/
+
−static void SeekForGSMExtensions (U8 entity, T_CCD_Globs *globs)
+
−{
+
−  U8 *MsgBuf = (U8*)globs->bitbuf;
+
−  U16 BP = globs->bytepos;
+
−  U16 OctNr = (globs->buflen+7) >> 3;
+
−  U16 errPos = 0;
+
−  U8 errTag = 0xFF;
+
−  U8 errCode;
+
−
+
−#ifdef DEBUG_CCD
+
−  TRACE_CCD( globs, "SeekForGSMExtensions...");
+
−#endif
+
−  while (BP < OctNr)
+
−  {
+
−    U8 T = MsgBuf[BP];
+
−    BOOL tlv5 = FALSE;
+
−
+
−    /* Expecting a CCDTYPE_GSM5_TLV type we get an unknown tag with MSB set.
+
−     * 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.
+
−     */
+
−    tlv5 = (aim_sat == entity);
+
−    if ( (tlv5 && ((T & 0x80) == 0x80))
+
−        ||
+
−         (!tlv5 && ((T & 0xf0) == 0)) )
+
−    {
+
−      errTag = T;
+
−      errPos = BP*8;
+
−      errCode = ERR_COMPREH_REQUIRED;
+
−      /* Report error. Do not analyse the rest. */
+
−      break;
+
−    }
+
−    else
+
−    {
+
−      errTag = T;
+
−      errPos = BP*8;
+
−      errCode = ERR_IE_NOT_EXPECTED;
+
−    }
+
−
+
−    /* The type is TLV or ASN.1. */
+
−    if ((T & 0x80) NEQ 0x80)
+
−    { 
+
−      /* BP points to the first L byte */
+
−      U16 L = MsgBuf[++BP]; 
+
−      switch (L)
+
−      {
+
−        /* End Of Content (ASN.1 BER) */
+
−        case 0x80:
+
−          do
+
−          {
+
−            BP++;
+
−          } while ((*(U16*)&MsgBuf[BP]) != 0 && BP < OctNr);
+
−          BP++;
+
−          L = 0;
+
−          break;
+
−
+
−        /* Length encoding in two bytes */
+
−        case 0x81:
+
−          L = MsgBuf[++BP];
+
−          break;
+
−
+
−        /* Length encoding in three bytes */
+
−        case 0x82:
+
−          L = (MsgBuf[++BP]) << 8;
+
−          L |= MsgBuf[++BP];
+
−          break;
+
−
+
−        /* Length encoding in one byte. */
+
−        default:
+
−          break;
+
−      }
+
−
+
−      /* Skip over the bytes. */
+
−      while (L > 0 && BP < OctNr)
+
−      {
+
−        --L;
+
−        ++BP;
+
−      } 
+
−
+
−    } /* if TLV */
+
−    /* else: The type is T or TV. Skip one byte (see next step). */
+
−
+
−    /* 
+
−     * BP points to the last byte of the skipped IE, 
+
−     * move to the next IE.
+
−     */
+
−    BP++;
+
−  }/* while bytes left unread */
+
−
+
−  /* Report the summary of the found erros. */
+
−  if (errTag != 0xFF)
+
−  {
+
−    ccd_setError (globs, errCode,
+
−      (U8)((errCode == ERR_COMPREH_REQUIRED) ? BREAK : CONTINUE),
+
−                  errTag,
+
−                  errPos,
+
−                  (USHORT) -1);
+
−  }
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)               MODULE  : CCD                   |
+
−| STATE   : code                     ROUTINE : ccd_decodeMsg         |
+
−+--------------------------------------------------------------------+
+
−
+
−
+
−  PARAMETERS:  UBYTE      entity
+
−                - specifies the calling entity of CCD. The Constants
+
−                  for each valid entity is defined in MCONST.CDG
+
−
+
−               UBYTE      direction
+
−                - specifies wether the message goes UPLINK or DOWNLINK.
+
−                  This is nessesary because there are same PDU-Type
+
−                  codes for different messages.
+
−
+
−	              T_MSGBUF * mBuf
+
−                - specifies the bitstream buffer of the message. The
+
−                  struct contains the l_buf and the o_buf elements.
+
−                  These elements specifies the length and offset in bits
+
−                  of the bitstream in the T_MSGBUF component buf.
+
−
+
−               UBYTE    * mStruct
+
−                - reference to the C-Structure of the decoded message.
+
−                  The type may differ so the Pointer is always typed as
+
−                  UBYTE* and must be casted after decoding. If this parameter
+
−                  is NULL CCD uses his internal buffer wich must be
+
−                  protected via ccd_begin() in a multithread environment.
+
−
+
−               UBYTE      mId
+
−                - specifies the PDU-Type of the bitstream. If this
+
−                  parameter is not equal 0xff the CCD does not decode
+
−                  the pdu-type from the bitstream to decide wich decoding
+
−                  rules to select. Normaly this param is set to 0xff.
+
−
+
−  PURPOSE:     decodes a bitstream, containing a valid TETRA-Message
+
−               of the Air-Interface to a corresponding C-Structure.
+
−
+
−*/
+
−
+
−BYTE CCDDATA_PREF(ccd_decodeMsg) (UBYTE         entity,
+
−                                  UBYTE         direction,
+
−                                  T_MSGBUF     *mBuf,
+
−                                  UBYTE        *mStruct,
+
−                                  UBYTE         mId)
+
−{
+
−  UBYTE theMsgId;
+
−  USHORT mcompRef;
+
−  int    jmp_ret;
+
−  T_CCD_Globs *globs;
+
−  T_CCD_ERR_LIST_HEAD* eentry;
+
−  T_CCD_STORE_LIST* stoentry;
+
−
+
−    globs = ccd_GetGlobVars (&eentry, &stoentry);
+
−
+
−    /*
+
−     * setup the structure-buffer
+
−     *
+
−     * if the parameter of the decoded message buffer address is NULL
+
−     * we use the internal one
+
−     */
+
−    globs->pstruct = (mStruct EQ NULL) ? ccd_decMsgBuffer : mStruct;
+
−    globs->pstructOffs = 0;
+
−
+
−    ccd_common_decode_init(mBuf->l_buf, mBuf->o_buf, mBuf->buf, globs);
+
−    ccd_err_reset (eentry);
+
−    globs->errLabel = 0;
+
−    globs->continue_array = TRUE;
+
−
+
−  #ifdef DEBUG_CCD
+
−    ccd_dump_msg(mBuf->l_buf, mBuf->o_buf, mBuf->buf, globs);
+
−  #endif
+
−
+
−    if (mId NEQ 0xff AND mId NEQ 0xfe)
+
−      globs->pstruct[0] = theMsgId = mId;
+
−    else
+
−    {
+
−      /* Read the message identifier */
+
−      globs->pstruct[0] = bf_decodeByteNumber ((ULONG) mi_length[entity], globs);
+
−      theMsgId = globs->pstruct[0];
+
−    }
+
−
+
−    /* Get entry in mmtx table for this message */
+
−    mcompRef = ccddata_get_mmtx(entity,theMsgId,direction);
+
−
+
−    /* Check the message identifier */
+
−    if (theMsgId > max_message_id OR mcompRef EQ NO_REF)
+
−    {
+
−  #ifdef ERR_TRC_STK_CCD
+
−      globs->ccd_recurs_level = 255;
+
−  #endif /* ERR_TRC_STK_CCD */
+
−      ccd_setError (globs, ERR_INVALID_MID, BREAK,
+
−		    (USHORT) theMsgId, (USHORT) -1);
+
−      ccd_FreeGlobVars (globs);
+
−      ccd_err_free (eentry);
+
−      return (BYTE)globs->CCD_Error;
+
−    }
+
−  #ifdef ERR_TRC_STK_CCD
+
−    /* save the value for tracing in error case */
+
−    globs->error_stack[0] = mcompRef;
+
−  #endif /* ERR_TRC_STK_CCD */
+
−
+
−  #ifdef DEBUG_CCD
+
−  #ifdef CCD_SYMBOLS
+
−    TRACE_CCD (globs, "CCD decode: Message = %s",
+
−    mcomp[mcompRef].name);
+
−  #else
+
−    TRACE_CCD (globs, "CCD decode: MessageId = %x", theMsgId);
+
−  #endif
+
−  #endif
+
−
+
−  /* 
+
−   * Clean up the entite C-structure before decoding.
+
−   * Do not overwrite the MsgId (1. Byte)
+
−   */
+
−  #ifdef DEBUG_CCD
+
−    TRACE_CCD (globs, "CCD Cleaning struct %ld bytes",
+
−	       mcomp[mcompRef].cSize-1);
+
−  #endif
+
−  memset ((UBYTE *) &globs->pstruct[1], 0,
+
−    (size_t)(mcomp[mcompRef].cSize - 1));
+
−
+
−    /*
+
−     * clear the UPN stack
+
−     */
+
−    ST_CLEAR(globs);
+
−    memset ((ULONG *) &(globs->KeepReg[0]), 0, MAX_KEEP_REG_SIZE);
+
−
+
−    /*
+
−     * inform the GSM-CODEC about the begin of a new message
+
−     */
+
−    cdc_GSM_start (globs);
+
−
+
−    jmp_ret = setjmp (globs->jmp_mark);
+
−
+
−    if (jmp_ret EQ 0)
+
−    {
+
−      globs->jmp_mark_set = TRUE;
+
−      ccd_decodeComposition ((ULONG) mcompRef, globs);
+
−
+
−      /*
+
−       * The coding rules and the data tables must be able to lead CCD to
+
−       * understand the bit buffer, element by element. If for some reason
+
−       * the bit pointer points to a place after the message limit, the
+
−       * encoding action is not trustworthy. Nevertheless CCD reports a
+
−       * WARNING and not error.
+
−       * In development phase it is helpful to detect such cases.
+
−       * Otherwise the caller can supposedly still use the message.
+
−       */
+
−      if (globs->bitpos > globs->buflen)
+
−      {
+
−        ccd_recordFault (globs, ERR_MSG_LEN, CONTINUE, mcompRef, NULL);
+
−      }
+
−      /*
+
−       * Seek for GSM extensions with types T, TV and TLV.
+
−       * (GRR, RCM/RRC and RRLP assume other extension mechanisms.)
+
−       * Check only at octet border.
+
−       */
+
−      else if ((globs->SeekTLVExt) && !globs->byteoffs)
+
−      {
+
−        SeekForGSMExtensions (entity, globs);
+
−      }
+
−  }
+
−
+
−
+
−  #ifdef DEBUG_CCD
+
−    TRACE_CCD (globs, "CCD-ERROR = %d", globs->CCD_Error);
+
−    TRACE_CCD (globs, "-------------------------------------------------");
+
−  #endif /* DEBUG_CCD */
+
−
+
−    ccd_FreeGlobVars (globs);
+
−    ccd_err_free (eentry);
+
−
+
−    return (BYTE) globs->CCD_Error;
+
−  }  /* end ccd_decodeMsg () */
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−  /*
+
−  +--------------------------------------------------------------------+
+
−  | PROJECT : CCD (6144)               MODULE  : CCD                   |
+
−  | STATE   : code                     ROUTINE : ccd_decodeMsgPtr      |
+
−  +--------------------------------------------------------------------+
+
−
+
−
+
−    PARAMETERS:  U8      entity
+
−		  - specifies the calling entity of CCD. The Constants
+
−		    for each valid entity is defined in MCONST.CDG
+
−
+
−		 U8      direction
+
−		  - specifies wether the message goes UPLINK or DOWNLINK.
+
−		    This is nessesary because there are same PDU-Type
+
−		    codes for different messages.
+
−
+
−		       U16 l_buf
+
−		  - Lenght of the bitstrem to be decoded.
+
−
+
−							   U16 o_buf
+
−		  - specifies the bitstream buffer of the message. The
+
−		    struct contains the l_buf and the o_buf elements.
+
−		    These elements specifies the length and offset in bits
+
−		    of the bitstream in the T_MSGBUF component buf.
+
−
+
−							   U8 *buf
+
−		  - specifies the bitstream buffer of the message. 
+
−
+
−		 U8 ** mStructPtr
+
−		  -	points to the pointer on the C-structure of the 
+
−		    decoded message. The buffer containing this message 
+
−		    structure will be allocated by CCD. After decoding 
+
−		    the first element in the message C-structure contains 
+
−		    the message (PDU) type as a UBYTE.
+
−
+
−		 U8  mId
+
−		  - specifies the PDU-Type of the bitstream. If this
+
−		    parameter is not equal 0xff the CCD does not decode
+
−		    the pdu-type from the bitstream to decide wich decoding
+
−		    rules to select. Normaly this param is set to 0xff.
+
−
+
−    PURPOSE:     Like ccd_decodeMsg, this function decodes a bitstream
+
−		 containing a valid TETRA-Message from the Air-Interface
+
−		 to a corresponding C-Structure, only this function
+
−		 allows the use of pointer types in the C-structure.
+
−
+
−  */
+
−  #if defined DYNAMIC_ARRAYS || defined _TOOLS_
+
−S8 CCDDATA_PREF(ccd_decodeMsgPtr) (U8   entity,
+
−		       U8   direction,
+
−		       U16  l_buf,
+
−		       U16  o_buf,
+
−		       U8*  buf,
+
−		       U8** mStructPtr,
+
−		       U8   mId)
+
−{
+
−  /*
+
−   * Make a dummy for the DLLs, even if DYNAMIC_ARRAYS is not defined to
+
−   * keep the ccd.def unique
+
−   */
+
−  #ifndef DYNAMIC_ARRAYS
+
−    return -1;
+
−}
+
−  #else /* DYNAMIC_ARRAYS */
+
−    UBYTE  theMsgId;
+
−    int    jmp_ret;
+
−    U32    msgsize;
+
−    USHORT mcompRef;
+
−    T_CCD_Globs *globs;
+
−    T_CCD_ERR_LIST_HEAD* eentry;
+
−    T_CCD_STORE_LIST* stoentry;
+
−
+
−    globs = ccd_GetGlobVars (&eentry, &stoentry);
+
−    ccd_common_decode_init(l_buf, o_buf, buf, globs);
+
−    ccd_err_reset (eentry);
+
−    globs->errLabel = 0;
+
−    globs->continue_array = TRUE;
+
−    globs->alloc_head = *mStructPtr = NULL;
+
−
+
−  #ifdef DEBUG_CCD
+
−    TRACE_CCD( globs, "======================================================");
+
−    TRACE_CCD( globs, "ccd_decodeMsgPtr: Decoding message with pointer types.");
+
−    ccd_dump_msg(l_buf, o_buf, buf, globs);
+
−  #endif
+
−
+
−	    /* Read the message identifier. */
+
−    if (mId NEQ 0xff AND mId NEQ 0xfe)
+
−      theMsgId = mId;
+
−    else
+
−      theMsgId = bf_decodeByteNumber ((ULONG) mi_length[entity], globs);
+
−
+
−    /* Get the entry in mmtx table for this message */
+
−    mcompRef = ccddata_get_mmtx (entity,theMsgId,direction);
+
−     
+
−    /* Check the validity of the message identifier */
+
−    if (theMsgId > max_message_id OR mcompRef EQ NO_REF)
+
−    {
+
−  #ifdef ERR_TRC_STK_CCD
+
−      globs->ccd_recurs_level = 255;
+
−  #endif /* ERR_TRC_STK_CCD */
+
−      ccd_setError (globs, ERR_INVALID_MID, BREAK, (USHORT) theMsgId, (USHORT) -1);
+
−      ccd_FreeGlobVars (globs);
+
−      ccd_err_free (eentry);
+
−      return (BYTE) globs->CCD_Error;
+
−    }
+
−
+
−  #ifdef ERR_TRC_STK_CCD
+
−    /* save the value for tracing in error case */
+
−    globs->error_stack[0] = mcompRef;
+
−  #endif /* ERR_TRC_STK_CCD */
+
−
+
−  #ifdef DEBUG_CCD
+
−  #ifdef CCD_SYMBOLS
+
−    TRACE_CCD (globs, "CCD decode: Message = %s",
+
−    mcomp[mcompRef].name);
+
−  #else
+
−    TRACE_CCD (globs, "CCD decode: MessageId = %x", theMsgId);
+
−  #endif
+
−  #endif
+
−
+
−    /*
+
−     * Setup the structure-buffer.
+
−     * Make a first simple estimation of much memory to allocate.
+
−     * It is twice as much as the air interface message, rounded up 
+
−     * to the nearest kilobyte boundary.
+
−     */
+
−    msgsize = mcomp[mcompRef].cSize;
+
−    
+
−  #ifdef DEBUG_CCD
+
−    TRACE_CCD( globs, "Allocating %ld bytes for msg.", msgsize);
+
−  #endif
+
−    
+
−    globs->alloc_head = (U8 *) DRP_ALLOC(msgsize, DP_NO_FRAME_GUESS);
+
−
+
−    if (globs->alloc_head == NULL)
+
−    {
+
−      ccd_setError (globs, ERR_NO_MEM, BREAK, (USHORT) theMsgId, (USHORT) -1);
+
−      ccd_FreeGlobVars (globs);
+
−      ccd_err_free (eentry);
+
−      return (BYTE) globs->CCD_Error;
+
−    }
+
−    *mStructPtr = globs->alloc_head;
+
−    globs->pstruct = globs->alloc_head;
+
−    globs->pstructOffs = 0;
+
−
+
−    /*Write the MSG ID in the buffer*/
+
−    globs->pstruct[0] = theMsgId;
+
−
+
−    /* 
+
−     * Clean up the entite C-structure before decoding.
+
−     * Do not overwrite the MsgId (1. Byte)
+
−     */
+
−  #ifdef DEBUG_CCD
+
−    TRACE_CCD (globs, "CCD Cleaning struct %ld bytes", mcomp[mcompRef].cSize);
+
−  #endif
+
−  memset ((U8 *)globs->pstruct, 0, (size_t)(msgsize));
+
−
+
−    /* 
+
−     * Write the message identifier into the C-structure.
+
−     */
+
−    globs->pstruct[0] = theMsgId;
+
−
+
−    /*
+
−     * clear the UPN stack
+
−     */
+
−    ST_CLEAR(globs);
+
−    memset ((ULONG *) &(globs->KeepReg[0]), 0, MAX_KEEP_REG_SIZE);
+
−
+
−    /*
+
−     * inform the GSM-CODEC about the begin of a new message
+
−     */
+
−    cdc_GSM_start (globs);
+
−
+
−    jmp_ret = setjmp (globs->jmp_mark);
+
−
+
−    if (jmp_ret EQ 0)
+
−    {
+
−      globs->jmp_mark_set = TRUE;
+
−      ccd_decodeComposition ((ULONG) mcompRef, globs);
+
−      if (globs->byteoffs NEQ 0)
+
−      {
+
−       bf_incBitpos (8-globs->byteoffs, globs);
+
−  
+
−        /* There are more bits to be decoded than ccddata expects.
+
−         * The additional bits may belong to unknown non-critical extensions.
+
−         */
+
−        if (globs->bitpos > globs->buflen)
+
−        {
+
−         ccd_recordFault (globs, ERR_UNEXPECT_PAD, CONTINUE, mcompRef, NULL);
+
−        }
+
−        /*
+
−         * Seek for GSM extensions with types T, TV and TLV.
+
−         * (GRR, RCM/RRC and RRLP assume other extension mechanisms.)
+
−         * Check only at octet border.
+
−         */
+
−        else if ((entity != aim_rrc_rcm) 
+
−                && (entity != aim_rrlp)
+
−                && (globs->SeekTLVExt)
+
−                && !globs->byteoffs)
+
−        {
+
−          SeekForGSMExtensions (entity, globs);
+
−        }
+
−      }
+
−      else
+
−      {
+
−        if (globs->bitpos > globs->buflen)
+
−        {
+
−         ccd_recordFault (globs, ERR_MSG_LEN, CONTINUE, mcompRef, NULL);
+
−        }
+
−        /*
+
−         * Seek for GSM extensions with types T, TV and TLV.
+
−         * (GRR, RCM/RRC and RRLP assume other extension mechanisms.)
+
−         * Check only at octet border.
+
−         */
+
−        else if ((entity != aim_rrc_rcm) 
+
−                && (entity != aim_rrlp)
+
−                && (globs->SeekTLVExt)
+
−                && !globs->byteoffs)
+
−        {
+
−          SeekForGSMExtensions (entity, globs);
+
−        }
+
−      }
+
−    }
+
−
+
−  #ifdef DEBUG_CCD
+
−    TRACE_CCD (globs, "CCD-ERROR = %d", globs->CCD_Error);
+
−    TRACE_CCD (globs, "-----------------------------------------------------");
+
−  #endif /* DEBUG_CCD */
+
−
+
−    ccd_FreeGlobVars (globs);
+
−    ccd_err_free (eentry);
+
−
+
−    return (BYTE) globs->CCD_Error;
+
−}  /* end ccd_decodeMsgPtr () */
+
−  #endif /* !DYNAMIC_ARRAYS */
+
−  #endif /* DYNAMIC_ARRAYS || _TOOLS_ */
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−  /*
+
−  +--------------------------------------------------------------------+
+
−  | PROJECT : CCD (6144)               MODULE  : CCD                   |
+
−  | STATE   : code                     ROUTINE : ccd_codeMsgPtr        |
+
−  +--------------------------------------------------------------------+
+
−
+
−   PARAMETERS:   UBYTE      entity
+
−		  - specifies the calling entity of CCD. The Constants
+
−		    for each valid entity is defined in MCONST.CDG
+
−
+
−		 UBYTE      direction
+
−		  - specifies wether the message goes UPLINK or DOWNLINK.
+
−		    This is nessesary because there are same PDU-Type
+
−		    codes for different messages.
+
−
+
−		 T_MSGBUF * mBuf
+
−		  - specifies the bitstream buffer of the message. The
+
−		    struct contains the l_buf and the o_buf elements.
+
−		    These elements specifies the length and offset in bits
+
−		    of the bitstream in the T_MSGBUF component buf.
+
−		    The o_buf component must be specified by the caller,
+
−		    the l_buf component is calculated by CCD.
+
−
+
−		 UBYTE    * mStruct
+
−		  - reference to the C-Structure containing the
+
−		    C-Representation of the decoded message.
+
−		    The type should be casted to UBYTE*. If this parameter
+
−		    is NULL CCD uses his internal buffer wich must be
+
−		    protected via ccd_begin() in a multithread environment.
+
−
+
−		 UBYTE      mId
+
−		  - specifies the PDU-Type of the bitstream. If this
+
−		    parameter is not equal 0xff the CCD does not read
+
−		    the pdu-type from the structure component pt
+
−		    to decide wich decoding rules to select.
+
−		    Normaly this param is set to 0xff.
+
−
+
−   PURPOSE:      encodes a C-Structure containing the C-Representation of
+
−		 a valid Air-interface message to a bitstream.
+
−
+
−  */
+
−
+
−S8 CCDDATA_PREF(ccd_codeMsgPtr)(U8   entity,
+
−		    U8   direction,
+
−		    U16* l_buf,
+
−		    U16  o_buf,
+
−		    U8   *buf,
+
−		    U8*  mStruct,
+
−		    U8   mId)
+
−{
+
−    UBYTE  theMsgId;
+
−    int    jmp_ret;
+
−    USHORT maxBytes, mcompRef;
+
−    T_CCD_Globs *globs;
+
−    T_CCD_ERR_LIST_HEAD* eentry;
+
−    T_CCD_STORE_LIST* stoentry;
+
−    
+
−    globs = ccd_GetGlobVars (&eentry, &stoentry);
+
−    ccd_err_reset (eentry);
+
−
+
−  #if defined (DEBUG_CCD)
+
−    {
+
−      /* to avoid the vsprintf if the traces won't appear anyhow */
+
−      ULONG mask;
+
−      if (vsi_gettracemask (globs->me, globs->me, &mask) != VSI_ERROR)
+
−      {
+
−	globs->TraceIt = mask & TC_CCD;
+
−      }
+
−    }
+
−  #endif
+
−
+
−    /*
+
−     * Set a sign that no call to setjmp() is done. So ccd_setError 
+
−     * performs no longjmp in case of an error.
+
−     */
+
−    globs->jmp_mark_set = FALSE;
+
−
+
−    /* Setup the bitbuffer. */
+
−    globs->bitbuf = buf;
+
−    globs->bitpos = 0;
+
−
+
−    /* and the structure-buffer */
+
−    globs->pstruct = (mStruct EQ NULL) ? ccd_decMsgBuffer : mStruct;
+
−    globs->pstructOffs = 0;
+
−
+
−    /* Cleanup the read-caches. */
+
−    globs->lastbytepos16 = globs->lastbytepos32 = 0xffff;
+
−
+
−    /* Setup the bitoffset. */
+
−    globs->bitoffs = o_buf;
+
−
+
−    
+
−    bf_incBitpos (o_buf, globs);
+
−
+
−    globs->bitbuf[globs->bytepos] = 0;
+
−
+
−    globs->ccd_recurs_level = 0;
+
−
+
−    globs->CCD_Error = ccdOK;
+
−
+
−    globs->continue_array = TRUE;
+
−
+
−    if (mId NEQ 0xff AND mId NEQ 0xfe)
+
−      theMsgId = mId;
+
−    else
+
−    {
+
−      theMsgId = globs->pstruct[0];
+
−    }
+
−
+
−    mcompRef = ccddata_get_mmtx(entity,theMsgId,direction);
+
−    /* Check the validity of the given message identifier. */
+
−    if (theMsgId > max_message_id OR mcompRef EQ NO_REF)
+
−    {
+
−  #ifdef ERR_TRC_STK_CCD
+
−      globs->ccd_recurs_level = 255;
+
−  #endif /* ERR_TRC_STK_CCD */
+
−      ccd_setError (globs, ERR_INVALID_MID, BREAK, (USHORT) theMsgId, (USHORT) -1);
+
−      ccd_FreeGlobVars (globs);
+
−      ccd_err_free (eentry);
+
−      return (BYTE) globs->CCD_Error;
+
−    }
+
−
+
−  #ifdef ERR_TRC_STK_CCD
+
−    /* save the value for tracing in error case */
+
−    globs->error_stack[0] = mcompRef;
+
−  #endif /* ERR_TRC_STK_CCD */
+
−
+
−  maxBytes = (*l_buf + 7)>>3;
+
−  globs->msgLen = *l_buf;
+
−
+
−  #ifdef DEBUG_CCD
+
−    TRACE_CCD (globs, "-------------------------------------------------");
+
−    TRACE_CCD (globs, "CCD: Code Message");
+
−    TRACE_CCD (globs, "Cleaning %d bits (%d bytes) of the bitstream",
+
−      mcomp[mcompRef].bSize, maxBytes);
+
−  #endif
+
−
+
−    /* 
+
−     * Clean up the bit buffer for the encoded message before encoding.
+
−     */
+
−    memset ((U8 *) &buf[(o_buf>>3)], 0, (size_t) maxBytes);
+
−    /* Store the length of ereased buffer to support error handling. */
+
−    globs->buflen = *l_buf;
+
−
+
−    if (mId EQ 0xff)
+
−    {
+
−      /* Write the message identifier. */
+
−      bf_writeBits ((U32)mi_length[entity], globs);
+
−    }
+
−
+
−  #ifdef DEBUG_CCD
+
−  #ifdef CCD_SYMBOLS
+
−    TRACE_CCD (globs, "CCD encode: Message = %s", mcomp[mcompRef].name);
+
−  #else
+
−    TRACE_CCD (globs, "CCD encode: MessageId = %x", theMsgId);
+
−  #endif
+
−  #endif
+
−
+
−    /*
+
−     * Clear the UPN stack.
+
−     */
+
−    ST_CLEAR(globs);
+
−    memset ((ULONG *) &(globs->KeepReg[0]), 0, MAX_KEEP_REG_SIZE);
+
−
+
−    /*
+
−     * Inform the GSM-CODEC about the begin of a new message.
+
−     */
+
−    cdc_GSM_start (globs);
+
−
+
−    jmp_ret = setjmp (globs->jmp_mark);
+
−
+
−    if (jmp_ret EQ 0)
+
−    {
+
−      /*
+
−       * no call to setjmp() done. So ccd_Error performs no longjmp in
+
−       * case of an error
+
−       */
+
−      globs->jmp_mark_set = TRUE;
+
−      ccd_encodeComposition ((ULONG) mcompRef, globs);
+
−      if (globs->bitpos > o_buf + *l_buf)
+
−      {
+
−	ccd_setError (globs, ERR_BUFFER_OF, CONTINUE, (USHORT) -1);
+
−      }
+
−      bf_writePadBits (globs);
+
−    }
+
−
+
−    *l_buf = (USHORT) globs->bitpos - (USHORT) o_buf;
+
−
+
−  #ifdef DEBUG_CCD
+
−  {
+
−    int i, j, buflen;
+
−    char s[64], c[4];  
+
−
+
−    buflen = (*l_buf + o_buf + 7) >> 3;
+
−
+
−    TRACE_CCD (globs, "-------------------------------------------------");
+
−    TRACE_CCD (globs, " After ENCODING: lbuf= %d, obuf= %d", *l_buf, o_buf);
+
−    TRACE_CCD (globs, " Hex dump of encoded message:"); 
+
−
+
−    s[0] = '\0';
+
−    for (i = o_buf >> 3; i < buflen; i+=16)
+
−    {
+
−      for (j = 0; j < 16; j++)
+
−      {
+
−	if ((i+j) < buflen)
+
−	{
+
−	  sprintf(c, " %02x", buf[i+j]);
+
−	  strcat (s, c);
+
−	}
+
−      }
+
−      TRACE_CCD (globs, "%s", s);
+
−      s[0] = '\0';
+
−    }
+
−  }
+
−  #endif
+
−
+
−  #ifdef DEBUG_CCD
+
−    TRACE_CCD (globs, "CCD-ERROR = %d", globs->CCD_Error);
+
−    TRACE_CCD (globs, "-------------------------------------------------");
+
−  #endif
+
−
+
−    ccd_FreeGlobVars (globs);
+
−    ccd_err_free (eentry);
+
−
+
−    return (BYTE)globs->CCD_Error;
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−  /*
+
−  +--------------------------------------------------------------------+
+
−  | PROJECT : CCD (6144)               MODULE  : CCD                   |
+
−  | STATE   : code                     ROUTINE : ccd_codeMsg           |
+
−  +--------------------------------------------------------------------+
+
−
+
−   PARAMETERS:   UBYTE      entity
+
−		  - specifies the calling entity of CCD. The Constants
+
−		    for each valid entity is defined in MCONST.CDG
+
−
+
−		 UBYTE      direction
+
−		  - specifies wether the message goes UPLINK or DOWNLINK.
+
−		    This is nessesary because there are same PDU-Type
+
−		    codes for different messages.
+
−
+
−		 T_MSGBUF * mBuf
+
−		  - specifies the bitstream buffer of the message. The
+
−		    struct contains the l_buf and the o_buf elements.
+
−		    These elements specifies the length and offset in bits
+
−		    of the bitstream in the T_MSGBUF component buf.
+
−		    The o_buf component must be specified by the caller,
+
−		    the l_buf component is calculated by CCD.
+
−
+
−		 UBYTE    * mStruct
+
−		  - reference to the C-Structure containing the
+
−		    C-Representation of the decoded message.
+
−		    The type should be casted to UBYTE*. If this parameter
+
−		    is NULL CCD uses his internal buffer wich must be
+
−		    protected via ccd_begin() in a multithread environment.
+
−
+
−		 UBYTE      mId
+
−		  - specifies the PDU-Type of the bitstream. If this
+
−		    parameter is not equal 0xff the CCD does not read
+
−		    the pdu-type from the structure component pt
+
−		    to decide wich decoding rules to select.
+
−		    Normaly this param is set to 0xff.
+
−
+
−   PURPOSE:      encodes a C-Structure containing the C-Representation of
+
−		 a valid Air-interface message to a bitstream.
+
−
+
−  */
+
−
+
−BYTE CCDDATA_PREF(ccd_codeMsg) (UBYTE  entity,
+
−		    UBYTE         direction,
+
−		    T_MSGBUF     *mBuf,
+
−		    UBYTE        *mStruct,
+
−		    UBYTE         mId)
+
−{
+
−  return CCDDATA_PREF(ccd_codeMsgPtr) (entity, direction, &mBuf->l_buf,
+
−      mBuf->o_buf, mBuf->buf, mStruct, mId);
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
−+------------------------------------------------------------------------------
+
−|  Function    : ccd_init_ccddata
+
−+------------------------------------------------------------------------------
+
−|  Description : Initialize local tables.
+
−|
+
−|  Parameters  : -
+
−|
+
−|  Return      : ccdOK, ccdWarning, or ccdError depending on the success.
+
−+------------------------------------------------------------------------------
+
−*/
+
−ULONG CCDDATA_PREF(ccd_init_ccddata) (void)
+
−{
+
−  const T_CCD_CompTabEntry *msg;
+
−  USHORT                    mcompRef;  
+
−  UBYTE                     ret, entity, num_of_entities;
+
−  USHORT                    messageId;
+
−#ifdef DEBUG_CCD
+
−  T_CCD_Globs *globs = &globs_all;
+
−#endif
+
−
+
−  aim_rrc_rcm = (U8)ccddata_get_ccdent ("UMTS_AS_ASN1_MSG");
+
−  aim_rrlp    = (U8)ccddata_get_ccdent ("RRLP_ASN1_MSG");
+
−  aim_sat     = (U8)ccddata_get_ccdent ("SAT");
+
−
+
−  mcomp = ccddata_get_mcomp (0);
+
−  mvar = ccddata_get_mvar (0);
+
−  mval = ccddata_get_mval (0);
+
−  melem = ccddata_get_melem (0);
+
−  spare = ccddata_get_spare (0);
+
−  calc = ccddata_get_calc (0);
+
−  calcidx = ccddata_get_calcidx (0);
+
−
+
−  mi_length = ccddata_get_mi_length();
+
−  ccd_decMsgBuffer = ALIGN_BUF(ccddata_get_decmsgbuffer());
+
−  max_message_id = (USHORT) ccddata_get_max_message_id();
+
−
+
−#ifdef CCD_SYMBOLS
+
−  if (!ccddata_mccd_symbols())
+
−  {
+
−#ifdef CCD_TEST
+
−    printf ("CCD_SYMBOLS is not set in ccddata\n");
+
−#else     /* CCD_TEST */
+
−    vsi_o_assert( VSI_CALLER OS_SYST_ERR, __FILE__, __LINE__,
+
−                  "CCD_SYMBOLS is not set in ccddata" );
+
−#endif    /* CCD_TEST */
+
−  }
+
−
+
−#else     /* CCD_SYMBOLS */
+
−  if (ccddata_mccd_symbols())
+
−  {
+
−#ifdef CCD_TEST
+
−    printf ("Undefine CCD_SYMBOLS in ccddata\n");
+
−#else     /* CCD_TEST */
+
−    vsi_o_assert( VSI_CALLER OS_SYST_ERR, __FILE__, __LINE__,
+
−                  "Undefine CCD_SYMBOLS in ccddata" );
+
−#endif    /* CCD_TEST */
+
−  }
+
−#endif    /* CCD_SYMBOLS */
+
−
+
−#ifdef DEBUG_CCD
+
−  /* Only for TRACE_CCD call in ccd_init. */
+
−  globs->me = 0;
+
−  globs->TraceIt = 1;
+
−#endif /* DEBUG_CCD */
+
−
+
−  num_of_entities = (UBYTE) ccddata_get_num_of_entities();
+
−  for (entity = 0; entity < num_of_entities; entity++)
+
−  {
+
−    /*
+
−     * Point to the first defined Message, to get the length
+
−     * of the message identifier
+
−     */
+
−    msg = NULL;
+
−    messageId = 0;
+
−    while (msg EQ NULL AND messageId <= max_message_id)
+
−    {
+
−      /* 
+
−       * If there is no UPLINK-decoding, try the DOWNLINK.
+
−       */
+
−      if ((mcompRef = ccddata_get_mmtx(entity, messageId, UPLINK)) NEQ NO_REF)
+
−        msg = (T_CCD_CompTabEntry *) &mcomp[mcompRef];
+
−      else
+
−        if ((mcompRef = ccddata_get_mmtx(entity, messageId, DOWNLINK)) NEQ NO_REF)
+
−          msg = (T_CCD_CompTabEntry *) &mcomp[mcompRef];
+
−        else
+
−          messageId++;
+
−    }
+
−    if (msg NEQ NULL
+
−    AND melem[msg->componentRef].elemType EQ 'V'
+
−    AND melem[msg->componentRef].elemRef NEQ NO_REF)
+
−    {
+
−      /*
+
−       * if there is a message for this layer - get the length
+
−       * of the first element (msg_type or pdu_type)
+
−       */
+
−      mi_length[entity] =(UBYTE) (mvar[melem[msg->componentRef].elemRef].bSize); 
+
−    }
+
−    else
+
−      mi_length[entity] = 0;
+
−
+
−#ifdef DEBUG_CCD
+
−  TRACE_CCD (globs, "MI-LEN [ENTITY %d] = %d", entity, mi_length[entity]);
+
−#endif
+
−  }
+
−
+
−  /*
+
−   * Register all needed coding/decoding functions in the jump table.
+
−   */
+
−  ret = cdc_init (codec);
+
−    
+
−  if (ret EQ ccdError)
+
−    return ccdError;
+
−
+
−#ifdef DEBUG_CCD
+
−  if (ret EQ ccdWarning)
+
−  {
+
−    TRACE_CCD (globs, "CCD: Mismatch between CCD and CCDDATA. Check the codec list.");//return ccdWarning;
+
−  }
+
−#endif
+
−
+
−  return ccdOK;
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
−+------------------------------------------------------------------------------
+
−|  Function     :  ccd_signup
+
−+------------------------------------------------------------------------------
+
−|  Description  :  This function sets up the local CCD data for the calling
+
−|                  entity.
+
−|
+
−|  Parameters   :  ccd_reg - set if called by ccd_register, not set if called
+
−|                            by ccd_init
+
−|                  decmsgbuf_size - further enhancement: size of the entity's
+
−|                                   decoded msg buffer size
+
−|
+
−|  Return       :  ccdErr or ccdOK depending on the success
+
−+------------------------------------------------------------------------------
+
−*/
+
−
+
−static int ccd_signup (int ccd_reg, int decmsgbuf_size)
+
−{
+
−#ifndef _TOOLS_
+
−    UBYTE                     ret;
+
−#endif
+
−  #ifdef SHARED_CCD
+
−    T_HANDLE me;
+
−  #else
+
−    int me = 0;
+
−  #endif
+
−  T_CCD_TASK_TABLE* tentry;
+
−
+
−#ifdef SHARED_CCD
+
−  me = vsi_e_handle (0, NULL);
+
−  if (me == VSI_ERROR)
+
−  {
+
−    me = 0;
+
−    tentry = ccd_task_list[0] = &task_null;
+
−    task_null.ccd_globs = &globs_all;
+
−#ifdef DEBUG_CCD
+
−    TRACE_CCD (&globs_all, "Ccd initialization: task could not be identified. Try to continue with a non reentrant init");
+
−#endif
+
−  }
+
−  else
+
−  {
+
−    if (!ccd_task_list[me])
+
−    {
+
−      ccd_task_list[me] = D_ALLOC (sizeof (T_CCD_TASK_TABLE));
+
−      if (!ccd_task_list[me])
+
−      {
+
−        vsi_o_assert( VSI_CALLER OS_SYST_ERR, __FILE__, __LINE__,
+
−                  "Could not allocate memory for ccd task table entry" );
+
−      }
+
−      else
+
−      {
+
−        ccd_task_list[me]->ccd_globs = NULL;
+
−        ccd_task_list[me]->ccd_err_list = NULL;
+
−        ccd_task_list[me]->ccd_store = NULL;
+
−      }
+
−    }
+
−    tentry = ccd_task_list[me];
+
−    tentry->decmsgbuf = NULL;
+
−    if (ccd_reg)
+
−    {
+
−      if (!tentry->ccd_globs)
+
−      {
+
−        if (decmsgbuf_size != CCD_REENTRANT)
+
−        {
+
−#ifdef DEBUG_CCD
+
−          TRACE_CCD (tentry->ccd_globs, "Ccd_register (task %d): ignore %d for parameter decmsgbuf_size. Make non reentrant ccd_init instead.", me, decmsgbuf_size);
+
−#endif
+
−          tentry->ccd_globs = &globs_all;
+
−        }
+
−        else
+
−        {
+
−          tentry->ccd_globs = D_ALLOC (sizeof(T_CCD_Globs));
+
−          if (!tentry->ccd_globs)
+
−          {
+
−            vsi_o_assert( VSI_CALLER OS_SYST_ERR, __FILE__, __LINE__,
+
−                      "Could not allocate memory for ccd_globs" );
+
−          }
+
−        }
+
−      }
+
−    }
+
−    else
+
−    {
+
−      tentry->ccd_globs = &globs_all;
+
−    }
+
−  }
+
−#else   /* SHARED_CCD */
+
−  tentry = ccd_task_list[0] = &task_null;
+
−  task_null.ccd_globs = &globs_all;
+
−#endif
+
−
+
−  tentry->ccd_globs->me = me;
+
−  if (ccd_err_init (&tentry->ccd_err_list))
+
−  {
+
−  #ifdef CCD_TEST
+
−    printf ("Cannot initialize error list: out of memory\n");
+
−  #else   /* CCD_TEST */
+
−    vsi_o_assert( VSI_CALLER OS_SYST_ERR, __FILE__, __LINE__,
+
−	  "Cannot initialize error list: out of memory" );
+
−  #endif  /* CCD_TEST */
+
−    return ccdError;
+
−  }
+
−
+
−  if (ccd_store_init (&tentry->ccd_store))
+
−  {
+
−#ifdef CCD_TEST
+
−    printf ("Cannot initialize store register: out of memory\n");
+
−#else   /* CCD_TEST */
+
−    vsi_o_assert( VSI_CALLER OS_SYST_ERR, __FILE__, __LINE__,
+
−	  "Cannot initialize store register: out of memory" );
+
−#endif  /* CCD_TEST */
+
−    return ccdError;
+
−  }
+
−
+
−  if (!initialized)
+
−  {
+
−#ifdef SHARED_CCD
+
−   /*
+
−   * if the CCD is used in a premptive multithreaded system
+
−   * we must create a semaphore for the coding and decoding
+
−   */
+
−    semCCD_Codec  = vsi_s_open (VSI_CALLER "CCD_COD",1);
+
−    semCCD_Buffer = vsi_s_open (VSI_CALLER "CCD_BUF",1);
+
−
+
−#endif     /* SHARED_CCD */
+
−  
+
−#ifndef _TOOLS_
+
−    ret = (UBYTE)ccd_init_ccddata ();
+
−    if (ret != ccdOK)
+
−    return  ret;
+
−
+
−#endif /* !_TOOLS_ */
+
−    initialized = TRUE;
+
−    /* save memory init pattern */
+
−    mempat = (U8*) CCDDATA_PREF(ccd_get_numFaults ());
+
−  }
+
−  return ccdOK;
+
−}
+
−
+
−BYTE CCDDATA_PREF(ccd_init) (void)
+
−{
+
−  return (BYTE) ccd_signup (0, 0);
+
−}
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|  Function     :  ccd_register
+
−+------------------------------------------------------------------------------
+
−|  Description  :  This function sets up the local CCD data for the calling
+
−|                  entity.
+
−|                  Entities calling this function with a parameter 0 will
+
−|                  get an own set of CCD local data, i.e., they don't have to
+
−|                  synchronize with other entities to use CCD.     
+
−|
+
−|  Parameters   :  decmsgbuf_size - further enhancement: size of the entity's
+
−|                                   decoded msg buffer size
+
−|
+
−|  Return       :  ccdErr or ccdOK depending on the success
+
−+------------------------------------------------------------------------------
+
−*/
+
−
+
−int ccd_register (int decmsgbuf_size)
+
−{
+
−  return ccd_signup (1, decmsgbuf_size);
+
−}
+
−#endif /* !RUN_FLASH */
+
−
+
−#ifndef RUN_FLASH
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)               MODULE  : CCD                   |
+
−| STATE   : code                     ROUTINE : ccd_exit              |
+
−+--------------------------------------------------------------------+
+
−
+
− PURPOSE:  performs a shutdown of CCD.
+
−
+
−*/
+
−
+
−int CCDDATA_PREF(ccd_exit) (void)
+
−{
+
−#ifdef SHARED_CCD
+
−  T_CCD_TASK_TABLE* tentry;
+
−  T_HANDLE me = vsi_e_handle (0, NULL);
+
−  if (me == VSI_ERROR)
+
−    return ccdError;
+
−  tentry = ccd_task_list[me]; 
+
−  if (tentry->ccd_globs && (tentry->ccd_globs != &globs_all))
+
−  {
+
−    D_FREE (tentry->ccd_globs);
+
−    tentry->ccd_globs = 0;
+
−  }
+
−  ccd_store_exit();
+
−  ccd_err_exit (); 
+
−  D_FREE (ccd_task_list[me]);
+
−  ccd_task_list[me] = NULL;
+
−#else
+
−  ccd_store_exit();
+
−  ccd_err_exit (); 
+
−#endif /* SHARED_CCD */
+
−  return ccdOK;
+
−}
+
−#endif /* !RUN_FLASH */