+
−/* 
+
−+----------------------------------------------------------------------------- 
+
−|  Project : 
+
−|  Modul   : Ccdedit.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 :  Coder Decoder editfunctions for reading/writing the
+
−|             	           C-Structures of primitives and messages.
+
−+----------------------------------------------------------------------------- 
+
−*/ 
+
−
+
−#define CCDEDIT_C
+
−
+
−#include <stdio.h>
+
−#include <stdlib.h>
+
−#include <string.h>
+
−
+
−/*
+
− * standard definitions like UCHAR, ERROR etc.
+
− */
+
−#include "typedefs.h"
+
−
+
−
+
−/*
+
− * Declaration of coder/decoder-tables
+
− */
+
−#include "ccdtable.h"
+
−#include "ccddata.h"
+
−
+
−#include "ccdedit.h"
+
−
+
−typedef union
+
−{
+
−  UBYTE  buffer[4];
+
−  UBYTE  b[4];
+
−  USHORT s[2];
+
−  ULONG  l;
+
−} T_CONV;
+
−
+
−typedef enum
+
−{
+
−  isvar,
+
−  isstruct,
+
−  isunion,
+
−  issdu,
+
−  isductrl
+
−} T_ELEMTYPE;
+
−
+
−/*
+
− *  strncpy() does not append a null chararcter to the copied string;
+
− *  This macro adds a terminating null following a call to strncpy()
+
− *  In Ccdedit.h the buffers are all len+1 bytes long.
+
− */
+
−#define STRNCPY(dest,source,len)  {\
+
−                                    strncpy (dest, source, len);\
+
−                                    dest [len] = 0;\
+
−                                  }
+
−
+
−
+
−static const T_CCD_CompTabEntry* mcomp;
+
−static const T_CCD_CompTabEntry* pcomp;
+
−static const T_CCD_VarTabEntry*  pvar;
+
−static const T_CCD_ElemTabEntry* pelem;
+
−static const T_CCD_StrTabEntry*  pstr;
+
−static const T_CCD_VarTabEntry*  mvar;
+
−static const T_CCD_ElemTabEntry* melem;
+
−static const T_CCD_StrTabEntry*  mstr;
+
−static const T_CCD_ValTabEntry*  mval;
+
−static const T_CCD_ValTabEntry*  pval;
+
−static int ccddata_num_of_entities;
+
−static int ccddata_max_message_id;
+
−static int ccddata_max_primitive_id;
+
−static int ccddata_max_sap_num;
+
−
+
−
+
−void CCDDATA_PREF(cde_init) ()
+
−{
+
−  mcomp = ccddata_get_mcomp (0);
+
−  pcomp = ccddata_get_pcomp (0);
+
−  pvar = ccddata_get_pvar (0);
+
−  pelem = ccddata_get_pelem (0);
+
−  pstr = ccddata_get_pstr (0);
+
−  mvar = ccddata_get_mvar (0);
+
−  melem = ccddata_get_melem (0);
+
−  mstr = ccddata_get_mstr (0);
+
−  mval = ccddata_get_mval (0);
+
−  pval = ccddata_get_pval (0);
+
−  ccddata_num_of_entities = ccddata_get_num_of_entities ();
+
−  ccddata_max_message_id = ccddata_get_max_message_id ();
+
−  ccddata_max_primitive_id = ccddata_get_max_primitive_id ();
+
−  ccddata_max_sap_num = ccddata_get_max_sap_num ();
+
−}
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|  Function     :  cde_val_iterate
+
−+------------------------------------------------------------------------------
+
−|  Description  :  This function searches the values in [pm]val.cdg for
+
−|                  a given value and depending on the value of the parameter
+
−|                  'copy' adds the "Comment" of the SAP-/MSG-catalogues
+
−|                  to the member symbolicValue of a given T_CCDE_ELEM_DESCR.
+
−|
+
−|  Parameters   :  elem_value - the actual value searched for
+
−|                  edescr - the element descriptor
+
−|                  copy - s.a.
+
−|
+
−|  Return       :  -1 if no values are defined or if the value is not found;
+
−|                  else: the ordinal of the value in relation to first valid
+
−|                    value of the var
+
−+------------------------------------------------------------------------------
+
−*/
+
−
+
−static void cde_val_iterate (int elem_value,
+
−                              T_CCDE_ELEM_DESCR* edescr)
+
−{
+
−  
+
−  S32  StartVal, EndVal;
+
−  BOOL   IsDefault;
+
−  char  *ValStr;
+
−  SHORT  NumDefs;
+
−  USHORT ValueDef;
+
−  USHORT valdefstart;
+
−  const T_CCD_ValTabEntry* val;
+
−  const T_CCD_StrTabEntry* str;
+
−
+
−  if (edescr->ccdIndex == NO_REF)
+
−    return;
+
−
+
−  if (edescr->esource EQ FromMsg)
+
−  {
+
−    NumDefs  = mvar[edescr->ccdIndex].numValueDefs;
+
−    ValueDef = mvar[edescr->ccdIndex].valueDefs;
+
−    val = mval;
+
−    str = mstr;
+
−  }
+
−  else
+
−  {
+
−    NumDefs  = pvar[edescr->ccdIndex].numValueDefs;
+
−    ValueDef = pvar[edescr->ccdIndex].valueDefs;
+
−    val = pval;
+
−    str = pstr;
+
−  }
+
−
+
−  valdefstart = ValueDef;
+
−
+
−  edescr->valcheck = NumDefs ? -1 : 1;
+
−  while (NumDefs-- > 0)
+
−  {
+
−    IsDefault = val[ValueDef].isDefault;
+
−    ValStr    = str[val[ValueDef].valStringRef];
+
−    StartVal  = val[ValueDef].startValue;
+
−    EndVal    = val[ValueDef].endValue;
+
−
+
−    if (IsDefault)
+
−    {
+
−      /* default definition */
+
−      
+
−      STRNCPY (edescr->symbolicValue, ValStr, SYMBOLIC_VAL_LENGTH);
+
−      /* 
+
−       * If IsDefault is 2 it is an ASN1 default value; StartVal and EndVal
+
−       * are set to the value. If IsDefault is 1, it means only a default
+
−       * symbolic value, but StartVal and EndVal are not set. In this case
+
−       * valcheck get the value 0.
+
−       */
+
−      if (IsDefault == 2)
+
−      {
+
−        if (elem_value == StartVal)
+
−        {
+
−          edescr->valcheck = 1;
+
−          return;
+
−        }
+
−      }
+
−      else
+
−      {
+
−        edescr->valcheck = 0;
+
−      }
+
−    }
+
−    else
+
−    {
+
−      if (elem_value == StartVal && elem_value == EndVal)
+
−      {
+
−        STRNCPY (edescr->symbolicValue, ValStr, SYMBOLIC_VAL_LENGTH);
+
−        edescr->valcheck = 1;
+
−        return;
+
−      }
+
−
+
−      if (elem_value >= StartVal AND elem_value <= EndVal)
+
−      {
+
−        /* found in range, but continue to search an exact match */
+
−        STRNCPY (edescr->symbolicValue, ValStr, SYMBOLIC_VAL_LENGTH);
+
−        edescr->valcheck = 1;
+
−      }
+
−    }
+
−    ValueDef++;
+
−  }
+
−}
+
−
+
−static void eval_elemtype (T_CCDE_ELEM_DESCR* edescr,
+
−                           const T_CCD_ElemTabEntry* elem,
+
−                           T_ELEMTYPE* elemtype,
+
−                           BOOL* linked)
+
−{
+
−  *linked = FALSE;
+
−
+
−  switch (elem->elemType)
+
−  {
+
−    case 'W':
+
−    case 'M':
+
−    case 'I':
+
−      *linked = TRUE; 
+
−      /* fallthrough */
+
−    case 'V':
+
−    case 'R':
+
−    case 'F':
+
−     *elemtype = isvar;
+
−     break;
+
−
+
−    case 'Z':
+
−    case 'K':
+
−    case 'G':
+
−      *linked = TRUE;
+
−      /* fallthrough */
+
−    case 'C':
+
−    case 'P':
+
−    case 'D':
+
−     *elemtype = isstruct;
+
−     break;
+
−
+
−    case 'c':
+
−    case 'p':
+
−    case 'd':
+
−     *elemtype = issdu;
+
−     break;
+
−
+
−    case 'Y':
+
−    case 'L':
+
−    case 'H':
+
−      *linked = TRUE;
+
−      /* fallthrough */
+
−    case 'U':
+
−    case 'Q':
+
−    case 'E':
+
−     *elemtype = isunion;
+
−     break;
+
−    case '!':
+
−     *elemtype = isductrl;
+
−     break;
+
−  }
+
−  if ((elem->elemType >= 'P' && elem->elemType <= 'R') ||
+
−      (elem->elemType >= 'K' && elem->elemType <= 'M') ||
+
−       elem->elemType == 'p')
+
−    edescr->ptrtype = usptr;
+
−  else if((elem->elemType >= 'D' && elem->elemType <= 'F') ||
+
−          (elem->elemType >= 'G' && elem->elemType <= 'I') ||
+
−           elem->elemType == 'd')
+
−    edescr->ptrtype = ctptr;
+
−  else
+
−    edescr->ptrtype = noptr;
+
−}
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CCDEDIT             |
+
−| STATE   : code                       ROUTINE : cde_get_next_elem   |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : 
+
−
+
−*/
+
−
+
−static USHORT cde_get_next_elem (T_CCDE_HANDLE       *handle,
+
−                                 UBYTE                descent,
+
−                                 T_CCDE_ELEM_DESCR   *edescr)
+
−{
+
−  T_CCDE_CONTEXT * ctx;
+
−  BOOL isMsg;
+
−  BOOL linked;
+
−  BOOL             validElemFound = FALSE;
+
−  const T_CCD_VarTabEntry   *var;
+
−  const T_CCD_CompTabEntry  *comp;
+
−  const T_CCD_ElemTabEntry  *elem;
+
−  const T_CCD_StrTabEntry   *str;
+
−  T_ELEMTYPE elemtype;
+
−
+
−  isMsg = handle->source == FromMsg;
+
−
+
−  if (isMsg)
+
−  /* var, str, and comp may become reset later */
+
−  {
+
−    comp = mcomp;
+
−    elem = melem;
+
−    str = mstr;
+
−    var = mvar;
+
−  }
+
−  else
+
−  {
+
−    comp = pcomp;
+
−    elem = pelem;
+
−    str = pstr;
+
−    var = pvar;
+
−  }
+
−  
+
−  if (descent > handle->level AND handle->canDescent)
+
−    handle->level++;
+
−
+
−  handle->canDescent = FALSE;
+
−  
+
−  ctx = &handle->context[handle->level];
+
−
+
−  do
+
−  {
+
−    if (ctx->numElems EQ 0)
+
−    {
+
−      /*
+
−       * end of composition or maybe of the entire message/primitive.
+
−       */
+
−      if (handle->level > 0)
+
−      {
+
−        /*
+
−         * end of substructured element.
+
−         * switch to the context of the previous level.
+
−         */
+
−        handle->level--;
+
−        ctx = &handle->context[handle->level];
+
−      }
+
−      else
+
−      {
+
−        edescr->offset = comp[ctx->structIdx].cSize
+
−                         + handle->lenVarPart;
+
−        return isMsg ? CCDEDIT_END_OF_MSG : CCDEDIT_END_OF_PRIM;
+
−      }
+
−    }
+
−    /*
+
−     * skip the spare elements (do it only for messages)
+
−     */
+
−    if (ctx->numElems)
+
−    {
+
−      /* 
+
−       * remember: primitives does not contain spare definitions
+
−       */
+
−      if (elem[ctx->elemIdx].elemType == 'S')
+
−      {
+
−        ctx->elemIdx++;
+
−        ctx->numElems--;
+
−      }
+
−      else
+
−        validElemFound = TRUE;
+
−    }
+
−  } while (!validElemFound);
+
−
+
−
+
−  eval_elemtype (edescr, &elem[ctx->elemIdx], &elemtype, &linked);
+
−
+
−  if (elemtype == isductrl)
+
−  {
+
−    edescr->btype = T_ductrl;
+
−    ctx->elemIdx++;
+
−    ctx->numElems--;
+
−    return CCDEDIT_OK;
+
−  }
+
−
+
−  if (linked)
+
−  {
+
−    /* element linked from pelem to mvar/mcomp */
+
−    edescr->esource = FromMsg;
+
−    comp = mcomp;
+
−    var = mvar;
+
−    str = mstr;
+
−  }
+
−  else
+
−    edescr->esource = handle->source;
+
−
+
−  if (ctx->state EQ TRAVERSE_ARRAY)
+
−  {
+
−    /*
+
−     * for every array element calculate the offset for the
+
−     * C-structure access.
+
−     * offset = leveloffset + (arrayIndex * csize) + 1
+
−     */
+
−	  edescr->offset = elem[ctx->elemIdx].structOffs + ctx->levelOffset
+
−                   + (ctx->arrayIndex
+
−                      * ((elem[ctx->elemIdx].elemType NEQ 'C') 
+
−                         ? var[elem[ctx->elemIdx].elemRef].cSize
+
−                         : comp[elem[ctx->elemIdx].elemRef].cSize
+
−                        )
+
−                     );
+
−/*
+
−                   + 1;
+
−  */
+
−  }
+
−  else
+
−  {
+
−	  edescr->offset = elem[ctx->elemIdx].structOffs
+
−                   + ctx->levelOffset;
+
−  }
+
−
+
−  edescr->level        = handle->level;
+
−  edescr->maxRepeat    = elem[ctx->elemIdx].maxRepeat;
+
−  edescr->index        = NO_REF;
+
−  edescr->ccdIndex     = NO_REF;
+
−  edescr->validRepeats = NO_REF;
+
−  edescr->isOptional   = elem[ctx->elemIdx].optional;
+
−  edescr->arrayType    = NoArray;
+
−  edescr->elemref      = NO_REF;
+
−  edescr->u_member     = FALSE;
+
−  edescr->u_ctrl       = 0xffffffff;
+
−  edescr->bitstring    = 0;
+
−  edescr->c_implicit   = 1;
+
−  edescr->issigned     = 0;
+
−  edescr->valcheck     = 0;
+
−
+
−  if ( edescr->maxRepeat > 0
+
−   && elem[ctx->elemIdx].repType != 'b'
+
−   && elem[ctx->elemIdx].repType != 's'
+
−   && elem[ctx->elemIdx].elemType != 'E'
+
−   && ctx->state == TRAVERSE_STRUCTURE)
+
−  {
+
−    edescr->arrayType = (   elem[ctx->elemIdx].repType == 'v'
+
−                         || elem[ctx->elemIdx].repType == 'i'
+
−                         || elem[ctx->elemIdx].repType == 'J'
+
−                         || elem[ctx->elemIdx].repType == 'j') 
+
−                        ? VarArray
+
−                        : FixArray;
+
−
+
−    if (elem[ctx->elemIdx].repType == 'C'
+
−        || elem[ctx->elemIdx].repType == 'J') 
+
−      edescr->bitstring = 1;
+
−
+
−    if (elem[ctx->elemIdx].repType == 'j'
+
−        || elem[ctx->elemIdx].repType == 'J') 
+
−      edescr->c_implicit = 0;
+
−
+
−    if (handle->level < MAX_LEVELS)
+
−    {
+
−      T_CCDE_CONTEXT * new_ctx = ctx+1;
+
−
+
−      ctx->repeats        = edescr->maxRepeat;
+
−
+
−      handle->canDescent = TRUE;
+
−
+
−	    new_ctx->structIdx      = ctx->structIdx;
+
−
+
−	    new_ctx->elemIdx        = ctx->elemIdx;
+
−	    new_ctx->elemType       = 0;
+
−      new_ctx->arrayIndex     = 0;
+
−	    new_ctx->numElems       = edescr->maxRepeat;
+
−      new_ctx->levelOffset    = ctx->levelOffset;
+
−      new_ctx->arrayType      = edescr->arrayType;
+
−      new_ctx->state          = TRAVERSE_ARRAY;
+
−      /*
+
−       * if the composition is optional, increment the offset
+
−       * because of the valid flag (v_xxx).
+
−       */
+
−      if (edescr->isOptional)
+
−        new_ctx->levelOffset++;
+
−      /*
+
−       * if the composition is a array with variable size,
+
−       * increment the offset because of the counter (c_xxx).
+
−       */
+
−      if (edescr->arrayType EQ VarArray)
+
−        new_ctx->levelOffset += edescr->maxRepeat >> 8 ? 2 : 1;
+
−    }
+
−  }
+
−
+
−  if (ctx->state EQ TRAVERSE_ARRAY)
+
−  {
+
−    /*
+
−     * if the size of the array is variable, mark the
+
−     * components of this array as optional. So we can later
+
−     * determine if the array component is valid
+
−     */
+
−    if (ctx->arrayType EQ VarArray)
+
−      edescr->isOptional = TRUE;
+
−    /*
+
−     * increment the array index
+
−     */
+
−    edescr->index = ctx->arrayIndex++;
+
−  }
+
−
+
−  if (elemtype == isvar)
+
−  {
+
−    /*
+
−     * basic element (var)
+
−     */
+
−    switch (var[elem[ctx->elemIdx].elemRef].cType)
+
−    {
+
−      case 'C':
+
−        edescr->issigned = 1;
+
−        /* fallthrough */
+
−      case 'B':
+
−        edescr->btype = T_byte;
+
−        break;
+
−      case 'T':
+
−        edescr->issigned = 1;
+
−        /* fallthrough */
+
−      case 'S':
+
−        edescr->btype = T_short;
+
−        break;
+
−      case 'M':
+
−        edescr->issigned = 1;
+
−        /* fallthrough */
+
−      case 'L':
+
−        edescr->btype = T_long;
+
−        break;
+
−      case 'X':
+
−        edescr->btype = T_buffer;
+
−        break;
+
−    }
+
−    edescr->bytelen = var[elem[ctx->elemIdx].elemRef].cSize;
+
−
+
−#ifdef CCD_SYMBOLS
+
−    strcpy (edescr->aname, var[elem[ctx->elemIdx].elemRef].name);
+
−    strcpy (edescr->sname, ccddata_get_alias (ctx->elemIdx, (int) isMsg));
+
−    if (edescr->sname[0] == '\0')
+
−      strcpy (edescr->sname, var[elem[ctx->elemIdx].elemRef].name);
+
−    STRNCPY (edescr->lname, str[var[elem[ctx->elemIdx].elemRef].longNameRef],
+
−             LONG_NAME_LENGTH);
+
−#else
+
−    strcpy (edescr->sname, "No name info avail.");
+
−    strcpy (edescr->aname, "No name info avail.");
+
−    strcpy (edescr->lname, "No name info avail.");
+
−#endif
+
−  }
+
−  else if (elemtype == isunion)
+
−  {
+
−    /* union */
+
−    edescr->btype = T_union;
+
−    edescr->bytelen = comp[elem[ctx->elemIdx].elemRef].cSize;
+
−    edescr->elemref = elem[ctx->elemIdx].elemRef;
+
−
+
−#ifdef CCD_SYMBOLS
+
−    strcpy (edescr->aname, comp[elem[ctx->elemIdx].elemRef].name);
+
−    strcpy (edescr->sname, ccddata_get_alias (ctx->elemIdx, (int) isMsg));
+
−    if (edescr->sname[0] == '\0')
+
−      strcpy (edescr->sname, comp[elem[ctx->elemIdx].elemRef].name);
+
−    STRNCPY (edescr->lname, str[comp[elem[ctx->elemIdx].elemRef].longNameRef],
+
−            LONG_NAME_LENGTH);
+
−#else
+
−    strcpy (edescr->sname, "No name info avail.");
+
−    strcpy (edescr->aname, "No name info avail.");
+
−    strcpy (edescr->lname, "No name info avail.");
+
−#endif
+
−  }
+
−  else
+
−  {
+
−    /*
+
−     * substructured info element
+
−     */
+
−    if (elemtype == issdu)
+
−      edescr->btype = T_issdu;
+
−    else
+
−      edescr->btype = T_struct;
+
−    edescr->bytelen = comp[elem[ctx->elemIdx].elemRef].cSize;
+
−    edescr->elemref = elem[ctx->elemIdx].elemRef;
+
−
+
−#ifdef CCD_SYMBOLS
+
−    strcpy (edescr->aname, comp[elem[ctx->elemIdx].elemRef].name);
+
−    strcpy (edescr->sname, ccddata_get_alias (ctx->elemIdx, (int) isMsg));
+
−    if (edescr->sname[0] == '\0')
+
−      strcpy (edescr->sname, comp[elem[ctx->elemIdx].elemRef].name);
+
−    STRNCPY (edescr->lname, str[comp[elem[ctx->elemIdx].elemRef].longNameRef],
+
−            LONG_NAME_LENGTH);
+
−#else
+
−    strcpy (edescr->sname, "No name info avail.");
+
−    strcpy (edescr->aname, "No name info avail.");
+
−    strcpy (edescr->lname, "No name info avail.");
+
−#endif
+
−    if (edescr->arrayType EQ NoArray
+
−      AND handle->level < MAX_LEVELS)
+
−    {
+
−      T_CCDE_CONTEXT * new_ctx = ctx+1;
+
−      
+
−      handle->canDescent     = TRUE;
+
−
+
−	    new_ctx->structIdx      = elem[ctx->elemIdx].elemRef;
+
−
+
−	    new_ctx->elemIdx        = comp[new_ctx->structIdx].componentRef;
+
−	    new_ctx->elemType       = 0;
+
−      new_ctx->arrayIndex     = 0;
+
−	    new_ctx->numElems       = comp[new_ctx->structIdx].numOfComponents;
+
−      new_ctx->levelOffset    = edescr->offset;
+
−      /*
+
−       * if the composition is optional, increment the offset
+
−       * because of the valid flag (v_xxx).
+
−       */
+
−      if (edescr->isOptional)
+
−        new_ctx->levelOffset++;
+
−      /*
+
−       * if the composition is a array with variable size,
+
−       * increment the offset because of the counter (c_xxx).
+
−       */
+
−      if (edescr->arrayType EQ VarArray)
+
−        new_ctx->levelOffset++;
+
−
+
−      new_ctx->state          = TRAVERSE_STRUCTURE;
+
−    }
+
−  }
+
−  
+
−
+
−  if (edescr->arrayType EQ NoArray && elem[ctx->elemIdx].elemType == 'V'
+
−  AND  var[elem[ctx->elemIdx].elemRef].numValueDefs > 0)
+
−  {
+
−    /*
+
−     * value definitions available
+
−     * store the index of this information element in the
+
−     * element descriptor for later value requests.
+
−     */
+
−    edescr->ccdIndex = elem[ctx->elemIdx].elemRef;
+
−  }
+
−    
+
−  ctx->numElems--;
+
−  
+
−  if (ctx->state EQ TRAVERSE_STRUCTURE)
+
−    ctx->elemIdx++;
+
−
+
−  return CCDEDIT_OK;
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CCDEDIT             |
+
−| STATE   : code                       ROUTINE : cde_prim_first      |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : 
+
−
+
−*/
+
−
+
−USHORT CCDDATA_PREF(cde_prim_first) (T_CCDE_HANDLE    * phandle,
+
−                       ULONG              primcode,
+
−                       char             * name)
+
−{
+
−  USHORT SAP, Opcode, Direction, ThePrimitive;
+
−
+
−  if (primcode & 0x80000000)
+
−  {
+
−    SAP       = (USHORT) (primcode & 0x3fff);
+
−    Opcode    = (USHORT) ((primcode >> 16) & 0xff);
+
−  }
+
−  else
+
−  {
+
−    SAP       = (USHORT) (((primcode & 0x3f00)>>8) & 0xff);
+
−    Opcode    = (USHORT) (primcode & 0xff);
+
−  }
+
−  Direction = (USHORT) (((primcode & 0x4000)>>14) & 0x01);
+
−
+
−  if (SAP > ccddata_max_sap_num OR Opcode > ccddata_max_primitive_id)
+
−    return CCDEDIT_PRIM_NOT_FOUND;
+
−
+
−  if ((ThePrimitive = ccddata_get_pmtx(SAP,Opcode,Direction)) EQ NO_REF)
+
−    return CCDEDIT_PRIM_NOT_FOUND;
+
−
+
−  phandle->context[0].structIdx = ThePrimitive;
+
−
+
−#ifdef CCD_SYMBOLS
+
−  strcpy (name, pcomp[phandle->context[0].structIdx].name);
+
−#else
+
−  strcpy (name, "No name info avail.");
+
−#endif
+
−
+
−  phandle->level                  = 0;
+
−	phandle->context[0].elemIdx     = pcomp[phandle->context[0].structIdx].componentRef;
+
−	phandle->context[0].elemType    = 0;
+
−	phandle->context[0].numElems    = pcomp[phandle->context[0].structIdx].numOfComponents;
+
−  phandle->context[0].levelOffset = 0;
+
−  phandle->context[0].arrayIndex  = 0;
+
−  phandle->context[0].state       = TRAVERSE_STRUCTURE;
+
−  phandle->canDescent             = FALSE;
+
−  phandle->source                 = FromPrim;
+
−	phandle->maxCSize               = pcomp[phandle->context[0].structIdx].cSize;
+
−  phandle->lenVarPart             = 0;
+
−
+
−  return CCDEDIT_OK;
+
−}
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CCDEDIT             |
+
−| STATE   : code                       ROUTINE : cde_prim_next       |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : 
+
−
+
−*/
+
−
+
−
+
−USHORT CCDDATA_PREF(cde_prim_next) (T_CCDE_HANDLE      *phandle,
+
−                      UBYTE               descent,
+
−                      T_CCDE_ELEM_DESCR  *pdescr)
+
−{
+
−  return cde_get_next_elem (phandle,
+
−                            descent,
+
−                            pdescr);
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CCDEDIT             |
+
−| STATE   : code                       ROUTINE : cde_msg_first       |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : 
+
−
+
−*/
+
−
+
−USHORT CCDDATA_PREF(cde_msg_first) (T_CCDE_HANDLE  * mhandle,
+
−                      UBYTE            type,
+
−                      UBYTE            direction,
+
−                      UBYTE            entity,
+
−                      char           * name)
+
−
+
−{
+
−  USHORT TheMessage;
+
−
+
−  if (entity > ccddata_num_of_entities OR type > ccddata_max_message_id)
+
−    return CCDEDIT_MESSAGE_NOT_FOUND;
+
−
+
−  if ((TheMessage = ccddata_get_mmtx((USHORT) entity,
+
−                        (USHORT) type,
+
−                        (USHORT) direction)) EQ NO_REF)
+
−    return CCDEDIT_MESSAGE_NOT_FOUND;
+
−
+
−  mhandle->context[0].structIdx = TheMessage;
+
−  
+
−#ifdef CCD_SYMBOLS
+
−  strcpy (name, mcomp[mhandle->context[0].structIdx].name);
+
−#else
+
−  strcpy (name, "No name info avail.");
+
−#endif
+
−
+
−  mhandle->level                  = 0;
+
−	mhandle->context[0].elemIdx     = mcomp[mhandle->context[0].structIdx].componentRef;
+
−	mhandle->context[0].elemType    = 0;
+
−	mhandle->context[0].numElems    = mcomp[mhandle->context[0].structIdx].numOfComponents;
+
−  mhandle->context[0].levelOffset = 0;
+
−  mhandle->context[0].arrayIndex  = 0;
+
−  mhandle->context[0].state       = TRAVERSE_STRUCTURE;
+
−  mhandle->canDescent             = FALSE;
+
−  mhandle->source                 = FromMsg;
+
−	mhandle->maxCSize               = mcomp[mhandle->context[0].structIdx].cSize;
+
−  mhandle->lenVarPart             = 0;
+
−
+
−  return CCDEDIT_OK;
+
−}
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CCDEDIT             |
+
−| STATE   : code                       ROUTINE : cde_msg_next        |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : 
+
−
+
−*/
+
−
+
−USHORT CCDDATA_PREF(cde_msg_next) (T_CCDE_HANDLE     *mhandle,
+
−                     UBYTE              descent,
+
−                     T_CCDE_ELEM_DESCR *iedescr)
+
−{
+
−  return cde_get_next_elem (mhandle,
+
−                            descent,
+
−                            iedescr);
+
−}
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|  Function     :  cde_get_comp
+
−+------------------------------------------------------------------------------
+
−|  Description  :  This function works with similar results like cde_comp_first,
+
−|                  but not the whole comp table is searched for the name of the
+
−|                  component. Instead the previous set elemref in the
+
−|                  parameter edescr is taken to directly jump to the component.
+
−|                  The component found is compared with the given name in
+
−|                  edescr. If equal chandle is defined. Otherwise there is an
+
−|                  error.
+
−|
+
−|  Parameters   :  chandle - the handle for the component (returned)
+
−|                  edescr - the element descriptor
+
−|
+
−|  Return       :  CCDEDIT_OK on success, CCDEDIT_COMP_NOT_FOUND otherwise
+
−+------------------------------------------------------------------------------
+
−*/
+
−
+
−USHORT CCDDATA_PREF(cde_get_comp) (T_CCDE_HANDLE*     chandle,
+
−                     T_CCDE_ELEM_DESCR* edescr)
+
−{
+
−  const T_CCD_CompTabEntry* comp;
+
−  USHORT index = edescr->elemref;
+
−
+
−  if (index == NO_REF)
+
−    return CCDEDIT_COMP_NOT_FOUND;
+
−
+
−  comp = edescr->esource == FromMsg ? &mcomp[index] : &pcomp[index];
+
−
+
−#ifdef CCD_SYMBOLS
+
−  if (strcmp (comp->name, edescr->aname))
+
−    return CCDEDIT_COMP_NOT_FOUND;
+
−#endif /* CCD_SYMBOLS */
+
−
+
−    chandle->context[0].structIdx = index;
+
−    chandle->level                  = 0;
+
−    chandle->context[0].elemIdx     = comp->componentRef;
+
−    chandle->context[0].elemType    = 0;
+
−    chandle->context[0].numElems    = comp->numOfComponents;
+
−    chandle->context[0].levelOffset = 0;
+
−    chandle->context[0].arrayIndex  = 0;
+
−    chandle->context[0].state       = TRAVERSE_STRUCTURE;
+
−    chandle->canDescent             = FALSE;
+
−    chandle->source                 = edescr->esource;
+
−    chandle->maxCSize               = comp->cSize;
+
−    chandle->lenVarPart             = 0;
+
−
+
−    return CCDEDIT_OK;
+
−}
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|  Function     :  cde_comp_alias
+
−+------------------------------------------------------------------------------
+
−|  Description  :  This function works with similar results like cde_comp_first,
+
−|                  but not thewhole comp table is searched for the name of the
+
−|                  component. Instead the alias name (as_name) from ?elem.cdg
+
−|                  is taken for name comparison.
+
−|
+
−|  Parameters   :  chandle - the handle for the component (returned)
+
−|                  source - if message or primitve
+
−|                  name - the name of the searched component
+
−|
+
−|  Return       :  CCDEDIT_OK on success, CCDEDIT_COMP_NOT_FOUND otherwise
+
−+------------------------------------------------------------------------------
+
−*/
+
−USHORT cde_comp_alias (T_CCDE_HANDLE      * chandle,
+
−                              T_ELM_SRC            source,
+
−                              char               * name)
+
−
+
−{
+
−  const T_CCD_CompTabEntry* comp;
+
−  const T_CCD_ElemTabEntry* elem;
+
−  int   found = 0;
+
−  USHORT index, cindex;
+
−
+
−  elem = source == FromMsg ? melem : pelem;
+
−
+
−  index = 0;
+
−  while (!found AND (ccddata_get_alias (index, source == FromMsg) != NULL))
+
−  {
+
−    /* name found */
+
−    if (elem[index].elemType == 'C' &&
+
−        !strcmp (ccddata_get_alias (index, source == FromMsg), name))
+
−      found = 1;
+
−    else
+
−      index++;
+
−  }
+
−  if (!found)
+
−    return CCDEDIT_COMP_NOT_FOUND;
+
−
+
−  cindex = elem[index].elemRef;
+
−  comp = source == FromMsg ? &mcomp[cindex] : &pcomp[cindex];
+
−  chandle->context[0].structIdx = cindex;
+
−  chandle->level                  = 0;
+
−  chandle->context[0].elemIdx     = comp->componentRef;
+
−  chandle->context[0].elemType    = 0;
+
−  chandle->context[0].numElems    = comp->numOfComponents;
+
−  chandle->context[0].levelOffset = 0;
+
−  chandle->context[0].arrayIndex  = 0;
+
−  chandle->context[0].state       = TRAVERSE_STRUCTURE;
+
−  chandle->canDescent             = FALSE;
+
−  chandle->source                 = source;
+
−  chandle->maxCSize               = comp->cSize;
+
−  chandle->lenVarPart             = 0;
+
−
+
−  return CCDEDIT_OK;
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CCDEDIT             |
+
−| STATE   : code                       ROUTINE : cde_comp_first      |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : 
+
−
+
−*/
+
−
+
−USHORT CCDDATA_PREF(cde_comp_first) (T_CCDE_HANDLE      * chandle,
+
−                       T_ELM_SRC            source,
+
−                       char               * compname)
+
−
+
−{
+
−  USHORT index;
+
−  BOOL   found = FALSE;
+
−
+
−  if (source EQ FromMsg)
+
−  {
+
−    /*
+
−     * search the mcomp-table for the given name
+
−     */
+
−    index = 0;
+
−    while (!found AND mcomp[index].name NEQ NULL)
+
−    {
+
−      /*
+
−       * composition name found
+
−       */
+
−      if (strcmp (mcomp[index].name, compname) EQ 0)
+
−        found = TRUE;
+
−      else
+
−        index++;
+
−    }
+
−    if (found)
+
−      chandle->context[0].structIdx = index;
+
−    else
+
−      return CCDEDIT_COMP_NOT_FOUND;
+
−
+
−    chandle->level                  = 0;
+
−	  chandle->context[0].elemIdx     = mcomp[index].componentRef;
+
−	  chandle->context[0].elemType    = 0;
+
−	  chandle->context[0].numElems    = mcomp[index].numOfComponents;
+
−    chandle->context[0].levelOffset = 0;
+
−    chandle->context[0].arrayIndex  = 0;
+
−    chandle->context[0].state       = TRAVERSE_STRUCTURE;
+
−    chandle->canDescent             = FALSE;
+
−    chandle->source                 = FromMsg;
+
−    chandle->maxCSize               = mcomp[index].cSize;
+
−    chandle->lenVarPart             = 0;
+
−  }
+
−  else
+
−  {
+
−    /*
+
−     * search the pcomp-table for the given name
+
−     */
+
−    index = 0;
+
−    while (!found AND pcomp[index].name NEQ NULL)
+
−    {
+
−      /*
+
−       * composition name found
+
−       */
+
−      if (strcmp (pcomp[index].name, compname) EQ 0)
+
−        found = TRUE;
+
−      else
+
−        index++;
+
−    }
+
−    if (found)
+
−      chandle->context[0].structIdx = index;
+
−    else
+
−      return CCDEDIT_COMP_NOT_FOUND;
+
−
+
−    chandle->level                  = 0;
+
−	  chandle->context[0].elemIdx     = pcomp[index].componentRef;
+
−	  chandle->context[0].elemType    = 0;
+
−	  chandle->context[0].numElems    = pcomp[index].numOfComponents;
+
−    chandle->context[0].levelOffset = 0;
+
−    chandle->context[0].arrayIndex  = 0;
+
−    chandle->context[0].state       = TRAVERSE_STRUCTURE;
+
−    chandle->canDescent             = FALSE;
+
−    chandle->source                 = FromPrim;
+
−    chandle->maxCSize               = pcomp[index].cSize;
+
−    chandle->lenVarPart             = 0;
+
−  }
+
−
+
−  return CCDEDIT_OK;
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CCDEDIT             |
+
−| STATE   : code                       ROUTINE : cde_comp_next       |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : 
+
−
+
−*/
+
−
+
−USHORT CCDDATA_PREF(cde_comp_next) (T_CCDE_HANDLE     *chandle,
+
−                      UBYTE              descent,
+
−                      T_CCDE_ELEM_DESCR *descr)
+
−{
+
−  return cde_get_next_elem      (chandle,
+
−                                 descent,
+
−                                 descr);
+
−}
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|  Function     :  cde_get_symval
+
−+------------------------------------------------------------------------------
+
−|  Description  :  This function adds the "Comment" of the SAP-/MSG-catalogues
+
−|                  to the member symbolicValue of a given T_CCDE_ELEM_DESCR.
+
−|
+
−|  Parameters   :  elem_value - the actual value for that the comment
+
−|                               is searched for
+
−|                  edescr - the element descriptor
+
−|
+
−|  Return       :  The string itself is returned which is a pointer to
+
−|                  '\0' if no comment was defined for that value.
+
−+------------------------------------------------------------------------------
+
−*/
+
−
+
−char* CCDDATA_PREF(cde_get_symval) (int elem_value, T_CCDE_ELEM_DESCR* edescr)
+
−{
+
−  edescr->symbolicValue[0] = '\0';
+
−  
+
−  cde_val_iterate (elem_value, edescr);
+
−
+
−  return edescr->symbolicValue;
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CCDEDIT             |
+
−| STATE   : code                       ROUTINE : cde_read_elem       |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Reads the value of the element, referenced by the element
+
−            descriptor edescr, out of the C-Structure cstruct. The 
+
−            value is stored in the memory area, addressed by the
+
−            parameter value.
+
−
+
−*/
+
−
+
−USHORT CCDDATA_PREF(cde_read_elem) (T_CCDE_HANDLE     * handle,
+
−                      void              * cstruct,
+
−                      T_CCDE_ELEM_DESCR * edescr,
+
−                      UBYTE             * value)
+
−{
+
−  T_CONV         * cvp;
+
−  U32              voffset;
+
−  ULONG            elem_value;
+
−  UBYTE          * cs = (UBYTE *) cstruct;
+
−
+
−  /* 
+
−   * if this element is optional and it is no array component
+
−   * read the valid flag out of the C-structure.
+
−   */
+
−  if (edescr->isOptional && edescr->index == NO_REF && edescr->ptrtype != usptr)
+
−  {
+
−    voffset = edescr->offset++;
+
−    edescr->isValid = (cs[voffset] EQ TRUE);
+
−  }
+
−  else
+
−  {
+
−    if (edescr->index NEQ NO_REF)
+
−    {
+
−      T_CCDE_CONTEXT *last_ctx;
+
−
+
−      last_ctx = &handle->context[handle->level-1];
+
−      edescr->isValid = (edescr->index < last_ctx->repeats);
+
−    }
+
−    else
+
−      edescr->isValid = TRUE;
+
−  }
+
−
+
−  if (!edescr->isValid)
+
−    return CCDEDIT_OK;
+
−   
+
−  if (edescr->u_member)
+
−  {
+
−    edescr->u_ctrl = * (U32 *) &cs[edescr->offset];
+
−    edescr->offset += sizeof (U32); 
+
−  }
+
−
+
−  if (edescr->arrayType NEQ NoArray)
+
−  {
+
−    T_CCDE_CONTEXT *ctx;
+
−
+
−    ctx = &handle->context[handle->level];
+
−
+
−    /*
+
−     * array of message elements (info elements)
+
−     */
+
−
+
−    if (edescr->arrayType EQ VarArray)
+
−    {
+
−      USHORT sz_of_len;
+
−      sz_of_len = edescr->maxRepeat >> 8 ? 2 : 1; /* 1 or 2 bytes for len */
+
−      if (sz_of_len == 1)
+
−      {
+
−        ctx->repeats = (USHORT) cs[edescr->offset];
+
−      }
+
−      else
+
−      {
+
−        ctx->repeats = * (USHORT *) &cs[edescr->offset];
+
−      }
+
−      edescr->offset += sz_of_len;
+
−
+
−      if (ctx->repeats > edescr->maxRepeat)
+
−        ctx->repeats = edescr->maxRepeat;
+
−    }
+
−    else
+
−      ctx->repeats = edescr->maxRepeat;
+
−
+
−    edescr->bytelen = edescr->bytelen * ctx->repeats;
+
−    edescr->validRepeats = ctx->repeats;
+
−    *value++ = (UBYTE) edescr->validRepeats;
+
−  }
+
−
+
−  if (edescr->ptrtype != noptr)
+
−  {
+
−    cs = * (UBYTE **) &cs[edescr->offset];
+
−    if (!cs)
+
−    {
+
−      edescr->isValid = FALSE;
+
−      return CCDEDIT_OK;
+
−    }
+
−  }
+
−  else
+
−    cs += edescr->offset;
+
−
+
−  /*
+
−   * read the current value from the C-structure
+
−   */
+
−  if ((edescr->btype == T_issdu) || (edescr->btype == T_buffer))
+
−  {
+
−    USHORT l_buf, o_buf, len;
+
− 
+
−    /*
+
−     * For the structure SDU perform a special handling.
+
−     * The SDU contains l_buf and o_buf and the element
+
−     * buf. This element is only defined as buf[1] because
+
−     * the real length results of the encoded message and
+
−     * must be calculated form l_buf and o_buf
+
−     */
+
−
+
−    /*
+
−     * read l_buf and o_buf (length and offset) out of the struct
+
−     */
+
−    memcpy ((UBYTE *)&l_buf, cs, sizeof (USHORT));
+
−
+
−    memcpy ((UBYTE *)&o_buf, cs+sizeof (USHORT), sizeof (USHORT));
+
−
+
−    len = ((l_buf+o_buf+7)/8);
+
−    handle->lenVarPart += len;
+
−    handle->canDescent = FALSE;
+
−    if ((edescr->btype == T_issdu) &&
+
−        ((len > (U32)(ccddata_get_max_bitstream_len()/8)) ||
+
−        (len > 0x1FFF))) /* max bytes: 0xFFFF/8 = 0x1FFF */
+
−    {
+
−      return CCDEDIT_MESSAGE_ERROR;
+
−    }
+
−    edescr->bytelen    = (2 * sizeof (USHORT)) + len;
+
−  }
+
−  
+
−  memcpy (value, cs, edescr->bytelen);
+
−
+
−  cvp = (T_CONV *) cs;
+
−  
+
−  switch (edescr->btype)
+
−  {
+
−    case T_byte:
+
−      elem_value = (ULONG) cvp->b[0];
+
−      break;
+
−    case T_short:
+
−      elem_value = (ULONG) cvp->s[0];
+
−      break;
+
−    case T_long:
+
−      elem_value = (ULONG) cvp->l;
+
−      break;
+
−    default:
+
−      return CCDEDIT_OK;
+
−  }
+
−
+
−  (void) CCDDATA_PREF(cde_get_symval) (elem_value, edescr);
+
−
+
−  return CCDEDIT_OK;
+
−}
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|  Function     :  cde_write_prepare
+
−+------------------------------------------------------------------------------
+
−|  Description  :  This function prepares the writing of elements, by setting
+
−|                  valid flag, union controller and length of vaiable arrays
+
−|                  if necessary. Current version: only valid flag and union
+
−|                  controller.
+
−|
+
−|  Parameters   :  same as cde_write_elem except value
+
−|
+
−|  Return       :  -
+
−+------------------------------------------------------------------------------
+
−*/
+
−
+
−void CCDDATA_PREF(cde_write_prepare) (T_CCDE_HANDLE     * handle,
+
−                         void              * cstruct,
+
−                         T_CCDE_ELEM_DESCR * edescr)
+
−{
+
−  UBYTE          * cs = (UBYTE *) cstruct;
+
−
+
−  /* 
+
−   * if this element is optional and it is no array component
+
−   * set the corresponding valid flag in the C-structure.
+
−   */
+
−  if (edescr->isOptional && edescr->ptrtype != usptr)
+
−  {
+
−    cs[edescr->offset++] = TRUE;
+
−  }
+
−
+
−  if (edescr->u_member)
+
−  {
+
−    * (U32 *) &cs[edescr->offset] = (UBYTE) edescr->u_ctrl;
+
−    edescr->offset += sizeof (U32); 
+
−  }
+
−}
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CCDEDIT             |
+
−| STATE   : code                       ROUTINE : cde_write_elem      |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Write the value wich is stored in the memory area,
+
−            addressed by the parameter value, into the C-Structure
+
−            element, referenced by the element descriptor edescr.
+
−
+
−*/
+
−
+
−USHORT CCDDATA_PREF(cde_write_elem) (T_CCDE_HANDLE     * handle,
+
−                       void              * cstruct,
+
−                       T_CCDE_ELEM_DESCR * edescr,
+
−                       UBYTE             * value)
+
−{
+
−  char  *cs = (UBYTE *) cstruct;
+
−  char  *vb;
+
−  U32   len;
+
−   
+
−  CCDDATA_PREF(cde_write_prepare) (handle, cs, edescr);
+
−
+
−  if ((edescr->arrayType != NoArray) && (edescr->btype != T_struct)) 
+
−  {
+
−    T_CCDE_CONTEXT *ctx;
+
−    T_CCDE_CONTEXT _ctx;
+
−
+
−    ctx = handle ? &handle->context[handle->level] : &_ctx;
+
−
+
−    /*
+
−     * Array of message elements (info elements) or 
+
−     * parameter.
+
−     * In case of variable sized arrays, store the 
+
−     * amount of elements into the corresponding c_xxx variable 
+
−     */
+
−    if (edescr->arrayType EQ VarArray)
+
−    {
+
−      /*
+
−       * array with a variable number of elements
+
−       * set the c_xxx variable in the C-Structure
+
−       */
+
−      USHORT sz_of_len;
+
−      sz_of_len = edescr->maxRepeat >> 8 ? 2 : 1; /* 1 or 2 bytes for len */
+
−      if (sz_of_len == 1)
+
−      {
+
−        cs[edescr->offset] = (UBYTE) edescr->validRepeats;
+
−      }
+
−      else
+
−      {
+
−        * (USHORT *) &cs[edescr->offset] = edescr->validRepeats;
+
−      }
+
−      edescr->offset += sz_of_len;
+
−    }
+
−    ctx->repeats = edescr->validRepeats; 
+
−    if (edescr->bitstring)
+
−    {
+
−      ctx->repeats = (ctx->repeats+7)/8; 
+
−    }
+
−
+
−    edescr->bytelen = edescr->bytelen * ctx->repeats;
+
−  }
+
−
+
−  if (edescr->ptrtype != noptr)
+
−  {
+
−    char* pointer = value;
+
−    vb = (char*) &pointer;
+
−    len = sizeof (char*);
+
−  }
+
−  else
+
−  {
+
−    vb = (char*) value;
+
−    len = edescr->bytelen;
+
−
+
−    if ((edescr->btype == T_issdu) || (edescr->btype == T_buffer))
+
−    {
+
−      USHORT l_buf, o_buf;
+
−   
+
−      /*
+
−       * For the structure SDU perform a special handling.
+
−       * The SDU contains l_buf and o_buf and the element
+
−       * buf. This element is only defined as buf[1] because
+
−       * the real length results of the encoded message and
+
−       * must be calculated form l_buf and o_buf
+
−       */
+
−
+
−      /*
+
−       * read l_buf and o_buf (length and offset) out of the value
+
−       */
+
−      memcpy ((UBYTE *)&l_buf, vb, sizeof (USHORT));
+
−
+
−      memcpy ((UBYTE *)&o_buf, vb+sizeof (USHORT), sizeof (USHORT));
+
−
+
−      len = (2 * sizeof (USHORT)) + ((l_buf+o_buf+7)/8);
+
−      if (handle)
+
−      {
+
−        if (edescr->ptrtype == noptr)
+
−          handle->lenVarPart += (USHORT) len;
+
−        else
+
−          handle->lenVarPart += sizeof (void*);
+
−      }
+
−      edescr->bytelen = len;
+
−    }
+
−  }
+
−
+
−  /*
+
−   * write the value into the C-structure
+
−   */
+
−  memcpy (cs+edescr->offset, vb, len);
+
−
+
−  return CCDEDIT_OK;
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CCDEDIT             |
+
−| STATE   : code                       ROUTINE : cde_get_type        |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Requests the type (primitive or message) for a given
+
−            name. The type is stored in the return parameter type.
+
−
+
−*/
+
−
+
−USHORT CCDDATA_PREF(cde_get_type) (char      *name,
+
−                     T_ELM_SRC *type)
+
−{
+
−#ifdef CCD_SYMBOLS
+
−  USHORT SAP, Opcode, Direction, Entity;
+
−
+
−  /*
+
−   * check the primitive table first. Look in all SAPs ands for
+
−   * all direction alls opcodes to find the name as a primitve 
+
−   * name.
+
−   */
+
−
+
−  for (SAP = 0; SAP <= ccddata_max_sap_num; SAP++)
+
−    for (Direction = 0; Direction <= 1; Direction++)
+
−      for (Opcode = 0; Opcode <= ccddata_max_primitive_id; Opcode++)
+
−        if (ccddata_get_pmtx(SAP, Opcode, Direction) NEQ NO_REF)
+
−        {
+
−          if (!strcmp (name,
+
−                       pcomp[ccddata_get_pmtx(SAP, Opcode, Direction)].name)) 
+
−          {
+
−            *type = FromPrim;
+
−            return CCDEDIT_OK;
+
−          }
+
−        }
+
−
+
−  /*
+
−   * check the message table second. Look in all entities ands for
+
−   * all direction alls opcodes to find the name as a message
+
−   * name.
+
−   */
+
−
+
−  for (Entity = 0; Entity < ccddata_num_of_entities; Entity++)
+
−    for (Direction = 0; Direction <= 1; Direction++)
+
−      for (Opcode = 0; Opcode <= ccddata_max_message_id; Opcode++)
+
−        if (ccddata_get_mmtx(Entity, Opcode, Direction) NEQ NO_REF)
+
−        {
+
−          if (!strcmp (name,
+
−                       mcomp[ccddata_get_mmtx(Entity, Opcode, Direction)].name)) 
+
−          {
+
−            *type = FromPrim;
+
−            return CCDEDIT_OK;
+
−          }
+
−        }
+
−
+
−#endif
+
−
+
−  return CCDEDIT_PRIM_NOT_FOUND;
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CCDEDIT             |
+
−| STATE   : code                       ROUTINE : cde_get_primcode    |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Requests the opcode of the primitive for a given
+
−            name. The opcode is stored in the return parameter primcode.
+
−
+
−*/
+
−
+
−USHORT CCDDATA_PREF(cde_get_primcode) (char      *name,
+
−                         ULONG    *primcode)
+
−{
+
−#ifdef CCD_SYMBOLS
+
−  USHORT SAP, Opcode, Direction;
+
−
+
−  /*
+
−   * check the primitive table. Look in all SAPs ands for
+
−   * all direction alls opcodes to find the name as a primitve 
+
−   * name.
+
−   */
+
−
+
−  for (SAP = 0; SAP <= ccddata_max_sap_num; SAP++)
+
−    for (Direction = 0; Direction <= 1; Direction++)
+
−      for (Opcode = 0; Opcode <= ccddata_max_primitive_id; Opcode++)
+
−        if (ccddata_get_pmtx(SAP, Opcode, Direction) NEQ NO_REF)
+
−        {
+
−          if (!strcmp (name, pcomp[ccddata_get_pmtx(SAP, Opcode, Direction)].name)) 
+
−          {
+
−            *primcode = ((Direction & 0x01) << 14);
+
−            *primcode |= (SAP & 0x3fff);
+
−            *primcode |= ((Opcode & 0xff) << 16);
+
−            *primcode |= 0x80000000;
+
−            
+
−            return CCDEDIT_OK;
+
−          }
+
−        }
+
−#endif
+
−
+
−  return CCDEDIT_PRIM_NOT_FOUND;
+
−}
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : CCD (6144)                 MODULE  : CCDEDIT             |
+
−| STATE   : code                       ROUTINE : cde_get_msgcode     |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Requests the opcode, the direction and the entity-number
+
−            of the message for a given name.
+
−            The opcode is stored in the return parameters .
+
−
+
−*/
+
−
+
−USHORT CCDDATA_PREF(cde_get_msgcode) (char      *name,
+
−                        UBYTE     *type,
+
−                        UBYTE     *direction,
+
−                        UBYTE     *entity)
+
−{
+
−#ifdef CCD_SYMBOLS
+
−  USHORT Opcode, Direction, Entity;
+
−
+
−  /*
+
−   * check the message table. Look in all entities ands for
+
−   * all direction alls opcodes to find the name as a message
+
−   * name.
+
−   */
+
−
+
−  for (Entity = 0; Entity < ccddata_num_of_entities; Entity++)
+
−    for (Direction = 0; Direction <= 1; Direction++)
+
−      for (Opcode = 0; Opcode <= ccddata_max_message_id; Opcode++)
+
−        if (ccddata_get_mmtx(Entity, Opcode, Direction) NEQ NO_REF)
+
−        {
+
−          if (!strcmp (name,
+
−              mcomp[ccddata_get_mmtx(Entity, Opcode, Direction)].name)) 
+
−          {
+
−            *type      = (UBYTE) Opcode;
+
−            *direction = (UBYTE) Direction;
+
−            *entity    = (UBYTE) Entity;
+
−            return CCDEDIT_OK;
+
−          }
+
−        }
+
−
+
−#endif
+
−
+
−  return CCDEDIT_MESSAGE_NOT_FOUND;
+
−}
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|  Function     :  cde_get_is_downlink
+
−+------------------------------------------------------------------------------
+
−|  Description  :  This function finds out if an AIM is a downlink or uplink.
+
−|
+
−|  Parameters   :  comp_index.
+
−|
+
−|  Return       :  False if uplink otherwise true (downlink or both).
+
−+------------------------------------------------------------------------------
+
−*/
+
−int CCDDATA_PREF(cde_get_is_downlink) (ULONG comp_index)
+
−{
+
−  UBYTE ent;
+
−  UBYTE msg_id;
+
−
+
−  for(ent = 0; ent < ccddata_num_of_entities ; ent++)
+
−  {
+
−    for(msg_id = 0; msg_id <= ccddata_max_message_id ; msg_id++)
+
−    {
+
−      if(ccddata_get_mmtx (ent, msg_id, 1) == (USHORT)comp_index)
+
−        return 1;
+
−    }
+
−  }
+
−  return 0;
+
−}
+
−
+
−/*
+
− * The following functions are copied from ..\TAP\tdc_interface.c and
+
− * renamed to get the cde_ prefix instead of tdc_.
+
− * It should be checked if instead of these functions the usual approach
+
− * to ccdedit by the functions pairs cde_comp_first/cde_comp_next
+
− * (respectively their prim/msg pendants) can be used (maybe in combination
+
− * with cde_get_comp). If the check confirms to use the usual approach,
+
− * those 3 functions here should be deleted again
+
− */
+
−/*
+
−+------------------------------------------------------------------------------
+
−|  Function     :  cde_get_comp_index
+
−+------------------------------------------------------------------------------
+
−|  Description  :  This function searches the comp index in either pcomp or mcomp
+
−|
+
−|  Parameters   :  name and table type.
+
−|
+
−|  Return       :  The table entry, if non found it returns 0xffffffff;
+
−+------------------------------------------------------------------------------
+
−*/
+
−
+
−ULONG CCDDATA_PREF(cde_get_comp_index) (CHAR* comp_name, T_ELM_SRC table)
+
−{
+
−  ULONG comp_index;
+
−  BOOL  found = FALSE;
+
−
+
−  if (table == FromMsg)
+
−  {
+
−    /*
+
−     * search the mcomp-table for the given name
+
−    */
+
−    comp_index = 0;
+
−    while (!found AND mcomp[comp_index].name NEQ NULL)
+
−    {
+
−      /*
+
−       * composition name found
+
−       */
+
−      if (strcmp (mcomp[comp_index].name, comp_name) EQ 0)
+
−        found = TRUE;
+
−      else
+
−        comp_index++;
+
−    }
+
−    if(found)
+
−      return comp_index;
+
−    else
+
−      return NO_ENTRY_FOUND;
+
−  }
+
−  else
+
−  {
+
−    /*
+
−     * search the pcomp-table for the given name
+
−     */
+
−    comp_index = 0;
+
−    while (!found AND pcomp[comp_index].name NEQ NULL)
+
−    {
+
−      /*
+
−       * composition name found
+
−       */
+
−      if (strcmp (pcomp[comp_index].name, comp_name) EQ 0)
+
−        found = TRUE;
+
−      else
+
−        comp_index++;
+
−    }
+
−    if(found)
+
−      return comp_index;
+
−    else
+
−      return NO_ENTRY_FOUND;
+
−  }
+
−}
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|  Function     :  cde_get_element_name
+
−+------------------------------------------------------------------------------
+
−|  Description  :  This function gets the element name for a given index + offset.
+
−|
+
−|  Parameters   :  comp_index, offset and table type.
+
−|
+
−|  Return       :  The element name.
+
−+------------------------------------------------------------------------------
+
−*/
+
−
+
−CHAR* CCDDATA_PREF(cde_get_element_name) (ULONG comp_index, USHORT elem_off , T_ELM_SRC table)
+
−{
+
−  if (table == FromMsg)
+
−  {
+
−    if (mcomp[comp_index].componentRef == -1 || elem_off >= mcomp[comp_index].numOfComponents)
+
−      return NULL;
+
−    return ccddata_get_alias ((USHORT) (mcomp[comp_index].componentRef + elem_off), table == FromMsg);
+
−  }
+
−  else
+
−    if (pcomp[comp_index].componentRef == -1 || elem_off >= pcomp[comp_index].numOfComponents)
+
−      return NULL;
+
−    return ccddata_get_alias ((USHORT) (pcomp[comp_index].componentRef + elem_off), table == FromMsg);
+
−}
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|  Function     :  cde_get_array_kind
+
−+------------------------------------------------------------------------------
+
−|  Description  :  This function gets the array kind - e.g. the cSize of the 
+
−|                  arrays (byte, short og long).
+
−|
+
−|  Parameters   :  Name of the base type (var_name) and table type.
+
−|
+
−|  Return       :  The cSize of the var_name. If not found it returns 0xffffffff
+
−+------------------------------------------------------------------------------
+
−*/
+
−
+
−ULONG CCDDATA_PREF(cde_get_array_kind) (CHAR* var_name, T_ELM_SRC table)
+
−{
+
−  ULONG var_index;
+
−  BOOL found = FALSE;
+
−
+
−  if (table == FromMsg)
+
−  {
+
−    /*
+
−     * search the mvar-table for the given name
+
−    */
+
−    var_index = 0;
+
−    while (!found AND mvar[var_index].name NEQ NULL)
+
−    {
+
−      /*
+
−       * name found
+
−       */
+
−      if (strcmp (mvar[var_index].name, var_name) EQ 0)
+
−        found = TRUE;
+
−      else
+
−        var_index++;
+
−    }
+
−    if(found)
+
−      return (ULONG) mvar[var_index].cSize;
+
−    else
+
−      return NO_ENTRY_FOUND;
+
−  }
+
−  else
+
−  {
+
−    /*
+
−     * search the pvar-table for the given name
+
−     */
+
−    var_index = 0;
+
−    while (!found AND pvar[var_index].name NEQ NULL)
+
−    {
+
−      /*
+
−       * name found
+
−       */
+
−      if (strcmp (pvar[var_index].name, var_name) EQ 0)
+
−        found = TRUE;
+
−      else
+
−        var_index++;
+
−    }
+
−    if(found)
+
−      return (ULONG) pvar[var_index].cSize;
+
−    else
+
−      return NO_ENTRY_FOUND;
+
−  }
+
−}