diff gsm-fw/ccd/ccddata_load.c @ 648:970d6199f2c5

gsm-fw/ccd/*.[ch]: initial import from the LoCosto source
author Michael Spacefalcon <msokolov@ivan.Harhan.ORG>
date Thu, 04 Sep 2014 05:48:57 +0000
parents
children
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gsm-fw/ccd/ccddata_load.c	Thu Sep 04 05:48:57 2014 +0000
@@ -0,0 +1,3790 @@
+/* 
++----------------------------------------------------------------------------- 
+|  Project :  
+|  Modul   : ccddata_load.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 :  Manage the explicit dynamic loading of ccddata.
++----------------------------------------------------------------------------- 
+*/
+
+/*==== INCLUDES ==============================================================*/
+#include <windows.h>
+#include <string.h>
+#include <stdio.h>
+#include "typedefs.h"
+#include "vsi.h"
+#include "ccdtable.h"
+#include "ccdapi.h"
+#include "pdi.h"
+#include "pcon.h"
+#include "ccdedit.h"
+#include "ccddata.h"
+#include "ccddata_tap_priv.h"
+/*==== CONSTS ================================================================*/
+#define MAXPROC 16
+/*==== TYPES =================================================================*/
+/* pcon.c */
+typedef ULONG (*T_pcon_init_prim_coding)(T_HANDLE caller, UBYTE format);
+typedef ULONG (*T_pcon_decodePrim)(ULONG opc,
+                                    void ** decoded_prim,
+                                    void * coded_prim,
+                                    ULONG * length,
+                                    ULONG woff);
+typedef ULONG (*T_pcon_codePrim)(ULONG opc,
+                                  void * decoded_prim,
+                                  void ** coded_prim,
+                                  ULONG * length,
+                                  ULONG woff,
+                                  char* receiver);
+typedef ULONG (*T_pcon_init_ccddata)(void);
+typedef ULONG (*T_pcon_make_filter)(char* string, void** prim);
+typedef ULONG (*T_pcon_filter_decode_prim)(ULONG opc,
+                                           void** decoded_prim,
+                                           void* coded_prim,
+                                           ULONG* length,
+                                           ULONG woff,
+                                           void** shadow_prim);
+/* ccddata_pdi.c */
+typedef int (*T_ccddata_get_pdi_dinfo)(const T_PDI_DECODEINFO* (*dinfo) );
+/* ccddata_mconst.c */
+typedef int (*T_ccddata_get_num_of_entities)(void);
+typedef int (*T_ccddata_get_max_message_id)(void);
+typedef int (*T_ccddata_get_max_bitstream_len)(void);
+typedef int (*T_ccddata_get_max_mstruct_len)(void);
+typedef int (*T_ccddata_get_max_mstruct_len)(void);
+typedef int (*T_ccddata_mccd_symbols)(void);
+/* ccddata_pconst.c */
+typedef int (*T_ccddata_get_max_sap_num)(void);
+typedef int (*T_ccddata_get_max_primitive_id)(void);
+typedef int (*T_ccddata_get_max_pstruct_len)(void);
+/* ccddata_ccdmtab.c */
+typedef const T_CCD_VarTabEntry*   (*T_ccddata_get_mvar)  (USHORT idx);
+typedef const T_CCD_SpareTabEntry* (*T_ccddata_get_spare) (USHORT idx);
+typedef const T_CCD_CalcTabEntry*  (*T_ccddata_get_calc)  (USHORT idx);
+typedef const T_CCD_CompTabEntry*  (*T_ccddata_get_mcomp) (USHORT idx);
+typedef const T_CCD_ElemTabEntry*  (*T_ccddata_get_melem) (USHORT idx);
+typedef const T_CCD_CalcIndex*     (*T_ccddata_get_calcidx) (USHORT idx);
+typedef USHORT (*T_ccddata_get_mmtx) (USHORT entity, USHORT msgid, USHORT idx);
+/* ccddata_ccdptab.c */
+typedef const T_CCD_VarTabEntry*  (*T_ccddata_get_pvar)  (USHORT idx);
+typedef const T_CCD_CompTabEntry* (*T_ccddata_get_pcomp) (USHORT idx);
+typedef const T_CCD_ElemTabEntry* (*T_ccddata_get_pelem) (USHORT idx);
+typedef USHORT (*T_ccddata_get_pmtx) (USHORT sap, USHORT primid, USHORT idx);
+/* ccddata_cdemval.c */
+typedef const T_CCD_ValTabEntry* (*T_ccddata_get_mval) (USHORT idx);
+/* ccddata_cdemstr.c */
+typedef const T_CCD_StrTabEntry* (*T_ccddata_get_mstr) (USHORT idx);
+/* ccddata_cdepval.c */
+typedef const T_CCD_ValTabEntry* (*T_ccddata_get_pval) (USHORT idx);
+typedef const T_CCD_StrTabEntry* (*T_ccddata_get_pstr) (USHORT idx);
+/* ccddata_ccdent.c */
+typedef short (*T_ccddata_get_ccdent) (char* entname);
+typedef const char * (*T_ccddata_get_entname) (short ccdent);
+/* ccddata_alias.c */
+typedef char* (*T_ccddata_get_alias) (USHORT idx, int from_msg);
+/* ccddata_version.c */
+typedef char* (*T_ccddata_get_version) ();
+typedef int (*T_ccddata_get_table_version) ();
+/* ccd_config.c */
+typedef UBYTE* (*T_ccddata_get_mi_length) (void);
+typedef UBYTE* (*T_ccddata_get_decmsgbuffer) (void);
+/* ccddata_tap_priv.c */
+typedef int (*T_ccddata_tap_get_pd) (UCHAR comp);
+typedef int (*T_ccddata_tap_check_pd) (UCHAR comp, UCHAR pd);
+/* ccddata_eg.c */
+typedef int (*T_ccddata_eg_nodes) (void);
+typedef char** (*T_ccddata_eg_nodenames) (void);
+typedef char* (*T_ccddata_eg_adjacent) (int idx);
+typedef int (*T_ccddata_eg_saps) (void);
+typedef char** (*T_ccddata_eg_sapnames) (void);
+typedef T_COMENDPOINTS* (*T_ccddata_eg_comendpoints) (int idx);
+/* ccdedit.c */
+typedef void (*T_cde_init) (void);
+typedef USHORT (*T_cde_get_comp) (T_CCDE_HANDLE* chandle,
+                                  T_CCDE_ELEM_DESCR* edescr);
+typedef USHORT (*T_cde_prim_first) (T_CCDE_HANDLE* phandle,
+                                    ULONG primcode,
+                                    char* name);
+typedef USHORT (*T_cde_prim_next) (T_CCDE_HANDLE* phandle,
+                                   UBYTE descent,
+                                   T_CCDE_ELEM_DESCR* pdescr);
+typedef USHORT (*T_cde_msg_first) (T_CCDE_HANDLE* mhandle,
+                                  UBYTE type,
+                                  UBYTE direction,
+                                  UBYTE entity,
+                                  char* name);
+typedef USHORT (*T_cde_msg_next) (T_CCDE_HANDLE* mhandle,
+                                  UBYTE descent,
+                                  T_CCDE_ELEM_DESCR* iedesrc);
+typedef USHORT (*T_cde_comp_first) (T_CCDE_HANDLE* chandle,
+                                    T_ELM_SRC source,
+                                    char* compname);
+typedef USHORT (*T_cde_comp_next) (T_CCDE_HANDLE* chandle,
+                                   UBYTE descent,
+                                   T_CCDE_ELEM_DESCR* descr);
+typedef char* (*T_cde_get_symval) (int elem_value,
+                                   T_CCDE_ELEM_DESCR* descr);
+typedef USHORT (*T_cde_read_elem) (T_CCDE_HANDLE* handle,
+                                   void* cstruct,
+                                   T_CCDE_ELEM_DESCR* descr,
+                                   UBYTE* value);
+typedef void (*T_cde_write_prepare) (T_CCDE_HANDLE* handle,
+                                     void* cstruct,
+                                     T_CCDE_ELEM_DESCR* descr);
+typedef USHORT (*T_cde_write_elem) (T_CCDE_HANDLE* handle,
+                                    void* cstruct,
+                                    T_CCDE_ELEM_DESCR* descr,
+                                    UBYTE* value);
+typedef USHORT (*T_cde_get_type) (char* name, T_ELM_SRC* source);
+typedef USHORT (*T_cde_get_primcode) (char* name, ULONG* primcode);
+typedef USHORT (*T_cde_get_msgcode) (char* name,
+                                     UBYTE* type,
+                                     UBYTE* direction,
+                                     UBYTE* entity);
+typedef int (*T_cde_get_is_downlink) (ULONG comp_index);
+typedef ULONG (*T_cde_get_comp_index) (char* comp_name, T_ELM_SRC table);
+typedef char* (*T_cde_get_element_name) (ULONG comp_index,
+                                         USHORT elem_off,
+                                         T_ELM_SRC table);
+typedef ULONG (*T_cde_get_array_kind) (char* var_name, T_ELM_SRC table);
+/* pdi.c */
+typedef T_PDI_CONTEXT* (*T_pdi_createDefContext) ();
+typedef T_PDI_CONTEXT* (*T_pdi_createContext) (const T_PDI_DECODEINFO* dinfop,
+                                                unsigned int dicount);
+typedef void (*T_pdi_destroyContext) (T_PDI_CONTEXT* context);
+typedef void (*T_pdi_startPrim) (T_PDI_CONTEXT* context, ULONG opc);
+typedef void (*T_pdi_getDecodeInfo) (T_PDI_CONTEXT* context,
+                                       const char* ename,
+                                       char* evalue,
+                                       int evlen,
+                                       T_PDI* decinfo);
+typedef short (*T_pdi_getEntityByPD) (const T_PDI_CONTEXT* context,
+                                         unsigned char pd);
+typedef const char* (*T_pdi_pd2name) (unsigned char pd);
+/* ccd.c */
+typedef int   (*T_ccd_set_patch_infos) (T_patch_info* pinfo);
+typedef BYTE  (*T_ccd_init) (void);
+typedef int   (*T_ccd_exit) (void);
+typedef UBYTE* (*T_ccd_begin) (void);
+typedef void  (*T_ccd_end) (void);
+typedef BYTE  (*T_ccd_decodeMsg) (UBYTE entity,
+                                  UBYTE direction,
+                                  T_MSGBUF *mBuf,
+                                  UBYTE *mStruct,
+                                  UBYTE pt);
+typedef S8   (*T_ccd_decodeMsgPtr) (U8 entity,
+                                    U8 direction,
+                                    U16 l_buf,
+                                    U16 o_buf,
+                                    U8 *buf,
+                                    U8 **mStructPtr,
+                                    U8 pt);
+typedef BYTE  (*T_ccd_codeMsg) (UBYTE entity,
+                                UBYTE direction,
+                                T_MSGBUF *mBuf,
+                                UBYTE *mStruct,
+                                UBYTE pt);
+typedef BYTE (*T_ccd_codeMsgPtr) (U8 entity,
+                                  U8 direction,
+                                  U16 *l_buf,
+                                  U16 o_buf,
+                                  U8 *buf,
+                                  U8 *mStruct,
+                                  U8 pt);
+typedef ULONG  (*T_ccd_init_ccddata) (void);
+/* cdc_std.c */
+typedef BYTE  (*T_ccd_decodeByte) (UBYTE *bitstream,
+                                   USHORT startbit,
+                                   USHORT bitlen,
+                                   UBYTE *value);
+typedef BYTE  (*T_ccd_codeByte) (UBYTE *bitstream,
+                                 USHORT startbit,
+                                 USHORT bitlen,
+                                 UBYTE val);
+typedef BYTE  (*T_ccd_codeLong) (UBYTE *bitstream,
+                                 USHORT startbit,
+                                 USHORT bitlen,
+                                 ULONG value);
+typedef BYTE  (*T_ccd_decodeLong) (UBYTE *bitstream,
+                                   USHORT startbit,
+                                   USHORT bitlen,
+                                   ULONG *value);
+typedef void  (*T_ccd_bitcopy) (UBYTE *dest,
+                                UBYTE *source,
+                                USHORT bitlen,
+                                USHORT offset);
+/* ccd_err.c */
+typedef UBYTE (*T_ccd_getFirstError) (UBYTE entity, USHORT *parlist);
+typedef UBYTE (*T_ccd_getNextError) (UBYTE entity, USHORT *parlist);
+typedef ULONG (*T_ccd_getFirstFault) (T_CCD_ERR_ENTRY **ccd_err_entry);
+typedef ULONG (*T_ccd_getNextFault) (T_CCD_ERR_ENTRY **ccd_err_entry);
+typedef void  (*T_ccd_free_faultlist) (void);
+typedef int   (*T_ccd_get_numFaults) (void);
+/* ccd_elem.c */
+typedef int  (*T_ccd_encodeElem) (ULONG ccdid,
+                                  USHORT *l_buf,
+                                  USHORT o_buf,
+                                  UCHAR *buf,
+                                  UCHAR *eStruct);
+
+typedef int  (*T_ccd_decodeElem) (ULONG ccdid,
+                                  USHORT l_buf,
+                                  USHORT o_buf,
+                                  UCHAR *buf,
+                                  UCHAR *eStruct);
+/*==== LOCALS ================================================================*/
+static int me = -1;
+static HANDLE initlock;
+static void (*ccddata_i_notify)(void)=NULL;
+static void (*ccddata_x_notify)(void)=NULL;
+
+static int ccddata_attach (int i);
+
+#pragma data_seg(".shared")
+static char lastdll[MAX_PATH] = { 0 };
+static DWORD ptrindex[MAXPROC] = {0, 0, 0, 0, 0, 0, 0, 0,
+                                  0, 0, 0, 0, 0, 0, 0, 0 };
+static HINSTANCE cdll[MAXPROC] = {0, 0, 0, 0, 0, 0, 0, 0,
+                                  0, 0, 0, 0, 0, 0, 0, 0 };
+static HANDLE mut[MAXPROC] = {0, 0, 0, 0, 0, 0, 0, 0,
+                              0, 0, 0, 0, 0, 0, 0, 0 };
+static T_pcon_init_prim_coding ptr_pcon_init_prim_coding[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_pcon_decodePrim ptr_pcon_decodePrim[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_pcon_codePrim ptr_pcon_codePrim[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_pcon_init_ccddata ptr_pcon_init_ccddata[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_pcon_make_filter ptr_pcon_make_filter[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_pcon_filter_decode_prim ptr_pcon_filter_decode_prim[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_pdi_dinfo ptr_ccddata_get_pdi_dinfo[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_num_of_entities ptr_ccddata_get_num_of_entities[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_max_message_id ptr_ccddata_get_max_message_id[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_max_bitstream_len
+  ptr_ccddata_get_max_bitstream_len[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_max_mstruct_len ptr_ccddata_get_max_mstruct_len[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_mccd_symbols ptr_ccddata_mccd_symbols[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_max_sap_num ptr_ccddata_get_max_sap_num[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_max_primitive_id ptr_ccddata_get_max_primitive_id[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_max_pstruct_len ptr_ccddata_get_max_pstruct_len[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_mvar ptr_ccddata_get_mvar[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_spare ptr_ccddata_get_spare[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_calc ptr_ccddata_get_calc[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_mcomp ptr_ccddata_get_mcomp[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_melem ptr_ccddata_get_melem[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_calcidx ptr_ccddata_get_calcidx[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_mmtx ptr_ccddata_get_mmtx[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_pvar ptr_ccddata_get_pvar[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_pcomp ptr_ccddata_get_pcomp[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_pelem ptr_ccddata_get_pelem[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_pmtx ptr_ccddata_get_pmtx[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_mval ptr_ccddata_get_mval[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_mstr ptr_ccddata_get_mstr[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_pval ptr_ccddata_get_pval[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_pstr ptr_ccddata_get_pstr[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_ccdent ptr_ccddata_get_ccdent[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_entname ptr_ccddata_get_entname[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_alias ptr_ccddata_get_alias[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_version ptr_ccddata_get_version[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_table_version ptr_ccddata_get_table_version[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_mi_length ptr_ccddata_get_mi_length[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static UBYTE* mi_length[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_get_decmsgbuffer ptr_ccddata_get_decmsgbuffer[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static UBYTE* decmsgbuffer[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_tap_check_pd ptr_ccddata_tap_check_pd[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_tap_get_pd ptr_ccddata_tap_get_pd[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_eg_nodes ptr_ccddata_eg_nodes[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_eg_nodenames ptr_ccddata_eg_nodenames[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_eg_adjacent ptr_ccddata_eg_adjacent[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_eg_saps ptr_ccddata_eg_saps[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_eg_sapnames ptr_ccddata_eg_sapnames[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccddata_eg_comendpoints ptr_ccddata_eg_comendpoints[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_cde_init ptr_cde_init[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_cde_get_comp ptr_cde_get_comp[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_cde_prim_first ptr_cde_prim_first[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_cde_prim_next ptr_cde_prim_next[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_cde_msg_first ptr_cde_msg_first[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_cde_msg_next ptr_cde_msg_next[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_cde_comp_first ptr_cde_comp_first[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_cde_comp_next ptr_cde_comp_next[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_cde_get_symval ptr_cde_get_symval[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_cde_read_elem ptr_cde_read_elem[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_cde_write_prepare ptr_cde_write_prepare[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_cde_write_elem ptr_cde_write_elem[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_cde_get_type ptr_cde_get_type[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_cde_get_primcode ptr_cde_get_primcode[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_cde_get_msgcode ptr_cde_get_msgcode[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_cde_get_is_downlink ptr_cde_get_is_downlink[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_cde_get_comp_index ptr_cde_get_comp_index[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_cde_get_element_name ptr_cde_get_element_name[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_cde_get_array_kind ptr_cde_get_array_kind[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_pdi_createDefContext ptr_pdi_createDefContext[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_pdi_createContext ptr_pdi_createContext[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_pdi_destroyContext ptr_pdi_destroyContext[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_pdi_startPrim ptr_pdi_startPrim[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_pdi_getDecodeInfo ptr_pdi_getDecodeInfo[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_pdi_getEntityByPD ptr_pdi_getEntityByPD[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_pdi_pd2name ptr_pdi_pd2name[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_set_patch_infos ptr_ccd_set_patch_infos[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_init ptr_ccd_init[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_exit ptr_ccd_exit[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_begin ptr_ccd_begin[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_end ptr_ccd_end[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_decodeMsg ptr_ccd_decodeMsg[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_decodeMsgPtr ptr_ccd_decodeMsgPtr[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_codeMsg ptr_ccd_codeMsg[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_codeMsgPtr ptr_ccd_codeMsgPtr[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_init_ccddata ptr_ccd_init_ccddata[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_decodeByte ptr_ccd_decodeByte[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_codeByte ptr_ccd_codeByte[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_codeLong ptr_ccd_codeLong[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_decodeLong ptr_ccd_decodeLong[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_bitcopy ptr_ccd_bitcopy[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_getFirstError ptr_ccd_getFirstError[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_getNextError ptr_ccd_getNextError[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_getFirstFault ptr_ccd_getFirstFault[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_getNextFault ptr_ccd_getNextFault[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_free_faultlist ptr_ccd_free_faultlist[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_get_numFaults ptr_ccd_get_numFaults[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_encodeElem ptr_ccd_encodeElem[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static T_ccd_decodeElem ptr_ccd_decodeElem[MAXPROC]
+  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+#pragma data_seg()
+
+
+/*==== HANDLER FOR FUNCTIONS UNSUPPORTED BY LOADED DLL =======================*/
+int cddl_ccddata_get_pdi_dinfo (const T_PDI_DECODEINFO* (*dinfo) )
+{
+  dinfo=NULL;
+  return 0;
+}
+
+int cddl_ccddata_eg_nodes (void)
+{
+  return 0;
+}
+
+char** cddl_ccddata_eg_nodenames (void)
+{
+  return NULL;
+}
+
+char* cddl_ccddata_eg_adjacent (int idx)
+{
+  return NULL;
+}
+
+int cddl_ccddata_eg_saps (void)
+{
+  return 0;
+}
+
+char** cddl_ccddata_eg_sapnames (void)
+{
+  return NULL;
+}
+
+T_COMENDPOINTS* cddl_ccddata_eg_comendpoints (int idx)
+{
+  return NULL;
+}
+
+char* cddl_ccddata_get_version (void)
+{
+  return "OLD";
+}
+
+int cddl_ccddata_get_table_version (void)
+{
+  return 0;
+}
+
+const char * cddl_ccddata_get_entname (short ccdent)
+{
+  return NULL;
+}
+/*==== PRIVATE FUNCTIONS =====================================================*/
+/*
++------------------------------------------------------------------------------
+|  Function     :  ccddata_init_lock
++------------------------------------------------------------------------------
+|  Description  :  Synchronize calls of ccddata_init
+|
+|  Parameters   :  - 
+|
+|  Return       :  0 on success, otherwise error code
++------------------------------------------------------------------------------
+*/
+static HANDLE ccddata_init_lock (void)
+{
+  char* mname = "ccddata_init_lock";
+  HANDLE tmp;
+  if ((tmp = CreateMutex (NULL, FALSE, mname)) == 0)
+  {
+    return 0;
+  }
+  if ((initlock = OpenMutex (MUTEX_ALL_ACCESS, FALSE, mname)) == 0)
+  {
+    return 0;
+  }
+  CloseHandle (tmp);
+  WaitForSingleObject (initlock, INFINITE);
+  return initlock;
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  ccddata_register
++------------------------------------------------------------------------------
+|  Description  :  Register process in ccddata load dll
+|
+|  Parameters   :  -
+|
+|  Return       :  Index to ptrindex on success, otherwise -1
++------------------------------------------------------------------------------
+*/
+static int ccddata_register (void)
+{
+  if (me >= 0)
+  {
+    return me;
+  }
+  for (me=0; me<MAXPROC; me++)
+  {
+    if (!ptrindex[me])
+    {
+      char mname[32];
+      HANDLE tmp;
+      ptrindex[me] = GetCurrentProcessId ();
+      sprintf (mname, "ccddata_%d", ptrindex[me]);
+      tmp = CreateMutex (NULL, FALSE, mname);
+      mut[me] = OpenMutex (MUTEX_ALL_ACCESS, FALSE, mname);
+      CloseHandle (tmp);
+      return me;
+    }
+  }
+  me = -1;
+  return me;
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  ccddata_detach
++------------------------------------------------------------------------------
+|  Description  :  Unload ccddata dll and clean pointer to the functions
+|
+|  Parameters   :  i - index to pointer list
+|                  exit_all - if set, call ccd_exit and call FreeLibrary
+|
+|  Return       :  -
++------------------------------------------------------------------------------
+*/
+static void ccddata_detach (int i, int exit_all)
+{
+  char mname[32];
+  HANDLE mutex;
+
+  if (!cdll[i])
+    return;
+
+  if (ccddata_x_notify != NULL && exit_all)
+  {
+    // make sure all functions are available again
+    if (ptr_ccd_init[i] != NULL || ccddata_attach(i)==CCDDATA_DLL_OK)
+    {
+      (*ccddata_x_notify)();
+    }
+  }
+
+  if (ptr_ccd_init[i] != NULL)
+  {
+    // clean all function pointers except ccd_exit
+    if (!exit_all)
+    {
+      sprintf (mname, "ccddata_%d", ptrindex[i]);
+      mutex = OpenMutex (MUTEX_ALL_ACCESS, FALSE, mname);
+      WaitForSingleObject (mutex, INFINITE);
+    }
+
+    ptr_pcon_init_prim_coding[i] = NULL;
+    ptr_pcon_decodePrim[i] = NULL;
+    ptr_pcon_codePrim[i] = NULL;
+    ptr_pcon_init_ccddata[i] = NULL;
+    ptr_pcon_make_filter[i] = NULL;
+    ptr_pcon_filter_decode_prim[i] = NULL;
+    ptr_ccddata_get_pdi_dinfo[i] = NULL;
+    ptr_ccddata_get_num_of_entities[i] = NULL;
+    ptr_ccddata_get_max_message_id[i] = NULL;
+    ptr_ccddata_get_max_bitstream_len[i] = NULL;
+    ptr_ccddata_get_max_mstruct_len[i] = NULL;
+    ptr_ccddata_mccd_symbols[i] = NULL;
+    ptr_ccddata_get_max_sap_num[i] = NULL;
+    ptr_ccddata_get_max_primitive_id[i] = NULL;
+    ptr_ccddata_get_max_pstruct_len[i] = NULL;
+    ptr_ccddata_get_mvar[i] = NULL;
+    ptr_ccddata_get_spare[i] = NULL;
+    ptr_ccddata_get_calc[i] = NULL;
+    ptr_ccddata_get_mcomp[i] = NULL;
+    ptr_ccddata_get_melem[i] = NULL;
+    ptr_ccddata_get_calcidx[i] = NULL;
+    ptr_ccddata_get_mmtx[i] = NULL;
+    ptr_ccddata_get_pvar[i] = NULL;
+    ptr_ccddata_get_pcomp[i] = NULL;
+    ptr_ccddata_get_pelem[i] = NULL;
+    ptr_ccddata_get_pmtx[i] = NULL;
+    ptr_ccddata_get_mval[i] = NULL;
+    ptr_ccddata_get_mstr[i] = NULL;
+    ptr_ccddata_get_pval[i] = NULL;
+    ptr_ccddata_get_pstr[i] = NULL;
+    ptr_ccddata_get_ccdent[i] = NULL;
+    ptr_ccddata_get_entname[i] = NULL;
+    ptr_ccddata_get_alias[i] = NULL;
+    ptr_ccddata_get_version[i] = NULL;
+    ptr_ccddata_get_table_version[i] = NULL;
+    ptr_ccddata_get_mi_length[i] = NULL;
+    mi_length[i] = NULL;
+    ptr_ccddata_get_decmsgbuffer[i] = NULL;
+    decmsgbuffer[i] = NULL;
+    ptr_ccddata_tap_check_pd[i] = NULL;
+    ptr_ccddata_tap_get_pd[i] = NULL;
+    ptr_ccddata_eg_nodes[i] = NULL;
+    ptr_ccddata_eg_nodenames[i] = NULL;
+    ptr_ccddata_eg_adjacent[i] = NULL;
+    ptr_ccddata_eg_saps[i] = NULL;
+    ptr_ccddata_eg_sapnames[i] = NULL;
+    ptr_ccddata_eg_comendpoints[i] = NULL;
+
+    ptr_cde_init[i] = NULL;
+    ptr_cde_get_comp[i] = NULL;
+    ptr_cde_prim_first[i] = NULL;
+    ptr_cde_prim_next[i] = NULL;
+    ptr_cde_msg_first[i] = NULL;
+    ptr_cde_msg_next[i] = NULL;
+    ptr_cde_comp_first[i] = NULL;
+    ptr_cde_comp_next[i] = NULL;
+    ptr_cde_get_symval[i] = NULL;
+    ptr_cde_read_elem[i] = NULL;
+    ptr_cde_write_prepare[i] = NULL;
+    ptr_cde_write_elem[i] = NULL;
+    ptr_cde_get_type[i] = NULL;
+    ptr_cde_get_primcode[i] = NULL;
+    ptr_cde_get_msgcode[i] = NULL;
+    ptr_cde_get_is_downlink[i] = NULL;
+    ptr_cde_get_comp_index[i] = NULL;
+    ptr_cde_get_element_name[i] = NULL;
+    ptr_cde_get_array_kind[i] = NULL;
+
+    ptr_pdi_createDefContext[i] = NULL;
+    ptr_pdi_createContext[i] = NULL;
+    ptr_pdi_destroyContext[i] = NULL;
+    ptr_pdi_startPrim[i] = NULL;
+    ptr_pdi_getDecodeInfo[i] = NULL;
+    ptr_pdi_getEntityByPD[i] = NULL;
+    ptr_pdi_pd2name[i] = NULL;
+
+    ptr_ccd_set_patch_infos[i] = NULL;
+    ptr_ccd_begin[i] = NULL;
+    ptr_ccd_end[i] = NULL;
+    ptr_ccd_decodeMsg[i] = NULL;
+    ptr_ccd_decodeMsgPtr[i] = NULL;
+    ptr_ccd_codeMsg[i] = NULL;
+    ptr_ccd_codeMsgPtr[i] = NULL;
+    ptr_ccd_init_ccddata[i] = NULL;
+    ptr_ccd_decodeByte[i] = NULL;
+    ptr_ccd_codeByte[i] = NULL;
+    ptr_ccd_codeLong[i] = NULL;
+    ptr_ccd_decodeLong[i] = NULL;
+    ptr_ccd_bitcopy[i] = NULL;
+    ptr_ccd_getFirstError[i] = NULL;
+    ptr_ccd_getNextError[i] = NULL;
+    ptr_ccd_getFirstFault[i] = NULL;
+    ptr_ccd_getNextFault[i] = NULL;
+    ptr_ccd_free_faultlist[i] = NULL;
+    ptr_ccd_get_numFaults[i] = NULL;
+    ptr_ccd_encodeElem[i] = NULL;
+    ptr_ccd_decodeElem[i] = NULL;
+    ptr_ccd_init[i] = NULL;
+
+    if (!exit_all)
+    {
+      ReleaseMutex (mutex);
+      CloseHandle (mutex);
+    }
+  }
+
+  if (exit_all)
+  {
+    if (ptr_ccd_exit[i])
+    {
+      (void)(*ptr_ccd_exit[i])();
+      ptr_ccd_exit[i] = NULL;
+    }
+    (void) FreeLibrary (cdll[i]);
+    cdll[i] = 0;
+  }
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  ccddata_clean
++------------------------------------------------------------------------------
+|  Description  :  Free own instance of ccddata dll and clean the pointers
+|                  of the other processes.
+|
+|  Parameters   :  -
+|
+|  Return       :  CCDDATA_DLL_REGISTER, if the process is not registered
+|                  or has not yet called ccddata_exit; CCDDATA_DLL_OK otherwise
++------------------------------------------------------------------------------
+*/
+static int ccddata_clean (void)
+{
+  int i;
+
+  if (me < 0)
+  {
+    return CCDDATA_DLL_REGISTER;
+  }
+
+  for (i=0; i<MAXPROC; i++)
+  {
+    if (me != i)
+    {
+      ccddata_detach (i, 0);
+    }
+  }
+  
+  return CCDDATA_DLL_OK;
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  ccddata_attach
++------------------------------------------------------------------------------
+|  Description  :  Unload ccddata dll and clean pointer to the functions
+|
+|  Parameters   :  i - index to pointer list
+|
+|  Return       :  CCDDATA_DLL_OK or error code
++------------------------------------------------------------------------------
+*/
+static int ccddata_attach (int i)
+{
+  int already_loaded=(cdll[i]!=0);
+  if (!already_loaded)
+  {
+    cdll[i] = LoadLibrary (lastdll);
+    if (cdll[i] == NULL)
+    {
+      return CCDDATA_DLL_LOADLIB;
+    }
+  }
+
+  ptr_pcon_init_prim_coding[i] = (T_pcon_init_prim_coding)
+    GetProcAddress (cdll[i], "cddl_pcon_init_prim_coding");
+  ptr_pcon_decodePrim[i] = (T_pcon_decodePrim)
+    GetProcAddress (cdll[i], "cddl_pcon_decodePrim");
+  ptr_pcon_codePrim[i] = (T_pcon_codePrim)
+    GetProcAddress (cdll[i], "cddl_pcon_codePrim");
+  ptr_pcon_init_ccddata[i] = (T_pcon_init_ccddata)
+    GetProcAddress (cdll[i], "cddl_pcon_init_ccddata");
+  ptr_pcon_make_filter[i] = (T_pcon_make_filter)
+    GetProcAddress (cdll[i], "cddl_pcon_make_filter");
+  ptr_pcon_filter_decode_prim[i] = (T_pcon_filter_decode_prim)
+    GetProcAddress (cdll[i], "cddl_pcon_filter_decode_prim");
+
+  if (
+    ptr_pcon_init_prim_coding[i] == NULL ||
+    ptr_pcon_decodePrim[i] == NULL ||
+    ptr_pcon_codePrim[i] == NULL ||
+    ptr_pcon_init_ccddata[i] == NULL ||
+    ptr_pcon_make_filter[i] == NULL ||
+    ptr_pcon_filter_decode_prim[i] == NULL)
+  {
+    ptr_pcon_init_prim_coding[i] = cddl_pcon_init_prim_coding;
+    ptr_pcon_decodePrim[i] = cddl_pcon_decodePrim;
+    ptr_pcon_codePrim[i] = cddl_pcon_codePrim;
+    ptr_pcon_init_ccddata[i] = cddl_pcon_init_ccddata;
+    ptr_pcon_make_filter[i] = cddl_pcon_make_filter;
+    ptr_pcon_filter_decode_prim[i] = cddl_pcon_filter_decode_prim;
+  }
+
+  ptr_ccd_init[i] = (T_ccd_init)
+    GetProcAddress (cdll[i], "cddl_ccd_init");
+  ptr_ccd_exit[i] = (T_ccd_exit)
+    GetProcAddress (cdll[i], "cddl_ccd_exit");
+  ptr_ccd_begin[i] = (T_ccd_begin)
+    GetProcAddress (cdll[i], "cddl_ccd_begin");
+  ptr_ccd_end[i] = (T_ccd_end)
+    GetProcAddress (cdll[i], "cddl_ccd_end");
+  ptr_ccd_decodeMsg[i] = (T_ccd_decodeMsg)
+    GetProcAddress (cdll[i], "cddl_ccd_decodeMsg");
+  ptr_ccd_decodeMsgPtr[i] = (T_ccd_decodeMsgPtr)
+    GetProcAddress (cdll[i], "cddl_ccd_decodeMsgPtr");
+  ptr_ccd_codeMsg[i] = (T_ccd_codeMsg)
+    GetProcAddress (cdll[i], "cddl_ccd_codeMsg");
+  ptr_ccd_codeMsgPtr[i] = (T_ccd_codeMsgPtr)
+    GetProcAddress (cdll[i], "cddl_ccd_codeMsgPtr");
+  ptr_ccd_init_ccddata[i] = (T_ccd_init_ccddata)
+    GetProcAddress (cdll[i], "cddl_ccd_init_ccddata");
+  ptr_ccd_decodeByte[i] = (T_ccd_decodeByte)
+    GetProcAddress (cdll[i], "cddl_ccd_decodeByte");
+  ptr_ccd_codeByte[i] = (T_ccd_codeByte)
+    GetProcAddress (cdll[i], "cddl_ccd_codeByte");
+  ptr_ccd_codeLong[i] = (T_ccd_codeLong)
+    GetProcAddress (cdll[i], "cddl_ccd_codeLong");
+  ptr_ccd_decodeLong[i] = (T_ccd_decodeLong)
+    GetProcAddress (cdll[i], "cddl_ccd_decodeLong");
+  ptr_ccd_bitcopy[i] = (T_ccd_bitcopy)
+    GetProcAddress (cdll[i], "cddl_ccd_bitcopy");
+  ptr_ccd_getFirstError[i] = (T_ccd_getFirstError)
+    GetProcAddress (cdll[i], "cddl_ccd_getFirstError");
+  ptr_ccd_getNextError[i] = (T_ccd_getNextError)
+    GetProcAddress (cdll[i], "cddl_ccd_getNextError");
+  ptr_ccd_getFirstFault[i] = (T_ccd_getFirstFault)
+    GetProcAddress (cdll[i], "cddl_ccd_getFirstFault");
+  ptr_ccd_getNextFault[i] = (T_ccd_getNextFault)
+    GetProcAddress (cdll[i], "cddl_ccd_getNextFault");
+  ptr_ccd_free_faultlist[i] = (T_ccd_free_faultlist)
+    GetProcAddress (cdll[i], "cddl_ccd_free_faultlist");
+  ptr_ccd_get_numFaults[i] = (T_ccd_get_numFaults)
+    GetProcAddress (cdll[i], "cddl_ccd_get_numFaults");
+  ptr_ccd_encodeElem[i] = (T_ccd_encodeElem)
+    GetProcAddress (cdll[i], "cddl_ccd_encodeElem");
+  ptr_ccd_decodeElem[i] = (T_ccd_decodeElem)
+    GetProcAddress (cdll[i], "cddl_ccd_decodeElem");
+  if (
+    ptr_ccd_init[i] == NULL ||
+    ptr_ccd_exit[i] == NULL ||
+    ptr_ccd_begin[i] == NULL ||
+    ptr_ccd_end[i] == NULL ||
+    ptr_ccd_decodeMsg[i] == NULL ||
+    ptr_ccd_decodeMsgPtr[i] == NULL ||
+    ptr_ccd_codeMsg[i] == NULL ||
+    ptr_ccd_codeMsgPtr[i] == NULL ||
+    ptr_ccd_init_ccddata[i] == NULL ||
+    ptr_ccd_decodeByte[i] == NULL ||
+    ptr_ccd_codeByte[i] == NULL ||
+    ptr_ccd_codeLong[i] == NULL ||
+    ptr_ccd_decodeLong[i] == NULL ||
+    ptr_ccd_bitcopy[i] == NULL ||
+    ptr_ccd_getFirstError[i] == NULL ||
+    ptr_ccd_getNextError[i] == NULL ||
+    ptr_ccd_getFirstFault[i] == NULL ||
+    ptr_ccd_getNextFault[i] == NULL ||
+    ptr_ccd_free_faultlist[i] == NULL ||
+    ptr_ccd_get_numFaults[i] == NULL ||
+    ptr_ccd_encodeElem[i] == NULL ||
+    ptr_ccd_decodeElem[i] == NULL)
+  {
+    ptr_ccd_init[i] = cddl_ccd_init;
+    ptr_ccd_exit[i] = cddl_ccd_exit;
+    ptr_ccd_begin[i] = cddl_ccd_begin;
+    ptr_ccd_end[i] = cddl_ccd_end;
+    ptr_ccd_decodeMsg[i] = cddl_ccd_decodeMsg;
+    ptr_ccd_decodeMsgPtr[i] = cddl_ccd_decodeMsgPtr;
+    ptr_ccd_codeMsg[i] = cddl_ccd_codeMsg;
+    ptr_ccd_codeMsgPtr[i] = cddl_ccd_codeMsgPtr;
+    ptr_ccd_init_ccddata[i] = cddl_ccd_init_ccddata;
+    ptr_ccd_decodeByte[i] = cddl_ccd_decodeByte;
+    ptr_ccd_codeByte[i] = cddl_ccd_codeByte;
+    ptr_ccd_codeLong[i] = cddl_ccd_codeLong;
+    ptr_ccd_decodeLong[i] = cddl_ccd_decodeLong;
+    ptr_ccd_bitcopy[i] = cddl_ccd_bitcopy;
+    ptr_ccd_getFirstError[i] = cddl_ccd_getFirstError;
+    ptr_ccd_getNextError[i] = cddl_ccd_getNextError;
+    ptr_ccd_getFirstFault[i] = cddl_ccd_getFirstFault;
+    ptr_ccd_getNextFault[i] = cddl_ccd_getNextFault;
+    ptr_ccd_free_faultlist[i] = cddl_ccd_free_faultlist;
+    ptr_ccd_get_numFaults[i] = cddl_ccd_get_numFaults;
+    ptr_ccd_encodeElem[i] = cddl_ccd_encodeElem;
+    ptr_ccd_decodeElem[i] = cddl_ccd_decodeElem;
+  }
+  ptr_ccd_set_patch_infos[i] = (T_ccd_set_patch_infos)
+    GetProcAddress (cdll[i], "cddl_ccd_set_patch_infos");
+  if (ptr_ccd_set_patch_infos[i] == NULL)
+  {
+    ptr_ccd_set_patch_infos[i] = cddl_ccd_set_patch_infos;
+  }
+
+  ptr_ccddata_eg_nodes[i] = (T_ccddata_eg_nodes)
+    GetProcAddress (cdll[i], "ccddata_eg_nodes");
+  ptr_ccddata_eg_nodenames[i] = (T_ccddata_eg_nodenames)
+    GetProcAddress (cdll[i], "ccddata_eg_nodenames");
+  ptr_ccddata_eg_adjacent[i] = (T_ccddata_eg_adjacent)
+    GetProcAddress (cdll[i], "ccddata_eg_adjacent");
+  if (
+    ptr_ccddata_eg_nodes[i] == NULL ||
+    ptr_ccddata_eg_nodenames[i] == NULL ||
+    ptr_ccddata_eg_adjacent[i] == NULL)
+  {
+    ptr_ccddata_eg_nodes[i] = cddl_ccddata_eg_nodes;
+    ptr_ccddata_eg_nodenames[i] = cddl_ccddata_eg_nodenames;
+    ptr_ccddata_eg_adjacent[i] = cddl_ccddata_eg_adjacent;
+  }
+
+  ptr_ccddata_eg_saps[i] = (T_ccddata_eg_saps)
+    GetProcAddress (cdll[i], "ccddata_eg_saps");
+  ptr_ccddata_eg_sapnames[i] = (T_ccddata_eg_sapnames)
+    GetProcAddress (cdll[i], "ccddata_eg_sapnames");
+  ptr_ccddata_eg_comendpoints[i] = (T_ccddata_eg_comendpoints)
+    GetProcAddress (cdll[i], "ccddata_eg_comendpoints");
+  if (
+    ptr_ccddata_eg_saps[i] == NULL ||
+    ptr_ccddata_eg_sapnames[i] == NULL ||
+    ptr_ccddata_eg_comendpoints[i] == NULL)
+  {
+    ptr_ccddata_eg_saps[i] = cddl_ccddata_eg_saps;
+    ptr_ccddata_eg_sapnames[i] = cddl_ccddata_eg_sapnames;
+    ptr_ccddata_eg_comendpoints[i] = cddl_ccddata_eg_comendpoints;
+  }
+  
+  ptr_cde_init[i] = (T_cde_init)
+    GetProcAddress (cdll[i], "cddl_cde_init");
+  ptr_cde_get_comp[i] = (T_cde_get_comp)
+    GetProcAddress (cdll[i], "cddl_cde_get_comp");
+  ptr_cde_prim_first[i] = (T_cde_prim_first)
+    GetProcAddress (cdll[i], "cddl_cde_prim_first");
+  ptr_cde_prim_next[i] = (T_cde_prim_next)
+    GetProcAddress (cdll[i], "cddl_cde_prim_next");
+  ptr_cde_msg_first[i] = (T_cde_msg_first)
+    GetProcAddress (cdll[i], "cddl_cde_msg_first");
+  ptr_cde_msg_next[i] = (T_cde_msg_next)
+    GetProcAddress (cdll[i], "cddl_cde_msg_next");
+  ptr_cde_comp_first[i] = (T_cde_comp_first)
+    GetProcAddress (cdll[i], "cddl_cde_comp_first");
+  ptr_cde_comp_next[i] = (T_cde_comp_next)
+    GetProcAddress (cdll[i], "cddl_cde_comp_next");
+  ptr_cde_get_symval[i] = (T_cde_get_symval)
+    GetProcAddress (cdll[i], "cddl_cde_get_symval");
+  ptr_cde_read_elem[i] = (T_cde_read_elem)
+    GetProcAddress (cdll[i], "cddl_cde_read_elem");
+  ptr_cde_write_prepare[i] = (T_cde_write_prepare)
+    GetProcAddress (cdll[i], "cddl_cde_write_prepare");
+  ptr_cde_write_elem[i] = (T_cde_write_elem)
+    GetProcAddress (cdll[i], "cddl_cde_write_elem");
+  ptr_cde_get_type[i] = (T_cde_get_type)
+    GetProcAddress (cdll[i], "cddl_cde_get_type");
+  ptr_cde_get_primcode[i] = (T_cde_get_primcode)
+    GetProcAddress (cdll[i], "cddl_cde_get_primcode");
+  ptr_cde_get_msgcode[i] = (T_cde_get_msgcode)
+    GetProcAddress (cdll[i], "cddl_cde_get_msgcode");
+  ptr_cde_get_is_downlink[i] = (T_cde_get_is_downlink)
+    GetProcAddress (cdll[i], "cddl_cde_get_is_downlink");
+  ptr_cde_get_comp_index[i] = (T_cde_get_comp_index)
+    GetProcAddress (cdll[i], "cddl_cde_get_comp_index");
+  ptr_cde_get_element_name[i] = (T_cde_get_element_name)
+    GetProcAddress (cdll[i], "cddl_cde_get_element_name");
+  ptr_cde_get_array_kind[i] = (T_cde_get_array_kind)
+    GetProcAddress (cdll[i], "cddl_cde_get_array_kind");
+  if (
+    ptr_cde_init[i] == NULL ||
+    ptr_cde_get_comp[i] == NULL ||
+    ptr_cde_prim_first[i] == NULL ||
+    ptr_cde_prim_next[i] == NULL ||
+    ptr_cde_msg_first[i] == NULL ||
+    ptr_cde_msg_next[i] == NULL ||
+    ptr_cde_comp_first[i] == NULL ||
+    ptr_cde_comp_next[i] == NULL ||
+    ptr_cde_get_symval[i] == NULL ||
+    ptr_cde_read_elem[i] == NULL ||
+    ptr_cde_write_prepare[i] == NULL ||
+    ptr_cde_write_elem[i] == NULL ||
+    ptr_cde_get_type[i] == NULL ||
+    ptr_cde_get_primcode[i] == NULL ||
+    ptr_cde_get_msgcode[i] == NULL ||
+    ptr_cde_get_is_downlink[i] == NULL ||
+    ptr_cde_get_comp_index[i] == NULL ||
+    ptr_cde_get_element_name[i] == NULL ||
+    ptr_cde_get_array_kind[i] == NULL)
+  {
+    ptr_cde_init[i] = cddl_cde_init;
+    ptr_cde_get_comp[i] = cddl_cde_get_comp;
+    ptr_cde_prim_first[i] = cddl_cde_prim_first;
+    ptr_cde_prim_next[i] = cddl_cde_prim_next;
+    ptr_cde_msg_first[i] = cddl_cde_msg_first;
+    ptr_cde_msg_next[i] = cddl_cde_msg_next;
+    ptr_cde_comp_first[i] = cddl_cde_comp_first;
+    ptr_cde_comp_next[i] = cddl_cde_comp_next;
+    ptr_cde_get_symval[i] = cddl_cde_get_symval;
+    ptr_cde_read_elem[i] = cddl_cde_read_elem;
+    ptr_cde_write_prepare[i] = cddl_cde_write_prepare;
+    ptr_cde_write_elem[i] = cddl_cde_write_elem;
+    ptr_cde_get_type[i] = cddl_cde_get_type;
+    ptr_cde_get_primcode[i] = cddl_cde_get_primcode;
+    ptr_cde_get_msgcode[i] = cddl_cde_get_msgcode;
+    ptr_cde_get_is_downlink[i] = cddl_cde_get_is_downlink;
+    ptr_cde_get_comp_index[i] = cddl_cde_get_comp_index;
+    ptr_cde_get_element_name[i] = cddl_cde_get_element_name;
+    ptr_cde_get_array_kind[i] = cddl_cde_get_array_kind;
+  }
+
+  ptr_pdi_createDefContext[i] = (T_pdi_createDefContext)
+    GetProcAddress (cdll[i], "cddl_pdi_createDefContext");
+  ptr_pdi_createContext[i] = (T_pdi_createContext)
+    GetProcAddress (cdll[i], "cddl_pdi_createContext");
+  ptr_pdi_destroyContext[i] = (T_pdi_destroyContext)
+    GetProcAddress (cdll[i], "cddl_pdi_destroyContext");
+  ptr_pdi_startPrim[i] = (T_pdi_startPrim)
+    GetProcAddress (cdll[i], "cddl_pdi_startPrim");
+  ptr_pdi_getDecodeInfo[i] = (T_pdi_getDecodeInfo)
+    GetProcAddress (cdll[i], "cddl_pdi_getDecodeInfo");
+  ptr_pdi_getEntityByPD[i] = (T_pdi_getEntityByPD)
+    GetProcAddress (cdll[i], "cddl_pdi_getEntityByPD");
+  ptr_pdi_pd2name[i] = (T_pdi_pd2name)
+    GetProcAddress (cdll[i], "cddl_pdi_pd2name");
+  if (
+    ptr_pdi_createDefContext[i] == NULL ||
+    ptr_pdi_createContext[i] == NULL ||
+    ptr_pdi_destroyContext[i] == NULL ||
+    ptr_pdi_startPrim[i] == NULL ||
+    ptr_pdi_getDecodeInfo[i] == NULL ||
+    ptr_pdi_getEntityByPD[i] == NULL ||
+    ptr_pdi_pd2name[i] == NULL)
+  {
+    ptr_pdi_createDefContext[i]=cddl_pdi_createDefContext;
+    ptr_pdi_createContext[i] =cddl_pdi_createContext;
+    ptr_pdi_destroyContext[i] = cddl_pdi_destroyContext;
+    ptr_pdi_startPrim[i] = cddl_pdi_startPrim;
+    ptr_pdi_getDecodeInfo[i] = cddl_pdi_getDecodeInfo;
+    ptr_pdi_getEntityByPD[i] = cddl_pdi_getEntityByPD;
+    ptr_pdi_pd2name[i] = cddl_pdi_pd2name;
+  }
+
+  ptr_ccddata_get_pdi_dinfo[i] = (T_ccddata_get_pdi_dinfo)
+    GetProcAddress (cdll[i], "ccddata_get_pdi_dinfo");
+  if (ptr_ccddata_get_pdi_dinfo[i] == NULL)
+  {
+    ptr_ccddata_get_pdi_dinfo[i] = cddl_ccddata_get_pdi_dinfo;
+  }
+  ptr_ccddata_get_num_of_entities[i] = (T_ccddata_get_num_of_entities)
+    GetProcAddress (cdll[i], "ccddata_get_num_of_entities");
+  ptr_ccddata_get_max_message_id[i] = (T_ccddata_get_max_message_id)
+    GetProcAddress (cdll[i], "ccddata_get_max_message_id");
+  ptr_ccddata_get_max_bitstream_len[i] = (T_ccddata_get_max_bitstream_len)
+    GetProcAddress (cdll[i], "ccddata_get_max_bitstream_len");
+  ptr_ccddata_get_max_mstruct_len[i] = (T_ccddata_get_max_mstruct_len)
+    GetProcAddress (cdll[i], "ccddata_get_max_mstruct_len");
+  ptr_ccddata_mccd_symbols[i] = (T_ccddata_mccd_symbols)
+    GetProcAddress (cdll[i], "ccddata_mccd_symbols");
+  ptr_ccddata_get_max_sap_num[i] = (T_ccddata_get_max_sap_num)
+    GetProcAddress (cdll[i], "ccddata_get_max_sap_num");
+  ptr_ccddata_get_max_primitive_id[i] = (T_ccddata_get_max_primitive_id)
+    GetProcAddress (cdll[i], "ccddata_get_max_primitive_id");
+  ptr_ccddata_get_max_pstruct_len[i] = (T_ccddata_get_max_pstruct_len)
+    GetProcAddress (cdll[i], "ccddata_get_max_pstruct_len");
+  ptr_ccddata_get_mvar[i] = (T_ccddata_get_mvar)
+    GetProcAddress (cdll[i], "ccddata_get_mvar");
+  ptr_ccddata_get_spare[i] = (T_ccddata_get_spare)
+    GetProcAddress (cdll[i], "ccddata_get_spare");
+  ptr_ccddata_get_calc[i] = (T_ccddata_get_calc)
+    GetProcAddress (cdll[i], "ccddata_get_calc");
+  ptr_ccddata_get_mcomp[i] = (T_ccddata_get_mcomp)
+    GetProcAddress (cdll[i], "ccddata_get_mcomp");
+  ptr_ccddata_get_melem[i] = (T_ccddata_get_melem)
+    GetProcAddress (cdll[i], "ccddata_get_melem");
+  ptr_ccddata_get_calcidx[i] = (T_ccddata_get_calcidx)
+    GetProcAddress (cdll[i], "ccddata_get_calcidx");
+  ptr_ccddata_get_mmtx[i] = (T_ccddata_get_mmtx)
+    GetProcAddress (cdll[i], "ccddata_get_mmtx");
+  ptr_ccddata_get_pvar[i] = (T_ccddata_get_pvar)
+    GetProcAddress (cdll[i], "ccddata_get_pvar");
+  ptr_ccddata_get_pcomp[i] = (T_ccddata_get_pcomp)
+    GetProcAddress (cdll[i], "ccddata_get_pcomp");
+  ptr_ccddata_get_pelem[i] = (T_ccddata_get_pelem)
+    GetProcAddress (cdll[i], "ccddata_get_pelem");
+  ptr_ccddata_get_pmtx[i] = (T_ccddata_get_pmtx)
+    GetProcAddress (cdll[i], "ccddata_get_pmtx");
+  ptr_ccddata_get_mval[i] = (T_ccddata_get_mval)
+    GetProcAddress (cdll[i], "ccddata_get_mval");
+  ptr_ccddata_get_mstr[i] = (T_ccddata_get_mstr)
+    GetProcAddress (cdll[i], "ccddata_get_mstr");
+  ptr_ccddata_get_pval[i] = (T_ccddata_get_pval)
+    GetProcAddress (cdll[i], "ccddata_get_pval");
+  ptr_ccddata_get_pstr[i] = (T_ccddata_get_pstr)
+    GetProcAddress (cdll[i], "ccddata_get_pstr");
+  ptr_ccddata_get_ccdent[i] = (T_ccddata_get_ccdent)
+    GetProcAddress (cdll[i], "ccddata_get_ccdent");
+  ptr_ccddata_get_entname[i] = (T_ccddata_get_entname)
+    GetProcAddress (cdll[i], "ccddata_get_entname");
+  if (ptr_ccddata_get_entname[i] == NULL)
+  {
+    ptr_ccddata_get_entname[i] = cddl_ccddata_get_entname;
+  }
+  ptr_ccddata_get_alias[i] = (T_ccddata_get_alias)
+    GetProcAddress (cdll[i], "ccddata_get_alias");
+  ptr_ccddata_get_version[i] = (T_ccddata_get_version)
+    GetProcAddress (cdll[i], "ccddata_get_version");
+  if (ptr_ccddata_get_version[i] == NULL)
+  {
+    ptr_ccddata_get_version[i] = cddl_ccddata_get_version;
+  }
+  ptr_ccddata_get_table_version[i] = (T_ccddata_get_table_version)
+    GetProcAddress (cdll[i], "ccddata_get_table_version");
+  if (ptr_ccddata_get_table_version[i] == NULL)
+  {
+    ptr_ccddata_get_table_version[i] = cddl_ccddata_get_table_version;
+  }
+  ptr_ccddata_get_mi_length[i] = (T_ccddata_get_mi_length)
+    GetProcAddress (cdll[i], "ccddata_get_mi_length");
+  if (ptr_ccddata_get_mi_length[i] == NULL)
+  {
+    mi_length[i] = (UBYTE*) GetProcAddress (cdll[i], "mi_length");
+  }
+  ptr_ccddata_get_decmsgbuffer[i] = (T_ccddata_get_decmsgbuffer)
+    GetProcAddress (cdll[i], "ccddata_get_decmsgbuffer");
+  if (ptr_ccddata_get_decmsgbuffer[i] == NULL)
+  {
+    decmsgbuffer[i] = (UBYTE*) GetProcAddress (cdll[i], "decMsgBuffer");
+  }
+  ptr_ccddata_tap_check_pd[i] = (T_ccddata_tap_check_pd)
+    GetProcAddress (cdll[i], "ccddata_tap_check_pd");
+  ptr_ccddata_tap_get_pd[i] = (T_ccddata_tap_get_pd)
+    GetProcAddress (cdll[i], "ccddata_tap_get_pd");
+  if (
+    ptr_ccddata_get_pdi_dinfo[i] == NULL ||
+    ptr_ccddata_get_num_of_entities[i] == NULL ||
+    ptr_ccddata_get_max_message_id[i] == NULL ||
+    ptr_ccddata_get_max_bitstream_len[i] == NULL ||
+    ptr_ccddata_get_max_mstruct_len[i] == NULL ||
+    ptr_ccddata_mccd_symbols[i] == NULL ||
+    ptr_ccddata_get_max_sap_num[i] == NULL ||
+    ptr_ccddata_get_max_primitive_id[i] == NULL ||
+    ptr_ccddata_get_max_pstruct_len[i] == NULL ||
+    ptr_ccddata_get_mvar[i] == NULL ||
+    ptr_ccddata_get_spare[i] == NULL ||
+    ptr_ccddata_get_calc[i] == NULL ||
+    ptr_ccddata_get_mcomp[i] == NULL ||
+    ptr_ccddata_get_melem[i] == NULL ||
+    ptr_ccddata_get_calcidx[i] == NULL ||
+    ptr_ccddata_get_mmtx[i] == NULL ||
+    ptr_ccddata_get_pvar[i] == NULL ||
+    ptr_ccddata_get_pcomp[i] == NULL ||
+    ptr_ccddata_get_pelem[i] == NULL ||
+    ptr_ccddata_get_pmtx[i] == NULL ||
+    ptr_ccddata_get_mval[i] == NULL ||
+    ptr_ccddata_get_mstr[i] == NULL ||
+    ptr_ccddata_get_pval[i] == NULL ||
+    ptr_ccddata_get_pstr[i] == NULL ||
+    ptr_ccddata_get_ccdent[i] == NULL ||
+    ptr_ccddata_get_entname[i] == NULL ||
+    ptr_ccddata_get_alias[i] == NULL ||
+    ptr_ccddata_get_version[i] == NULL ||
+    ptr_ccddata_get_table_version[i] == NULL ||
+    ((ptr_ccddata_get_mi_length[i] == NULL) && (mi_length[i] == NULL)) ||
+    ((ptr_ccddata_get_decmsgbuffer[i] == NULL) &&
+      (decmsgbuffer[i] == NULL)) ||
+    ptr_ccddata_tap_check_pd[i] == NULL ||
+    ptr_ccddata_tap_get_pd[i] == NULL)
+  {
+    (void) ccddata_exit ();
+    return CCDDATA_DLL_LOADFUN;
+  }
+
+  (void) (*ptr_ccd_init_ccddata[i]) ();
+  (void) (*ptr_ccd_init[i]) ();
+  (void) (*ptr_cde_init[i]) ();
+  (void) (*ptr_pcon_init_ccddata[i]) ();
+  (void) (*ptr_pcon_init_prim_coding[i]) (0, PCON_LITTLE);
+
+  if (!already_loaded && ccddata_i_notify != NULL)
+  {
+    (*ccddata_i_notify)();
+  }
+
+  return CCDDATA_DLL_OK;
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  ccddata_ehandler
++------------------------------------------------------------------------------
+|  Description  :  Handle NULL pointer; if we had loaded a ccddata dll
+|                  but any other process had loaded another one in the
+|                  meantime, the old one is unloaded and the new one is
+<                  attached to.
+|
+|  Parameters   :  -
+|
+|  Return       :  An error code or the return value of ccddata_attach
++------------------------------------------------------------------------------
+*/
+static int ccddata_ehandler (void)
+{
+  if (me < 0)
+  {
+    return CCDDATA_DLL_REGISTER;
+  }
+
+  // functions not loaded -> reattach
+  ccddata_detach (me, 1);
+  return ccddata_attach (me);
+}
+/*==== PUBLIC FUNCTIONS ======================================================*/
+
+/* pcon_init_prim_coding ==================================================== */
+ULONG pcon_init_prim_coding (T_HANDLE caller, UBYTE format)
+{
+  ULONG ret = PCON_DLLFUNC_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_pcon_init_prim_coding[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_pcon_init_prim_coding[me]) (caller, format);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* pcon_decodePrim ========================================================== */
+ULONG pcon_decodePrim (ULONG opc,
+                       void ** decoded_prim,
+                       void * coded_prim,
+                       ULONG * length,
+                       ULONG woff)
+{
+  ULONG ret = PCON_DLLFUNC_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_pcon_decodePrim[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_pcon_decodePrim[me])(opc, decoded_prim, coded_prim, length,
+                                         woff);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* pcon_codePrim  ============================================================*/
+ULONG pcon_codePrim (ULONG opc,
+                     void * decoded_prim,
+                     void ** coded_prim,
+                     ULONG * length,
+                     ULONG woff,
+                     char* receiver)
+{
+  ULONG ret = PCON_DLLFUNC_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_pcon_codePrim[me] != NULL) || (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_pcon_codePrim[me])(opc, decoded_prim, coded_prim, length,
+                                     woff, receiver);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* pcon_init_ccddata  ========================================================*/
+ULONG pcon_init_ccddata (void)
+{
+  ULONG ret = PCON_DLLFUNC_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_pcon_init_ccddata[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_pcon_init_ccddata[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* pcon_make_filter  =========================================================*/
+ULONG pcon_make_filter (char* string, void** prim)
+{
+  ULONG ret = PCON_DLLFUNC_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_pcon_make_filter[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_pcon_make_filter[me])(string, prim);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* pcon_filter_decode_prim ===================================================*/
+ULONG pcon_filter_decode_prim (ULONG opc,
+                               void** decoded_prim,
+                               void* coded_prim,
+                               ULONG* length,
+                               ULONG woff,
+                               void** shadow_prim)
+{
+  ULONG ret = PCON_DLLFUNC_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_pcon_filter_decode_prim[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_pcon_filter_decode_prim[me])(opc, decoded_prim, coded_prim,
+                                               length, woff, shadow_prim);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* pcon_codePrim  ============================================================*/
+/* ccddata_get_num_of_entities  ==============================================*/
+int ccddata_get_num_of_entities (void)
+{
+  int ret = 0;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_num_of_entities[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_num_of_entities[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_pdi_dinfo  ==============================================*/
+int ccddata_get_pdi_dinfo (const T_PDI_DECODEINFO* (*dinfo) )
+{
+  int ret = 0;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_pdi_dinfo[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_pdi_dinfo[me])(dinfo);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_max_message_id  ===============================================*/
+int ccddata_get_max_message_id (void)
+{
+  int ret = 0;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_max_message_id[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_max_message_id[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_max_bitstream_len  ============================================*/
+int ccddata_get_max_bitstream_len (void)
+{
+  int ret = CCDDATA_MCONST_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_max_bitstream_len[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_max_bitstream_len[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_max_mstruct_len  ==============================================*/
+int ccddata_get_max_mstruct_len (void)
+{
+  int ret = CCDDATA_MCONST_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_max_mstruct_len[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_max_mstruct_len[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_mccd_symbols  =====================================================*/
+int ccddata_mccd_symbols (void)
+{
+  int ret = CCDDATA_MCONST_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_mccd_symbols[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_mccd_symbols[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_max_sap_num  ==================================================*/
+int ccddata_get_max_sap_num (void)
+{
+  int ret = 0;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_max_sap_num[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_max_sap_num[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_max_primitive_id  =============================================*/
+int ccddata_get_max_primitive_id (void)
+{
+  int ret = 0;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_max_primitive_id[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_max_primitive_id[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_max_pstruct_len  ==============================================*/
+int ccddata_get_max_pstruct_len (void)
+{
+  int ret = CCDDATA_PCONST_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_max_pstruct_len[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_max_pstruct_len[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_calcidx  ======================================================*/
+const T_CCD_CalcIndex* ccddata_get_calcidx (USHORT idx)
+{
+  const T_CCD_CalcIndex* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_calcidx[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_calcidx[me])(idx);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_mvar  =========================================================*/
+const T_CCD_VarTabEntry* ccddata_get_mvar (USHORT idx)
+{
+  const T_CCD_VarTabEntry* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_mvar[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_mvar[me])(idx);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_spare  ========================================================*/
+const T_CCD_SpareTabEntry* ccddata_get_spare (USHORT idx)
+{
+  const T_CCD_SpareTabEntry* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_spare[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_spare[me])(idx);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_calc  =========================================================*/
+const T_CCD_CalcTabEntry* ccddata_get_calc (USHORT idx)
+{
+  const T_CCD_CalcTabEntry* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_calc[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_calc[me])(idx);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_mcomp  ========================================================*/
+const T_CCD_CompTabEntry* ccddata_get_mcomp (USHORT idx)
+{
+  const T_CCD_CompTabEntry* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_mcomp[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_mcomp[me])(idx);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_melem  ========================================================*/
+const T_CCD_ElemTabEntry* ccddata_get_melem (USHORT idx)
+{
+  const T_CCD_ElemTabEntry* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_melem[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_melem[me])(idx);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_mmtx  =========================================================*/
+USHORT ccddata_get_mmtx (USHORT entity, USHORT msgid, USHORT index)
+{
+  USHORT ret = NO_REF;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_mmtx[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_mmtx[me])(entity, msgid, index);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_pvar  =========================================================*/
+const T_CCD_VarTabEntry* ccddata_get_pvar (USHORT idx)
+{
+  const T_CCD_VarTabEntry* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_pvar[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_pvar[me])(idx);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_pcomp  ========================================================*/
+const T_CCD_CompTabEntry* ccddata_get_pcomp (USHORT idx)
+{
+  const T_CCD_CompTabEntry* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_pcomp[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_pcomp[me])(idx);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_pelem  ========================================================*/
+const T_CCD_ElemTabEntry* ccddata_get_pelem (USHORT idx)
+{
+  const T_CCD_ElemTabEntry* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_pelem[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_pelem[me])(idx);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_pmtx  =========================================================*/
+USHORT ccddata_get_pmtx (USHORT sap, USHORT primid, USHORT index)
+{
+  USHORT ret = NO_REF;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_pmtx[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_pmtx[me])(sap, primid, index);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_mval  =========================================================*/
+const T_CCD_ValTabEntry* ccddata_get_mval (USHORT idx)
+{
+  const T_CCD_ValTabEntry* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_mval[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_mval[me])(idx);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_mstr  =========================================================*/
+const T_CCD_StrTabEntry* ccddata_get_mstr (USHORT idx)
+{
+  const T_CCD_StrTabEntry* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_mstr[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_mstr[me])(idx);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_pval  =========================================================*/
+const T_CCD_ValTabEntry* ccddata_get_pval (USHORT idx)
+{
+  const T_CCD_ValTabEntry* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_pval[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_pval[me])(idx);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_pstr  =========================================================*/
+const T_CCD_StrTabEntry* ccddata_get_pstr (USHORT idx)
+{
+  const T_CCD_StrTabEntry* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_pstr[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_pstr[me])(idx);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_ccdent  =======================================================*/
+short ccddata_get_ccdent (char* entname)
+{
+  short ret = CCDDATA_CCDENT_INVALID;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_ccdent[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_ccdent[me])(entname);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_entname  =======================================================*/
+const char * ccddata_get_entname (short ccdent)
+{
+  const char * ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_entname[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_entname[me])(ccdent);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_alias  ========================================================*/
+char* ccddata_get_alias (USHORT idx, int from_msg)
+{
+  char* ret = "";
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_alias[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_alias[me])(idx, from_msg);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_version  ======================================================*/
+char* ccddata_get_version (void)
+{
+  char* ret = "";
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_version[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_version[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_table_version  ================================================*/
+int ccddata_get_table_version (void)
+{
+  int ret = 0;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_get_table_version[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_table_version[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_decmsgbuffer  =================================================*/
+UBYTE* ccddata_get_decmsgbuffer (void)
+{
+  UBYTE* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if (ptr_ccddata_get_decmsgbuffer[me] == NULL)
+  {
+    if (decmsgbuffer[me] != NULL)
+    {
+      ret = decmsgbuffer[me];
+    }
+    else if (ccddata_ehandler() == CCDDATA_DLL_OK)
+    {
+      ret = ccddata_get_decmsgbuffer ();
+    }
+    else
+    {
+      ;
+    }
+  }
+  else
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_decmsgbuffer[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_get_mi_length  ====================================================*/
+UBYTE* ccddata_get_mi_length (void)
+{
+  UBYTE* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if (ptr_ccddata_get_mi_length[me] == NULL)
+  {
+    if (mi_length[me] != NULL)
+    {
+      ret = mi_length[me];
+    }
+    else if (ccddata_ehandler() == CCDDATA_DLL_OK)
+    {
+      ret = ccddata_get_mi_length ();
+    }
+    else
+    {
+      ;
+    }
+  }
+  else
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_get_mi_length[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_tap_get_pd  =======================================================*/
+int ccddata_tap_get_pd (UCHAR comp)
+{
+  int ret = TAP_PD_INVALID;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_tap_get_pd[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_tap_get_pd[me])(comp);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_tap_check_pd  =====================================================*/
+int ccddata_tap_check_pd (UCHAR comp, UCHAR pd)
+{
+  int ret = TAP_PD_INVALID;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_tap_check_pd[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_tap_check_pd[me])(comp, pd);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_eg_nodes  =========================================================*/
+int ccddata_eg_nodes (void)
+{
+  int ret = 0;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_eg_nodes[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_eg_nodes[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_eg_nodenames  =====================================================*/
+char** ccddata_eg_nodenames (void)
+{
+  char** ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_eg_nodenames[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_eg_nodenames[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_eg_adjacent  ======================================================*/
+char* ccddata_eg_adjacent (int idx)
+{
+  char* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_eg_adjacent[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_eg_adjacent[me])(idx);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_eg_saps  ==========================================================*/
+int ccddata_eg_saps (void)
+{
+  int ret = 0;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_eg_saps[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_eg_saps[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_eg_sapnames  ======================================================*/
+char** ccddata_eg_sapnames (void)
+{
+  char** ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_eg_sapnames[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_eg_sapnames[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccddata_eg_comendpoints  ==================================================*/
+T_COMENDPOINTS* ccddata_eg_comendpoints (int idx)
+{
+  T_COMENDPOINTS* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccddata_eg_comendpoints[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccddata_eg_comendpoints[me])(idx);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* cde_init  =================================================================*/
+void cde_init (void)
+{
+  if (me < 0)
+  {
+    return;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_cde_init[me] != NULL) || (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      (*ptr_cde_init[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+}
+
+/* cde_get_comp  =============================================================*/
+USHORT cde_get_comp (T_CCDE_HANDLE*     chandle,
+                     T_CCDE_ELEM_DESCR* edescr)
+{
+  USHORT ret = CCDEDIT_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_cde_get_comp[me] != NULL) || (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_cde_get_comp[me])(chandle, edescr);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* cde_prim_first  ===========================================================*/
+USHORT cde_prim_first (T_CCDE_HANDLE    * phandle,
+                       ULONG              primcode,
+                       char             * name)
+{
+  USHORT ret = CCDEDIT_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_cde_prim_first[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_cde_prim_first[me])(phandle, primcode, name);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* cde_prim_next  ============================================================*/
+USHORT cde_prim_next (T_CCDE_HANDLE      *phandle,
+                      UBYTE               descent,
+                      T_CCDE_ELEM_DESCR  *pdescr)
+{
+  USHORT ret = CCDEDIT_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_cde_prim_next[me] != NULL) || (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_cde_prim_next[me])(phandle, descent, pdescr);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* cde_msg_first  ============================================================*/
+USHORT cde_msg_first (T_CCDE_HANDLE  * mhandle,
+                      UBYTE            type,
+                      UBYTE            direction,
+                      UBYTE            entity,
+                      char           * name)
+
+{
+  USHORT ret = CCDEDIT_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_cde_msg_first[me] != NULL) || (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_cde_msg_first[me])(mhandle, type, direction, entity, name);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* cde_msg_next  =============================================================*/
+USHORT cde_msg_next (T_CCDE_HANDLE     *mhandle,
+                     UBYTE              descent,
+                     T_CCDE_ELEM_DESCR *iedescr)
+{
+  USHORT ret = CCDEDIT_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_cde_msg_next[me] != NULL) || (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_cde_msg_next[me])(mhandle, descent, iedescr);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* cde_comp_first  ===========================================================*/
+USHORT cde_comp_first (T_CCDE_HANDLE      * chandle,
+                       T_ELM_SRC            source,
+                       char               * compname)
+
+{
+  USHORT ret = CCDEDIT_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_cde_comp_first[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_cde_comp_first[me])(chandle, source, compname);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* cde_comp_next  ============================================================*/
+USHORT cde_comp_next (T_CCDE_HANDLE     *chandle,
+                      UBYTE              descent,
+                      T_CCDE_ELEM_DESCR *descr)
+{
+  USHORT ret = CCDEDIT_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_cde_comp_next[me] != NULL) || (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_cde_comp_next[me])(chandle, descent, descr);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* cde_get_symval  ===========================================================*/
+char* cde_get_symval (int elem_value, T_CCDE_ELEM_DESCR* edescr)
+{
+  char* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_cde_get_symval[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_cde_get_symval[me])(elem_value, edescr);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* cde_read_elem  ============================================================*/
+USHORT cde_read_elem (T_CCDE_HANDLE     * handle,
+                      void              * cstruct,
+                      T_CCDE_ELEM_DESCR * edescr,
+                      UBYTE             * value)
+{
+  USHORT ret = CCDEDIT_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_cde_read_elem[me] != NULL) || (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_cde_read_elem[me])(handle, cstruct, edescr, value);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* cde_write_prepare  ========================================================*/
+void cde_write_prepare (T_CCDE_HANDLE     * handle,
+                        void              * cstruct,
+                        T_CCDE_ELEM_DESCR * edescr)
+{
+  if (me < 0)
+  {
+    return;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_cde_write_prepare[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    (*ptr_cde_write_prepare[me])(handle, cstruct, edescr);
+  }
+  ReleaseMutex (mut[me]);
+}
+
+/* cde_write_elem  ===========================================================*/
+USHORT cde_write_elem (T_CCDE_HANDLE     * handle,
+                       void              * cstruct,
+                       T_CCDE_ELEM_DESCR * edescr,
+                       UBYTE             * value)
+{
+  USHORT ret = CCDEDIT_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_cde_write_elem[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_cde_write_elem[me])(handle, cstruct, edescr, value);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* cde_get_type  ===========================================================*/
+USHORT cde_get_type (char      *name,
+                     T_ELM_SRC *type)
+{
+  USHORT ret = CCDEDIT_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_cde_get_type[me] != NULL) || (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_cde_get_type[me])(name, type);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* cde_get_primcode  =========================================================*/
+USHORT cde_get_primcode (char      *name,
+                         ULONG     *primcode)
+{
+  USHORT ret = CCDEDIT_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_cde_get_primcode[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_cde_get_primcode[me])(name, primcode);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* cde_get_msgcode  ==========================================================*/
+USHORT cde_get_msgcode (char      *name,
+                        UBYTE     *type,
+                        UBYTE     *direction,
+                        UBYTE     *entity)
+{
+  USHORT ret = CCDEDIT_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_cde_get_msgcode[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_cde_get_msgcode[me])(name, type, direction, entity);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* cde_get_is_downlink  ======================================================*/
+int cde_get_is_downlink (ULONG comp_index)
+{
+  int ret = CCDEDIT_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_cde_get_is_downlink[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_cde_get_is_downlink[me])(comp_index);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* cde_get_comp_index  =======================================================*/
+ULONG cde_get_comp_index (char* comp_name, T_ELM_SRC table)
+{
+  ULONG ret = CCDEDIT_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_cde_get_comp_index[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_cde_get_comp_index[me])(comp_name, table);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* cde_get_element_name  =====================================================*/
+char* cde_get_element_name (ULONG comp_index, USHORT elem_off, T_ELM_SRC table)
+{
+  char* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_cde_get_element_name[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_cde_get_element_name[me])(comp_index, elem_off, table);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* cde_get_array_kind  =======================================================*/
+ULONG cde_get_array_kind (char* var_name, T_ELM_SRC table)
+{
+  ULONG ret = (ULONG)CCDEDIT_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_cde_get_array_kind[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_cde_get_array_kind[me])(var_name, table);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccd_set_patch_infos  ======================================================*/
+int ccd_set_patch_infos (T_patch_info* pinfo)
+{
+  int ret = CCD_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_set_patch_infos[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccd_set_patch_infos[me])(pinfo);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccd_init  =================================================================*/
+BYTE ccd_init (void)
+{
+  BYTE ret = CCD_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_init[me] != NULL) || (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccd_init[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccd_exit  =================================================================*/
+int ccd_exit (void)
+{
+  int ret = CCD_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_exit[me] != NULL) || (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccd_exit[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccd_begin  ================================================================*/
+UBYTE* ccd_begin (void)
+{
+  UBYTE* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_begin[me] != NULL) || (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccd_begin[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccd_end  ==================================================================*/
+void ccd_end (void)
+{
+  if (me < 0)
+  {
+    return;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_end[me] != NULL) || (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    (*ptr_ccd_end[me])();
+  }
+  ReleaseMutex (mut[me]);
+}
+
+/* ccd_decodeMsg  ============================================================*/
+BYTE ccd_decodeMsg (UBYTE         entity,
+                    UBYTE         direction,
+                    T_MSGBUF     *mBuf,
+                    UBYTE        *mStruct,
+                    UBYTE         mId)
+{
+  BYTE ret = CCD_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_decodeMsg[me] != NULL) || (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccd_decodeMsg[me])(entity, direction, mBuf, mStruct, mId);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccd_decodeMsgPtr  =========================================================*/
+S8 ccd_decodeMsgPtr (U8   entity,
+		       U8   direction,
+		       U16  l_buf,
+		       U16  o_buf,
+		       U8*  buf,
+		       U8** mStructPtr,
+		       U8   mId)
+{
+  S8 ret = CCD_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_decodeMsgPtr[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccd_decodeMsgPtr[me])(entity, direction, l_buf, o_buf, buf, 
+                                      mStructPtr, mId);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccd_codeMsg  ========================)=====================================*/
+BYTE ccd_codeMsg (UBYTE         entity,
+      UBYTE         direction,
+      T_MSGBUF     *mBuf,
+      UBYTE        *mStruct,
+      UBYTE         mId)
+{
+  BYTE ret = CCD_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_codeMsg[me] != NULL) || (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccd_codeMsg[me])(entity, direction, mBuf, mStruct, mId);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccd_codeMsgPtr  =========================)=================================*/
+S8 ccd_codeMsgPtr(U8   entity,
+      U8   direction,
+      U16* l_buf,
+      U16  o_buf,
+      U8*  buf,
+      U8*  mStruct,
+      U8   mId)
+{
+  S8 ret = CCD_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_codeMsgPtr[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccd_codeMsgPtr[me])(entity, direction, l_buf, o_buf, buf, 
+                                    mStruct, mId);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccd_init_ccddata  =========================================================*/
+ULONG ccd_init_ccddata (void)
+{
+  ULONG ret = CCD_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_init_ccddata[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccd_init_ccddata[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccd_decodeByte  ===========================================================*/
+BYTE ccd_decodeByte (UBYTE* bitstream, USHORT startbit,
+                     USHORT bitlen, UBYTE* value)
+{
+  BYTE ret = CCD_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_decodeByte[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccd_decodeByte[me])(bitstream, startbit, bitlen, value);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccd_codeByte  =============================)===============================*/
+BYTE ccd_codeByte (UBYTE* bitstream, USHORT startbit,
+              		 USHORT bitlen, UBYTE value)
+{
+  BYTE ret = CCD_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_codeByte[me] != NULL) || (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccd_codeByte[me])(bitstream, startbit, bitlen, value);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccd_codeLong  ===)=========================================================*/
+BYTE ccd_codeLong (UBYTE* bitstream, USHORT startbit,
+	                 USHORT bitlen, ULONG value)
+{
+  BYTE ret = CCD_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_codeLong[me] != NULL) || (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccd_codeLong[me])(bitstream, startbit, bitlen, value);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccd_decodeLong  ===========================================================*/
+BYTE ccd_decodeLong (UBYTE* bitstream, USHORT startbit,
+	                   USHORT bitlen, ULONG *value)
+{
+  BYTE ret = CCD_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_decodeLong[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccd_decodeLong[me])(bitstream, startbit, bitlen, value);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccd_bitcopy  ============================)=================================*/
+void ccd_bitcopy (UBYTE     *dest,
+                  UBYTE     *source,
+                  USHORT     bitlen,
+                  USHORT     offset)
+{
+  if (me < 0)
+  {
+    return;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_bitcopy[me] != NULL) || (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      (*ptr_ccd_bitcopy[me])(dest, source, bitlen, offset);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+}
+
+/* ccd_getFirstError  ========================================================*/
+UBYTE ccd_getFirstError (UBYTE entity, USHORT *parlist)
+{
+  UBYTE ret = CCD_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_getFirstError[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccd_getFirstError[me])(entity, parlist);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccd_getNextError  =========================================================*/
+UBYTE ccd_getNextError (UBYTE entity, USHORT *parlist)
+{
+  UBYTE ret = CCD_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_getNextError[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccd_getNextError[me])(entity, parlist);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccd_getFirstFault  ========================================================*/
+ULONG ccd_getFirstFault (T_CCD_ERR_ENTRY **ccd_err_entry)
+{
+  ULONG ret = CCD_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_getFirstFault[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccd_getFirstFault[me])(ccd_err_entry);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccd_getNextFault  =========================================================*/
+ULONG ccd_getNextFault (T_CCD_ERR_ENTRY **ccd_err_entry)
+{
+  ULONG ret = CCD_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_getNextFault[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccd_getNextFault[me])(ccd_err_entry);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccd_free_faultlist  =======================================================*/
+void ccd_free_faultlist (void)
+{
+  if (me < 0)
+  {
+    return;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_free_faultlist[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      (*ptr_ccd_free_faultlist[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+}
+
+/* ccd_get_numFaults  ========================================================*/
+int ccd_get_numFaults ()
+{
+  int ret = CCD_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_get_numFaults[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccd_get_numFaults[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccd_encodeElem  ===========================================================*/
+int  ccd_encodeElem (ULONG  ccdid,
+                     USHORT* l_buf,
+                     USHORT  o_buf,
+                     UCHAR*  buf,
+                     UCHAR*  eStruct)
+{
+  int ret = CCD_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_encodeElem[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccd_encodeElem[me])(ccdid, l_buf, o_buf, buf, eStruct);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* ccd_decodeElem  ===========================================================*/
+int  ccd_decodeElem (ULONG  ccdid,
+                     USHORT  l_buf,
+                     USHORT  o_buf,
+                     UCHAR*  buf,
+                     UCHAR*  eStruct)
+{
+  int ret = CCD_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_ccd_decodeElem[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_ccd_decodeElem[me])(ccdid, l_buf, o_buf, buf, eStruct);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* pdi_createDefContext  =====================================================*/
+T_PDI_CONTEXT* pdi_createDefContext()
+{
+  T_PDI_CONTEXT* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_pdi_createDefContext[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_pdi_createDefContext[me])();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* pdi_createContext  ========================================================*/
+T_PDI_CONTEXT* pdi_createContext(const T_PDI_DECODEINFO* dinfo,
+                                 unsigned int dicount)
+{
+  T_PDI_CONTEXT* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_pdi_createContext[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_pdi_createContext[me])(dinfo, dicount);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* pdi_destroyContext  =======================================================*/
+void pdi_destroyContext(T_PDI_CONTEXT *context)
+{
+  if (me < 0)
+  {
+    return;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_pdi_destroyContext[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      (*ptr_pdi_destroyContext[me])(context);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+}
+
+/* pdi_startPrim  ============================================================*/
+void pdi_startPrim(T_PDI_CONTEXT *context, ULONG opc)
+{
+  if (me < 0)
+  {
+    return;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_pdi_startPrim[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      (*ptr_pdi_startPrim[me])(context, opc);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+}
+
+/* pdi_getDecodeInfo  ========================================================*/
+void pdi_getDecodeInfo(T_PDI_CONTEXT *context, const char *ename,
+                       char *evalue, int evlen, T_PDI *decinfo)
+{
+  if (me < 0)
+  {
+    return;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_pdi_getDecodeInfo[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      (*ptr_pdi_getDecodeInfo[me])(context, ename, evalue, evlen, decinfo);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+}
+
+/* pdi_getEntityByPD  ========================================================*/
+short pdi_getEntityByPD(T_PDI_CONTEXT *context, unsigned char pd)
+{
+  short ret = PDI_DLL_ERROR;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_pdi_getEntityByPD[me] != NULL) ||
+      (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_pdi_getEntityByPD[me])(context, pd);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/* pdi_pd2name  ==============================================================*/
+const char* pdi_pd2name(unsigned char pd)
+{
+  const char* ret = NULL;
+  if (me < 0)
+  {
+    return ret;
+  }
+  WaitForSingleObject (mut[me], INFINITE);
+  if ((ptr_pdi_pd2name[me] != NULL) || (ccddata_ehandler() == CCDDATA_DLL_OK))
+  {
+    __try
+    {
+      ret = (*ptr_pdi_pd2name[me])(pd);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+      // acces violation -> possibly wrong ccddata-DLL
+    }
+  }
+  ReleaseMutex (mut[me]);
+  return ret;
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  ccddata_dllname
++------------------------------------------------------------------------------
+|  Description  :  Deliver name of currently loaded dll
+|
+|  Parameters   :  -
+|
+|  Return       :  lastdll
++------------------------------------------------------------------------------
+*/
+char* ccddata_dllname (void)
+{
+  return lastdll;
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  ccddata_exit
++------------------------------------------------------------------------------
+|  Description  :  Unload ccddata dll and clean pointer to the functions
+|
+|  Parameters   :  -
+|
+|  Return       :  0 on success, otherwise error code
++------------------------------------------------------------------------------
+*/
+
+int ccddata_exit (void)
+{
+  if (me < 0)
+  {
+    return CCDDATA_DLL_REGISTER;
+  }
+
+  ccddata_detach (me, 1);
+
+  CloseHandle (mut[me]);
+  CloseHandle (initlock);
+  ptrindex[me] = 0;
+  me = -1;
+
+  return CCDDATA_DLL_OK;
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  ccddata_init
++------------------------------------------------------------------------------
+|  Description  :  Load ccddata dll and initialize pointer to the functions
+|
+|  Parameters   :  dllname - name of the ccddata dll or NULL
+|                  reload  - if set, the ccddata dll will be switched
+|
+|  Return       :  0 on success, otherwise error code
++------------------------------------------------------------------------------
+*/
+
+int ccddata_init (const char* dllname,
+                  int reload,
+                  void (*ccddata_init_notify)(void),
+                  void (*ccddata_exit_notify)(void))
+{
+  int ret = CCDDATA_DLL_OK;
+
+  if (cdll[me] && !reload)
+  {
+    return CCDDATA_DLL_ALREADY;
+  }
+
+  if ((initlock = ccddata_init_lock ()) == 0)
+  {
+    return CCDDATA_DLL_REGISTER;
+  }
+
+  if (ccddata_register () < 0)
+  {
+    ret = CCDDATA_DLL_REGISTER;
+  }
+  else
+  {
+    ccddata_i_notify = ccddata_init_notify;
+    ccddata_x_notify = ccddata_exit_notify;
+
+    if (dllname)
+    {
+      /* build full path of DLL */
+      char name[MAX_PATH+1];
+      LPTSTR filepart;
+      DWORD len=SearchPath(
+        NULL,      // pointer to search path
+        dllname,  // pointer to filename
+        NULL, // pointer to extension
+        MAX_PATH, // size, in characters, of buffer
+        name,     // pointer to buffer for found filename
+        &filepart   // pointer to pointer to file component
+      );
+      if (!len)
+      {
+        strcpy(name, dllname);
+      }
+      
+      if (!lastdll[0])
+      {
+        // no DLL has been loaded yet
+        reload=1;
+      }
+      else if (strcmp (lastdll, name)==0)
+      {
+        // the correct DLL is already in use
+        reload=0;
+      }
+
+      if (reload)
+      {
+        // we want to load a new DLL but save the current one ... just in case
+        char old_dll[MAX_PATH]="";
+        strcpy (old_dll, lastdll);
+        strcpy (lastdll, name);
+        (void) ccddata_detach (me, 1);
+        ret = ccddata_attach (me);
+        if (ret == CCDDATA_DLL_OK)
+        {
+          // now inform the other applications
+          (void)ccddata_clean ();
+        }
+        else
+        {
+          // upps, didn't work
+          strcpy (lastdll, old_dll);
+          (void) ccddata_attach (me);
+        }
+      }
+      else
+      {
+        // we just attach to the already loaded DLL
+        ret = ccddata_attach (me);
+      }
+
+    }
+  }
+
+  ReleaseMutex (initlock);
+
+  return ret;
+}
+/*==== END OF FILE ===========================================================*/