/* 
+----------------------------------------------------------------------------- 
|  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;
  }
}